fix: resolve ssl certificate port issue

.github/workflows/check-build.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Set up Node
         uses: actions/setup-node@v4
         with:
-          node-version: 24
+          node-version: 22
 
       - name: Install client dependencies
         working-directory: client
@@ -29,7 +29,7 @@ jobs:
       - name: Set up Node
         uses: actions/setup-node@v4
         with:
-          node-version: 24
+          node-version: 22
 
       - name: Install server dependencies
         working-directory: server

.github/workflows/check-format.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Set up Node
         uses: actions/setup-node@v4
         with:
-          node-version: 24
+          node-version: 22
 
       - name: Install client dependencies
         working-directory: client
@@ -30,7 +30,7 @@ jobs:
       - name: Set up Node
         uses: actions/setup-node@v4
         with:
-          node-version: 24
+          node-version: 22
 
       - name: Install server dependencies
         working-directory: server

.github/workflows/check-tests.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Set up Node
         uses: actions/setup-node@v4
         with:
-          node-version: 24
+          node-version: 22
 
       - name: Install server dependencies
         working-directory: server

CLAUDE.md

@@ -62,7 +62,7 @@ VITE_APP_LOG_LEVEL="debug"
 
 ### Monorepo Structure
 - `/client` - React 18 + TypeScript + Vite + MUI frontend
-- `/server` - Node.js 24+ + Express + TypeScript backend
+- `/server` - Node.js 20+ + Express + TypeScript backend
 - `/docker` - Multi-environment Docker configs (dev, staging, prod, arm, mono)
 
 ### Backend Layers

client/package.json

@@ -2,10 +2,6 @@
 	"name": "client",
 	"private": true,
 	"version": "3.12.0",
-	"engines": {
-		"node": ">=24",
-		"npm": ">=11"
-	},
 	"type": "module",
 	"scripts": {
 		"lockfile": "docker run --rm -v \"$PWD\":/w -w /w $(grep -m1 -o 'node:[^ ]*' ../docker/Dockerfile) npm install --package-lock-only",

client/src/Features/UI/uiSlice.ts

@@ -1,16 +1,10 @@
-import {
-	dashboardCardKeys,
-	type DashboardCardKey,
-	type DashboardSortOrder,
-} from "@/Types/Dashboard";
-import type { SortOrder } from "@/Types/Query";
+import { dashboardCardKeys, type DashboardCardKey } from "@/Types/Dashboard";
 import { createSlice, type PayloadAction } from "@reduxjs/toolkit";
 
 type ThemeMode = "light" | "dark";
 type ChartType = "histogram" | "line";
 
 type TableName =
-	| "dashboard"
 	| "monitors"
 	| "team"
 	| "maintenance"
@@ -21,8 +15,6 @@ type TableName =
 
 interface TableState {
 	rowsPerPage: number;
-	sortField?: string;
-	sortOrder?: SortOrder;
 }
 
 interface SidebarState {
@@ -30,7 +22,6 @@ interface SidebarState {
 }
 
 interface UIState {
-	dashboard: TableState;
 	monitors: TableState;
 	pagespeed: TableState;
 	team: TableState;
@@ -47,7 +38,6 @@ interface UIState {
 	starPromptOpen: boolean;
 	chartType: ChartType;
 	dashboardVisibleCards: DashboardCardKey[];
-	dashboardUptimeSortOrder: DashboardSortOrder;
 }
 
 const initialMode: ThemeMode = window?.matchMedia?.("(prefers-color-scheme: dark)")
@@ -56,9 +46,6 @@ const initialMode: ThemeMode = window?.matchMedia?.("(prefers-color-scheme: dark
 	: "light";
 
 const initialState: UIState = {
-	dashboard: {
-		rowsPerPage: 100,
-	},
 	monitors: {
 		rowsPerPage: 10,
 	},
@@ -91,7 +78,6 @@ const initialState: UIState = {
 	starPromptOpen: true,
 	chartType: "histogram",
 	dashboardVisibleCards: [...dashboardCardKeys],
-	dashboardUptimeSortOrder: "ascending",
 };
 
 const uiSlice = createSlice({
@@ -108,14 +94,6 @@ const uiSlice = createSlice({
 			const { table, value } = action.payload;
 			state[table].rowsPerPage = value;
 		},
-		setTableSort: (
-			state,
-			action: PayloadAction<{ table: TableName; field: string; order: SortOrder }>
-		) => {
-			const { table, field, order } = action.payload;
-			state[table].sortField = field;
-			state[table].sortOrder = order;
-		},
 		toggleSidebar: (state) => {
 			state.sidebar.collapsed = !state.sidebar.collapsed;
 		},
@@ -146,9 +124,6 @@ const uiSlice = createSlice({
 		setDashboardVisibleCards: (state, action: PayloadAction<DashboardCardKey[]>) => {
 			state.dashboardVisibleCards = action.payload;
 		},
-		setDashboardUptimeSortOrder: (state, action: PayloadAction<DashboardSortOrder>) => {
-			state.dashboardUptimeSortOrder = action.payload;
-		},
 	},
 });
 
@@ -156,7 +131,6 @@ export type { UIState, ThemeMode, ChartType, TableName };
 export default uiSlice.reducer;
 export const {
 	setRowsPerPage,
-	setTableSort,
 	toggleSidebar,
 	setCollapsed,
 	setMode,
@@ -167,5 +141,4 @@ export const {
 	setStarPromptOpen,
 	setChartType,
 	setDashboardVisibleCards,
-	setDashboardUptimeSortOrder,
 } = uiSlice.actions;

client/src/Hooks/useMonitorForm.ts

@@ -85,8 +85,6 @@ export const getMonitorDefaults = (
 				dockerTlsKey: "",
 				dockerTlsKeySet: data?.dockerTlsKeySet ?? false,
 				dockerLogsEnabled: data?.dockerLogsEnabled ?? false,
-				dockerAlertOnStopped: data?.dockerAlertOnStopped ?? false,
-				dockerAlertOnUnhealthy: data?.dockerAlertOnUnhealthy ?? false,
 			};
 			break;
 		case "game":

client/src/Hooks/useMonitorListController.ts

@@ -1,4 +1,4 @@
-import { setRowsPerPage, setTableSort, type TableName } from "@/Features/UI/uiSlice";
+import { setRowsPerPage, type TableName } from "@/Features/UI/uiSlice";
 import { useDelete, useGet } from "@/Hooks/UseApi";
 import { useBulkMonitorActions } from "@/Hooks/useBulkMonitorActions";
 import useDebounce from "@/Hooks/useDebounce";
@@ -10,7 +10,6 @@ import {
 	type MonitorType,
 } from "@/Types/Monitor";
 import type { Tag } from "@/Types/Tag";
-import type { SortOrder } from "@/Types/Query";
 import { useCallback, useMemo, useState } from "react";
 import { useDispatch, useSelector } from "react-redux";
 
@@ -25,12 +24,10 @@ interface MonitorListConfig {
 
 export const useMonitorListController = (config: MonitorListConfig) => {
 	const dispatch = useDispatch();
-	const tableState = useSelector(
-		(state: RootState) => state.ui?.[config.rowsPerPageTable]
+	const rowsPerPage = useSelector(
+		(state: RootState) =>
+			state.ui?.[config.rowsPerPageTable]?.rowsPerPage ?? config.rowsPerPageDefault
 	);
-	const rowsPerPage = tableState?.rowsPerPage ?? config.rowsPerPageDefault;
-	const sortField = tableState?.sortField ?? config.initialSortField ?? "";
-	const sortOrder = tableState?.sortOrder ?? "asc";
 
 	// Filter states
 	const [selectedTypes, setSelectedTypes] = useState<MonitorType[]>([]);
@@ -39,6 +36,8 @@ export const useMonitorListController = (config: MonitorListConfig) => {
 	const [selectedTags, setSelectedTags] = useState<string[]>([]);
 	const [page, setPage] = useState<number>(0);
 	const [search, setSearch] = useState<string>("");
+	const [sortField, setSortField] = useState<string>(config.initialSortField ?? "");
+	const [sortOrder, setSortOrder] = useState<"asc" | "desc">("asc");
 	const [selectedMonitor, setSelectedMonitor] = useState<Monitor | null>(null);
 	const debouncedSearch = useDebounce<string>(search, 300);
 
@@ -136,11 +135,6 @@ export const useMonitorListController = (config: MonitorListConfig) => {
 		setPage(0);
 	};
 
-	const setSort = (field: string, order: SortOrder) => {
-		dispatch(setTableSort({ field, order, table: config.rowsPerPageTable }));
-		setPage(0);
-	};
-
 	// Check for active filters
 	const hasActiveFilters = Boolean(
 		selectedTypes.length > 0 ||
@@ -195,8 +189,9 @@ export const useMonitorListController = (config: MonitorListConfig) => {
 		rowsPerPage,
 		handleSetRowsPerPage,
 		sortField,
+		setSortField,
 		sortOrder,
-		setSort,
+		setSortOrder,
 
 		// Delete
 		selectedMonitor,

client/src/Pages/CreateMonitor/index.tsx

@@ -617,6 +617,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				{showStep(0) && (
 					<ConfigBox
 						title={t("pages.createMonitor.form.general.title")}
@@ -757,6 +758,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				{showStep(0) && watchedType === "docker" && isDockerTlsUrl(watchedUrl) && (
 					<ConfigBox
 						title={t("pages.createMonitor.form.dockerTls.title")}
@@ -814,6 +816,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				{showStep(1) && (
 					<ConfigBox
 						title={t("pages.createMonitor.form.frequency.title")}
@@ -834,6 +837,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				{/* Alert Thresholds - only for hardware type */}
 				{watchedType === "hardware" && showStep(1) && (
 					<ConfigBox
@@ -889,6 +893,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				{showStep(1) && (
 					<ConfigBox
 						title={t("pages.createMonitor.form.incidents.title")}
@@ -915,6 +920,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				{showStep(1) && (
 					<ConfigBox
 						title={t("pages.createMonitor.form.notifications.title")}
@@ -927,6 +933,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				{showStep(1) && (
 					<ConfigBox
 						title={t("pages.createMonitor.form.tags.title")}
@@ -953,6 +960,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				{showStep(1) && watchedType === "docker" && !isCaptureDocker && (
 					<ConfigBox
 						title={t("pages.createMonitor.form.dockerLogs.title")}
@@ -965,28 +973,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
-				{showStep(1) && watchedType === "docker" && (
-					<ConfigBox
-						title={t("pages.createMonitor.form.dockerAlerts.title")}
-						subtitle={t("pages.createMonitor.form.dockerAlerts.description")}
-						rightContent={
-							<Stack gap={theme.spacing(LAYOUT.MD)}>
-								<FormSwitchField
-									name="dockerAlertOnStopped"
-									label={t(
-										"pages.createMonitor.form.dockerAlerts.option.onStopped.label"
-									)}
-								/>
-								<FormSwitchField
-									name="dockerAlertOnUnhealthy"
-									label={t(
-										"pages.createMonitor.form.dockerAlerts.option.onUnhealthy.label"
-									)}
-								/>
-							</Stack>
-						}
-					/>
-				)}
+
 				{showStep(2) &&
 					(watchedType === "http" ||
 						watchedType === "grpc" ||
@@ -1002,6 +989,7 @@ const CreateMonitorPage = () => {
 							}
 						/>
 					)}
+
 				{showStep(2) && watchedType === "http" && (
 					<ConfigBox
 						title={t("pages.createMonitor.form.advanced.title")}
@@ -1101,6 +1089,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				{showStep(2) && supportsGeoCheck(watchedType) && (
 					<ConfigBox
 						title={t("pages.createMonitor.form.geoChecks.title")}
@@ -1133,6 +1122,7 @@ const CreateMonitorPage = () => {
 						}
 					/>
 				)}
+
 				<Stack
 					direction="row"
 					justifyContent={!isEditMode ? "space-between" : "flex-end"}

client/src/Pages/Dashboard/components/EditCardsModal.tsx

@@ -1,11 +1,8 @@
-import { useMemo, useState } from "react";
+import { useState } from "react";
 import Stack from "@mui/material/Stack";
 import FormControlLabel from "@mui/material/FormControlLabel";
-import Typography from "@mui/material/Typography";
-import { useTheme } from "@mui/material/styles";
 import { useTranslation } from "react-i18next";
 import { Checkbox, Dialog } from "@/Components/inputs";
-import { LAYOUT } from "@/Utils/Theme/constants";
 import { type DashboardCardKey, dashboardCardKeys } from "@/Types/Dashboard";
 
 interface EditCardsModalProps {
@@ -21,19 +18,16 @@ export const EditCardsModal = ({
 	onClose,
 	onSave,
 }: EditCardsModalProps) => {
-	const theme = useTheme();
 	const { t } = useTranslation();
-	const [cardsSelection, setCardsSelection] = useState<Set<DashboardCardKey>>(
-		new Set(visibleCards)
-	);
+	const [draft, setDraft] = useState<Set<DashboardCardKey>>(new Set(visibleCards));
 
 	const handleClose = () => {
-		setCardsSelection(new Set(visibleCards));
+		setDraft(new Set(visibleCards));
 		onClose();
 	};
 
 	const handleToggle = (key: DashboardCardKey) => {
-		setCardsSelection((prev) => {
+		setDraft((prev) => {
 			const next = new Set(prev);
 			if (next.has(key)) {
 				next.delete(key);
@@ -44,40 +38,26 @@ export const EditCardsModal = ({
 		});
 	};
 
-	const sortedCardKeys = useMemo(
-		() =>
-			[...dashboardCardKeys].sort((a, b) =>
-				t(`pages.dashboard.cards.${a}`).localeCompare(t(`pages.dashboard.cards.${b}`))
-			),
-		[t]
-	);
-
 	return (
 		<Dialog
 			open={open}
 			title={t("pages.dashboard.editCardsModal.title")}
 			content={t("pages.dashboard.editCardsModal.description")}
 			onCancel={handleClose}
-			onConfirm={() => onSave(cardsSelection)}
+			onConfirm={() => onSave(draft)}
 			confirmText={t("pages.dashboard.editCardsModal.done")}
 			maxWidth="xs"
 			fullWidth
 		>
-			<Stack gap={theme.spacing(LAYOUT.XXS)}>
-				<Typography
-					variant="eyebrow"
-					color={theme.palette.text.disabled}
-				>
-					{t("pages.dashboard.editCardsModal.groups.uptime")}
-				</Typography>
-				{sortedCardKeys.map((key: DashboardCardKey) => (
+			<Stack>
+				{dashboardCardKeys.map((key: DashboardCardKey) => (
 					<FormControlLabel
 						key={key}
 						label={t(`pages.dashboard.cards.${key}`)}
 						control={
 							<Checkbox
-								checked={cardsSelection.has(key)}
-								disabled={cardsSelection.has(key) && cardsSelection.size === 1}
+								checked={draft.has(key)}
+								disabled={draft.has(key) && draft.size === 1}
 								onChange={() => handleToggle(key)}
 							/>
 						}

client/src/Pages/Dashboard/components/cards/CurrentlyDownCard.tsx

@@ -1,58 +0,0 @@
-import Stack from "@mui/material/Stack";
-import Typography from "@mui/material/Typography";
-import { useTheme } from "@mui/material/styles";
-import { useTranslation } from "react-i18next";
-import { DashboardCard } from "@/Pages/Dashboard/components/DashboardCard";
-import { Dot } from "@/Components/design-elements";
-import { typographyLevels } from "@/Utils/Theme/Palette";
-import { LAYOUT } from "@/Utils/Theme/constants";
-import type { Monitor } from "@/Types/Monitor";
-
-interface CurrentlyDownCardProps {
-	monitors: Monitor[];
-}
-
-export const CurrentlyDownCard = ({ monitors }: CurrentlyDownCardProps) => {
-	const theme = useTheme();
-	const { t } = useTranslation();
-
-	const downMonitors = monitors.filter((monitor) => monitor.status === "down");
-
-	return (
-		<DashboardCard
-			title={t("pages.dashboard.cards.currentlyDown")}
-			topRight={downMonitors.length > 0 ? downMonitors.length : undefined}
-		>
-			{downMonitors.length === 0 ? (
-				<Typography
-					fontSize={typographyLevels.m}
-					color={theme.palette.text.disabled}
-				>
-					{t("pages.dashboard.currentlyDown.empty")}
-				</Typography>
-			) : (
-				<Stack gap={theme.spacing(LAYOUT.SM)}>
-					{downMonitors.map((monitor) => (
-						<Stack
-							key={monitor.id}
-							direction="row"
-							alignItems="center"
-							gap={theme.spacing(LAYOUT.XS)}
-						>
-							<Dot color={theme.palette.error.main} />
-							<Typography
-								fontSize={typographyLevels.m}
-								color={theme.palette.text.primary}
-								overflow="hidden"
-								textOverflow="ellipsis"
-								whiteSpace="nowrap"
-							>
-								{monitor.name}
-							</Typography>
-						</Stack>
-					))}
-				</Stack>
-			)}
-		</DashboardCard>
-	);
-};

client/src/Pages/Dashboard/components/cards/UptimeCard.tsx

@@ -1,90 +0,0 @@
-import IconButton from "@mui/material/IconButton";
-import Stack from "@mui/material/Stack";
-import Typography from "@mui/material/Typography";
-import { useTheme } from "@mui/material/styles";
-import { useTranslation } from "react-i18next";
-import { useDispatch, useSelector } from "react-redux";
-import { ArrowDown, ArrowUp } from "lucide-react";
-import { Icon } from "@/Components/design-elements";
-import { DashboardCard } from "@/Pages/Dashboard/components/DashboardCard";
-import { BarRow } from "@/Pages/Dashboard/components/cards/BarRow";
-import { getUptimePercentageColor } from "@/Utils/MonitorUtils";
-import { formatPercentage } from "@/Utils/FormatUtils";
-import { typographyLevels } from "@/Utils/Theme/Palette";
-import { LAYOUT } from "@/Utils/Theme/constants";
-import { setDashboardUptimeSortOrder } from "@/Features/UI/uiSlice";
-import type { Monitor } from "@/Types/Monitor";
-import type { AppDispatch, RootState } from "@/store";
-
-const TOP_N = 5;
-
-interface UptimeCardProps {
-	monitors: Monitor[];
-}
-
-export const UptimeCard = ({ monitors }: UptimeCardProps) => {
-	const theme = useTheme();
-	const { t } = useTranslation();
-	const dispatch = useDispatch<AppDispatch>();
-	const sortOrder = useSelector((state: RootState) => state.ui.dashboardUptimeSortOrder);
-
-	const direction = sortOrder === "ascending" ? 1 : -1;
-	const ranked = monitors
-		.filter((monitor) => monitor.status !== "paused")
-		.filter(
-			(monitor): monitor is Monitor & { uptimePercentage: number } =>
-				typeof monitor.uptimePercentage === "number"
-		)
-		.sort((a, b) => direction * (a.uptimePercentage - b.uptimePercentage))
-		.slice(0, TOP_N);
-
-	return (
-		<DashboardCard
-			title={t("pages.dashboard.cards.uptime")}
-			topRight={
-				<IconButton
-					size="small"
-					aria-label={t("pages.dashboard.uptimeCard.toggleSortOrder")}
-					onClick={() =>
-						dispatch(
-							setDashboardUptimeSortOrder(
-								sortOrder === "ascending" ? "descending" : "ascending"
-							)
-						)
-					}
-				>
-					<Icon
-						icon={sortOrder === "ascending" ? ArrowUp : ArrowDown}
-						size={16}
-						color={theme.palette.text.secondary}
-					/>
-				</IconButton>
-			}
-		>
-			{ranked.length === 0 ? (
-				<Typography
-					fontSize={typographyLevels.m}
-					color={theme.palette.text.disabled}
-				>
-					{t("pages.dashboard.noData")}
-				</Typography>
-			) : (
-				<Stack gap={theme.spacing(LAYOUT.SM)}>
-					{ranked.map((monitor) => {
-						const paletteKey = getUptimePercentageColor(monitor.uptimePercentage);
-						const color = theme.palette[paletteKey].main;
-						return (
-							<BarRow
-								key={monitor.id}
-								label={monitor.name}
-								value={formatPercentage(monitor.uptimePercentage)}
-								fillRatio={monitor.uptimePercentage}
-								valueColor={color}
-							/>
-						);
-					})}
-				</Stack>
-			)}
-		</DashboardCard>
-	);
-};

client/src/Pages/Dashboard/index.tsx

@@ -14,8 +14,6 @@ import { setDashboardVisibleCards } from "@/Features/UI/uiSlice";
 import type { RootState, AppDispatch } from "@/store";
 
 import { MonitorStatusCard } from "@/Pages/Dashboard/components/cards/MonitorStatusCard";
-import { CurrentlyDownCard } from "@/Pages/Dashboard/components/cards/CurrentlyDownCard";
-import { UptimeCard } from "@/Pages/Dashboard/components/cards/UptimeCard";
 import { MonitorsByTypeCard } from "@/Pages/Dashboard/components/cards/MonitorsByTypeCard";
 import { EditCardsModal } from "@/Pages/Dashboard/components/EditCardsModal";
 import { type DashboardCardKey, dashboardCardKeys } from "@/Types/Dashboard";
@@ -34,7 +32,7 @@ const Dashboard = () => {
 		types: [...MonitorTypes],
 		checksLimit: 1,
 		refreshInterval: 30000,
-		rowsPerPageTable: "dashboard",
+		rowsPerPageTable: "monitors",
 		rowsPerPageDefault: 100,
 	});
 
@@ -50,8 +48,6 @@ const Dashboard = () => {
 
 	const cardComponents: Record<DashboardCardKey, ReactNode> = {
 		monitorStatus: <MonitorStatusCard summary={summary} />,
-		currentlyDown: <CurrentlyDownCard monitors={monitors ?? []} />,
-		uptime: <UptimeCard monitors={monitors ?? []} />,
 		monitorsByType: <MonitorsByTypeCard monitorsByType={monitorsByType} />,
 	};
 

client/src/Pages/Docker/Monitors/Components/DockerMonitorsTable.tsx

@@ -8,7 +8,6 @@ import {
 	ColoredLabel,
 } from "@/Components/design-elements";
 import { SPACING } from "@/Utils/Theme/constants";
-import { getNextMonitorSort } from "@/Utils/MonitorUtils";
 import type { Header } from "@/Components/design-elements/Table";
 import { ActionsMenu, type ActionMenuItem } from "@/Components/actions-menu";
 import { ArrowUp, ArrowDown } from "lucide-react";
@@ -21,7 +20,6 @@ import { usePost } from "@/Hooks/UseApi";
 
 import type { Monitor } from "@/Types/Monitor";
 import type { Tag } from "@/Types/Tag";
-import type { SortOrder } from "@/Types/Query";
 import type { DockerContainerSummary } from "@/Types/Check";
 import { Checkbox } from "@/Components/inputs";
 
@@ -36,8 +34,9 @@ interface DockerMonitorsTableProps {
 	refetch: () => void;
 	setSelectedMonitor: (monitor: Monitor | null) => void;
 	sortField: string;
-	sortOrder: SortOrder;
-	setSort: (field: string, order: SortOrder) => void;
+	setSortField: (field: string) => void;
+	sortOrder: "asc" | "desc";
+	setSortOrder: (order: "asc" | "desc") => void;
 	count: number;
 	page: number;
 	setPage: (page: number) => void;
@@ -53,8 +52,9 @@ export const DockerMonitorsTable = ({
 	refetch,
 	setSelectedMonitor,
 	sortField,
+	setSortField,
 	sortOrder,
-	setSort,
+	setSortOrder,
 	count,
 	page,
 	setPage,
@@ -105,8 +105,14 @@ export const DockerMonitorsTable = ({
 	const handleSort = (e: React.MouseEvent, field: string) => {
 		e.preventDefault();
 		e.stopPropagation();
-		const nextSort = getNextMonitorSort(field, sortField, sortOrder);
-		setSort(nextSort.field, nextSort.order);
+		if (sortField === field) {
+			const newOrder = sortOrder === "asc" ? "desc" : "asc";
+			setSortOrder(newOrder);
+		} else {
+			setSortField(field);
+			setSortOrder("asc");
+		}
+		refetch();
 	};
 
 	const getActions = (monitor: Monitor): ActionMenuItem[] => {

client/src/Pages/Docker/Monitors/index.tsx

@@ -19,7 +19,6 @@ const DockerMonitorsPage = () => {
 			controller={c}
 			bulkActions
 			showTypeFilter={false}
-			summaryProps={{ showBreached: true }}
 		>
 			<DockerMonitorsTable
 				monitors={c.monitors || []}
@@ -31,8 +30,9 @@ const DockerMonitorsPage = () => {
 				setPage={c.setPage}
 				rowsPerPage={c.rowsPerPage}
 				sortField={c.sortField}
+				setSortField={c.setSortField}
 				sortOrder={c.sortOrder}
-				setSort={c.setSort}
+				setSortOrder={c.setSortOrder}
 				setRowsPerPage={c.handleSetRowsPerPage}
 				selectedRows={c.selectedRows}
 				onSelectionChange={c.setSelectedRows}

client/src/Pages/Infrastructure/Monitors/Components/MonitorsTable.tsx

@@ -9,7 +9,6 @@ import {
 	ColoredLabel,
 } from "@/Components/design-elements";
 import { SPACING } from "@/Utils/Theme/constants";
-import { getNextMonitorSort } from "@/Utils/MonitorUtils";
 import type { Header } from "@/Components/design-elements/Table";
 import { ActionsMenu, type ActionMenuItem } from "@/Components/actions-menu";
 import { ArrowUp, ArrowDown } from "lucide-react";
@@ -22,7 +21,6 @@ import { usePost } from "@/Hooks/UseApi";
 
 import type { Monitor } from "@/Types/Monitor";
 import type { Tag } from "@/Types/Tag";
-import type { SortOrder } from "@/Types/Query";
 import { Checkbox } from "@/Components/inputs";
 
 interface InfraMonitorsTableProps {
@@ -31,8 +29,9 @@ interface InfraMonitorsTableProps {
 	refetch: () => void;
 	setSelectedMonitor: (monitor: Monitor | null) => void;
 	sortField: string;
-	sortOrder: SortOrder;
-	setSort: (field: string, order: SortOrder) => void;
+	setSortField: (field: string) => void;
+	sortOrder: "asc" | "desc";
+	setSortOrder: (order: "asc" | "desc") => void;
 	count: number;
 	page: number;
 	setPage: (page: number) => void;
@@ -48,8 +47,9 @@ export const InfraMonitorsTable = ({
 	refetch,
 	setSelectedMonitor,
 	sortField,
+	setSortField,
 	sortOrder,
-	setSort,
+	setSortOrder,
 	count,
 	page,
 	setPage,
@@ -100,8 +100,14 @@ export const InfraMonitorsTable = ({
 	const handleSort = (e: React.MouseEvent, field: string) => {
 		e.preventDefault();
 		e.stopPropagation();
-		const nextSort = getNextMonitorSort(field, sortField, sortOrder);
-		setSort(nextSort.field, nextSort.order);
+		if (sortField === field) {
+			const newOrder = sortOrder === "asc" ? "desc" : "asc";
+			setSortOrder(newOrder);
+		} else {
+			setSortField(field);
+			setSortOrder("asc");
+		}
+		refetch();
 	};
 
 	const getActions = (monitor: Monitor): ActionMenuItem[] => {

client/src/Pages/Infrastructure/Monitors/index.tsx

@@ -31,8 +31,9 @@ const InfrastructureMonitors = () => {
 				setPage={c.setPage}
 				rowsPerPage={c.rowsPerPage}
 				sortField={c.sortField}
+				setSortField={c.setSortField}
 				sortOrder={c.sortOrder}
-				setSort={c.setSort}
+				setSortOrder={c.setSortOrder}
 				setRowsPerPage={c.handleSetRowsPerPage}
 				selectedRows={c.selectedRows}
 				onSelectionChange={c.setSelectedRows}

client/src/Pages/PageSpeed/Monitors/Components/PageSpeedMonitorsTable.tsx

@@ -9,7 +9,6 @@ import {
 	ColoredLabel,
 } from "@/Components/design-elements";
 import { LAYOUT, SPACING } from "@/Utils/Theme/constants";
-import { getNextMonitorSort } from "@/Utils/MonitorUtils";
 import { HistogramPageSpeed } from "@/Components/monitors";
 import { ArrowDown, ArrowUp } from "lucide-react";
 import type { Header } from "@/Components/design-elements/Table";
@@ -23,7 +22,6 @@ import { usePatch } from "@/Hooks/UseApi";
 
 import type { Monitor, MonitorWithChecks } from "@/Types/Monitor";
 import type { Tag } from "@/Types/Tag";
-import type { SortOrder } from "@/Types/Query";
 import type { ActionMenuItem } from "@/Components/actions-menu";
 
 export const PageSpeedMonitorsTable = ({
@@ -32,8 +30,9 @@ export const PageSpeedMonitorsTable = ({
 	refetch,
 	setSelectedMonitor,
 	sortField,
+	setSortField,
 	sortOrder,
-	setSort,
+	setSortOrder,
 	count,
 	page,
 	setPage,
@@ -45,8 +44,9 @@ export const PageSpeedMonitorsTable = ({
 	refetch: Function;
 	setSelectedMonitor: Function;
 	sortField: string;
-	sortOrder: SortOrder;
-	setSort: (field: string, order: SortOrder) => void;
+	setSortField: (field: string) => void;
+	sortOrder: "asc" | "desc";
+	setSortOrder: (order: "asc" | "desc") => void;
 	count: number;
 	page: number;
 	setPage: (page: number) => void;
@@ -81,8 +81,14 @@ export const PageSpeedMonitorsTable = ({
 	const handleSort = (e: any, field: string) => {
 		e.preventDefault();
 		e.stopPropagation();
-		const nextSort = getNextMonitorSort(field, sortField, sortOrder);
-		setSort(nextSort.field, nextSort.order);
+		if (sortField === field) {
+			const newOrder = sortOrder === "asc" ? "desc" : "asc";
+			setSortOrder(newOrder);
+		} else {
+			setSortField(field);
+			setSortOrder("asc");
+		}
+		refetch();
 	};
 
 	const getActions = (monitor: Monitor): ActionMenuItem[] => {

client/src/Pages/PageSpeed/Monitors/index.tsx

@@ -46,8 +46,9 @@ const PageSpeedMonitorsPage = () => {
 				setPage={c.setPage}
 				rowsPerPage={c.rowsPerPage}
 				sortField={c.sortField}
+				setSortField={c.setSortField}
 				sortOrder={c.sortOrder}
-				setSort={c.setSort}
+				setSortOrder={c.setSortOrder}
 				setRowsPerPage={c.handleSetRowsPerPage}
 			/>
 		</MonitorListPage>

client/src/Pages/Uptime/Monitors/Components/UptimeMonitorsTable.tsx

@@ -24,9 +24,8 @@ import type { ActionMenuItem } from "@/Components/actions-menu";
 import type { RootState } from "@/Types/state";
 import { Checkbox } from "@/Components/inputs";
 import type { Tag } from "@/Types/Tag";
-import type { SortOrder } from "@/Types/Query";
 import { SPACING } from "@/Utils/Theme/constants";
-import { getNextMonitorSort, getUptimePercentageColor } from "@/Utils/MonitorUtils";
+import { getUptimePercentageColor } from "@/Utils/MonitorUtils";
 import { formatPercentage } from "@/Utils/FormatUtils";
 
 interface MonitorTableProps {
@@ -35,8 +34,9 @@ interface MonitorTableProps {
 	refetch: () => void;
 	setSelectedMonitor: (monitor: Monitor | null) => void;
 	sortField: string;
-	sortOrder: SortOrder;
-	setSort: (field: string, order: SortOrder) => void;
+	setSortField: (field: string) => void;
+	sortOrder: "asc" | "desc";
+	setSortOrder: (order: "asc" | "desc") => void;
 	count: number;
 	page: number;
 	setPage: (page: number) => void;
@@ -52,8 +52,9 @@ export const MonitorTable = ({
 	refetch,
 	setSelectedMonitor,
 	sortField,
+	setSortField,
 	sortOrder,
-	setSort,
+	setSortOrder,
 	count,
 	page,
 	setPage,
@@ -90,8 +91,14 @@ export const MonitorTable = ({
 	const handleSort = (e: React.MouseEvent, field: string) => {
 		e.preventDefault();
 		e.stopPropagation();
-		const nextSort = getNextMonitorSort(field, sortField, sortOrder);
-		setSort(nextSort.field, nextSort.order);
+		if (sortField === field) {
+			const newOrder = sortOrder === "asc" ? "desc" : "asc";
+			setSortOrder(newOrder);
+		} else {
+			setSortField(field);
+			setSortOrder("asc");
+		}
+		refetch();
 	};
 
 	const isBrowserOpenable = (monitor: Monitor): boolean => {

client/src/Pages/Uptime/Monitors/index.tsx

@@ -30,8 +30,9 @@ const UptimeMonitorsPage = () => {
 				setPage={monitorListController.setPage}
 				rowsPerPage={monitorListController.rowsPerPage}
 				sortField={monitorListController.sortField}
+				setSortField={monitorListController.setSortField}
 				sortOrder={monitorListController.sortOrder}
-				setSort={monitorListController.setSort}
+				setSortOrder={monitorListController.setSortOrder}
 				setRowsPerPage={monitorListController.handleSetRowsPerPage}
 				selectedRows={monitorListController.selectedRows}
 				onSelectionChange={monitorListController.setSelectedRows}

client/src/Types/Dashboard.ts

@@ -1,10 +1,2 @@
-export const dashboardCardKeys = [
-	"monitorStatus",
-	"currentlyDown",
-	"uptime",
-	"monitorsByType",
-] as const;
+export const dashboardCardKeys = ["monitorStatus", "monitorsByType"] as const;
 export type DashboardCardKey = (typeof dashboardCardKeys)[number];
-
-export const dashboardSortOrders = ["ascending", "descending"] as const;
-export type DashboardSortOrder = (typeof dashboardSortOrders)[number];

client/src/Types/Monitor.ts

@@ -169,8 +169,6 @@ export interface Monitor {
 	geoCheckLocations?: GeoContinent[];
 	geoCheckInterval?: number;
 	dockerLogsEnabled?: boolean;
-	dockerAlertOnStopped?: boolean;
-	dockerAlertOnUnhealthy?: boolean;
 	dockerTlsCa?: string;
 	dockerTlsCert?: string;
 	dockerTlsKeySet?: boolean;

client/src/Types/Query.ts

@@ -1,5 +1,2 @@
 export const DateRanges = ["recent", "hour", "day", "week", "month", "all"] as const;
 export type DateRange = (typeof DateRanges)[number];
-
-export const SortOrders = ["asc", "desc"] as const;
-export type SortOrder = (typeof SortOrders)[number];

client/src/Utils/MonitorUtils.ts

@@ -1,5 +1,4 @@
 import type { MonitorStatus, MonitorType } from "@/Types/Monitor";
-import type { SortOrder } from "@/Types/Query";
 import type { PaletteKey } from "@/Utils/Theme/Theme";
 import type { ValueType } from "@/Components/design-elements/StatusLabel";
 import {
@@ -11,16 +10,6 @@ import {
 	type DockerLogLine,
 } from "@/Types/Check";
 
-export const getNextMonitorSort = (
-	field: string,
-	sortField: string,
-	sortOrder: SortOrder
-): { field: string; order: SortOrder } => {
-	if (field !== sortField) return { field, order: "asc" };
-	if (sortOrder === "asc") return { field, order: "desc" };
-	return { field: "", order: "asc" };
-};
-
 export const getMonitorPath = (type: MonitorType): string => {
 	const pathMap: Record<MonitorType, string> = {
 		http: "uptime",
@@ -31,7 +20,7 @@ export const getMonitorPath = (type: MonitorType): string => {
 		websocket: "uptime",
 		dns: "uptime",
 		unknown: "uptime",
-		docker: "docker/host",
+		docker: "docker",
 		hardware: "infrastructure",
 		pagespeed: "pagespeed",
 	};

client/src/Validation/monitor.ts

@@ -152,8 +152,6 @@ const dockerSchema = baseSchema.extend({
 	// Read only mirror of the server flag, stripped on submit
 	dockerTlsKeySet: z.boolean(),
 	dockerLogsEnabled: z.boolean().register(monitorStepRegistry, { step: 1 }),
-	dockerAlertOnStopped: z.boolean().register(monitorStepRegistry, { step: 1 }),
-	dockerAlertOnUnhealthy: z.boolean().register(monitorStepRegistry, { step: 1 }),
 });
 
 // Game server monitor schema

client/src/locales/en.json

@@ -557,7 +557,7 @@
 				},
 				"status": {
 					"down": "down",
-					"breached": "alert",
+					"breached": "threshold exceeded",
 					"initializing": "initializing",
 					"maintenance": "maintenance",
 					"paused": "paused",
@@ -827,18 +827,6 @@
 						}
 					}
 				},
-				"dockerAlerts": {
-					"title": "Container alerts",
-					"description": "Mark this host as breached while any container on it is stopped or failing its health check, and notify on the change. Containers that exit with code 0 do not count as stopped. Capture does not report exit codes, so on Capture hosts every stopped container counts.",
-					"option": {
-						"onStopped": {
-							"label": "Alert when a container is stopped"
-						},
-						"onUnhealthy": {
-							"label": "Alert when a container is unhealthy"
-						}
-					}
-				},
 				"stats": {
 					"title": "Monitor history",
 					"description": "Clear all monitoring history and statistics for your team. This action is irreversible.",
@@ -1697,7 +1685,7 @@
 				"status": {
 					"up": "Operational",
 					"down": "Down",
-					"breached": "Alert",
+					"breached": "Threshold exceeded",
 					"maintenance": "Maintenance",
 					"paused": "Paused",
 					"initializing": "Initializing"
@@ -1737,13 +1725,13 @@
 				"monitoringSummary": "Monitoring {{count}} service · Updates every 10 seconds",
 				"monitoringSummary_other": "Monitoring {{count}} services · Updates every 10 seconds",
 				"allUp": "All systems operational",
-				"allBreached": "All systems have active alerts",
+				"allBreached": "All systems have exceeded thresholds",
 				"allMaintenance": "All systems are under maintenance",
 				"allDown": "All systems are down",
 				"allPaused": "All systems are paused",
 				"allInitializing": "All systems are initializing",
-				"breachedAndDown": "Some systems have active alerts and some are down",
-				"breached": "Some systems have active alerts",
+				"breachedAndDown": "Some systems have exceeded thresholds and are down",
+				"breached": "Some systems have exceeded thresholds",
 				"degraded": "Some systems are experiencing issues",
 				"maintenanceAndDown": "Some systems are down during maintenance",
 				"maintenance": "Some systems are under maintenance",
@@ -1936,27 +1924,16 @@
 			},
 			"cards": {
 				"monitorStatus": "Monitor status",
-				"currentlyDown": "Currently down",
-				"uptime": "Monitor uptime",
 				"monitorsByType": "Monitors by type"
 			},
-			"uptimeCard": {
-				"toggleSortOrder": "Toggle sort order"
-			},
-			"currentlyDown": {
-				"empty": "No monitors are down at this moment."
-			},
 			"header": {
 				"title": "Dashboard",
 				"description": "See every monitor type in one place and spot what needs attention."
 			},
 			"editCards": "Edit cards",
 			"editCardsModal": {
-				"title": "Dashboard cards",
+				"title": "Edit cards",
 				"description": "Select the cards to display on your dashboard.",
-				"groups": {
-					"uptime": "Uptime"
-				},
 				"done": "Done"
 			}
 		}

docker/Dockerfile

@@ -4,7 +4,7 @@
 # Build on the host arch (BUILDPLATFORM) rather than under QEMU — the output is
 # pure JS so it's arch-independent, and this avoids the esbuild host/native
 # binary version mismatch under emulation.
-FROM --platform=$BUILDPLATFORM node:24-slim AS frontend-build
+FROM --platform=$BUILDPLATFORM node:22-slim AS frontend-build
 
 WORKDIR /app/client
 
@@ -19,7 +19,7 @@ RUN npm run build
 # ---------------------
 # Backend stage
 # ---------------------
-FROM node:24-slim AS app
+FROM node:22-slim AS app
 
 # Install ping
 RUN apt-get update \

server/openapi.json

@@ -466,12 +466,6 @@
 					"dockerLogsEnabled": {
 						"type": "boolean"
 					},
-					"dockerAlertOnStopped": {
-						"type": "boolean"
-					},
-					"dockerAlertOnUnhealthy": {
-						"type": "boolean"
-					},
 					"dockerTlsCa": {
 						"type": "string"
 					},
@@ -529,8 +523,6 @@
 					"geoCheckLocations",
 					"geoCheckInterval",
 					"dockerLogsEnabled",
-					"dockerAlertOnStopped",
-					"dockerAlertOnUnhealthy",
 					"teamId",
 					"userId",
 					"createdAt",
@@ -702,12 +694,6 @@
 									"dockerLogsEnabled": {
 										"type": "boolean"
 									},
-									"dockerAlertOnStopped": {
-										"type": "boolean"
-									},
-									"dockerAlertOnUnhealthy": {
-										"type": "boolean"
-									},
 									"dockerTlsCa": {
 										"type": "string"
 									},
@@ -767,8 +753,6 @@
 									"geoCheckLocations",
 									"geoCheckInterval",
 									"dockerLogsEnabled",
-									"dockerAlertOnStopped",
-									"dockerAlertOnUnhealthy",
 									"teamId",
 									"userId",
 									"createdAt",
@@ -7202,12 +7186,6 @@
 														"dockerLogsEnabled": {
 															"type": "boolean"
 														},
-														"dockerAlertOnStopped": {
-															"type": "boolean"
-														},
-														"dockerAlertOnUnhealthy": {
-															"type": "boolean"
-														},
 														"dockerTlsCa": {
 															"type": "string"
 														},
@@ -7267,8 +7245,6 @@
 														"geoCheckLocations",
 														"geoCheckInterval",
 														"dockerLogsEnabled",
-														"dockerAlertOnStopped",
-														"dockerAlertOnUnhealthy",
 														"teamId",
 														"userId",
 														"createdAt",
@@ -7785,12 +7761,6 @@
 														"dockerLogsEnabled": {
 															"type": "boolean"
 														},
-														"dockerAlertOnStopped": {
-															"type": "boolean"
-														},
-														"dockerAlertOnUnhealthy": {
-															"type": "boolean"
-														},
 														"dockerTlsCa": {
 															"type": "string"
 														},
@@ -7850,8 +7820,6 @@
 														"geoCheckLocations",
 														"geoCheckInterval",
 														"dockerLogsEnabled",
-														"dockerAlertOnStopped",
-														"dockerAlertOnUnhealthy",
 														"teamId",
 														"userId",
 														"createdAt",
@@ -9340,12 +9308,6 @@
 									"dockerLogsEnabled": {
 										"type": "boolean"
 									},
-									"dockerAlertOnStopped": {
-										"type": "boolean"
-									},
-									"dockerAlertOnUnhealthy": {
-										"type": "boolean"
-									},
 									"dockerTlsCa": {
 										"anyOf": [
 											{
@@ -10071,14 +10033,6 @@
 													"type": "boolean",
 													"default": false
 												},
-												"dockerAlertOnStopped": {
-													"type": "boolean",
-													"default": false
-												},
-												"dockerAlertOnUnhealthy": {
-													"type": "boolean",
-													"default": false
-												},
 												"dnsServer": {
 													"type": "string",
 													"minLength": 1
@@ -10646,12 +10600,6 @@
 									"dockerLogsEnabled": {
 										"type": "boolean"
 									},
-									"dockerAlertOnStopped": {
-										"type": "boolean"
-									},
-									"dockerAlertOnUnhealthy": {
-										"type": "boolean"
-									},
 									"dockerTlsCa": {
 										"anyOf": [
 											{

server/package.json

@@ -30,8 +30,7 @@
 	"author": "",
 	"license": "ISC",
 	"engines": {
-		"node": ">=24",
-		"npm": ">=11"
+		"node": ">=20"
 	},
 	"dependencies": {
 		"@csstools/css-tokenizer": "^3.0.4",
@@ -46,7 +45,7 @@
 		"dayjs": "^1.11.23",
 		"dockerode": "5.0.0",
 		"dotenv": "^16.4.5",
-		"express": "5.2.1",
+		"express": "^4.19.2",
 		"express-rate-limit": "^8.5.1",
 		"gamedig": "5.2.0",
 		"got": "14.4.7",
@@ -59,11 +58,11 @@
 		"jsonwebtoken": "9.0.2",
 		"mjml": "^5.0.0-alpha.4",
 		"mongoose": "^8.3.3",
-		"multer": "2.4.0",
-		"nodemailer": "9.1.1",
+		"multer": "^1.4.5-lts.2",
+		"nodemailer": "9.0.5",
 		"ping": "0.4.4",
 		"re2": "^1.24.1",
-		"sharp": "0.35.4",
+		"sharp": "0.35.3",
 		"ssl-checker": "2.0.10",
 		"swagger-ui-express": "5.0.1",
 		"tldts": "^7.4.10",

server/src/api/controllers/controllerUtils.ts

@@ -1,5 +1,5 @@
 import { AppError } from "@/utils/AppError.js";
-import { Monitor } from "@/domain/monitors/monitor.type.js";
+import { Monitor, MonitorTypes, type MonitorType } from "@/domain/monitors/monitor.type.js";
 import { UserRole } from "@/domain/users/user.type.js";
 import sslChecker, { SSLDetails } from "ssl-checker";
 import * as whoiser from "whoiser";
@@ -10,7 +10,10 @@ type WhoisModule = typeof whoiser;
 export const fetchMonitorCertificate = async (checker: SSLCheckerType, monitor: Monitor): Promise<SSLDetails> => {
 	const monitorUrl = new URL(monitor.url);
 	const hostname = monitorUrl.hostname;
-	const cert = await checker(hostname);
+	// An explicit port in the URL is the most visible to the user, so it takes precedence over monitor.port.
+	const urlPort = monitorUrl.port ? Number(monitorUrl.port) : undefined;
+	const port = urlPort ?? monitor.port;
+	const cert = await checker(hostname, port !== undefined ? { port } : undefined);
 	if (cert?.validTo === null || cert?.validTo === undefined) {
 		throw new Error("Certificate not found");
 	}
@@ -124,6 +127,23 @@ export const fetchMonitorDomain = async (
 	return domainExpiry;
 };
 
+export const requireString = (value: unknown, fieldName: string): string => {
+	if (typeof value === "string" && value.trim().length > 0) {
+		return value;
+	}
+	throw new AppError({ message: `${fieldName} is required`, status: 400 });
+};
+
+export const optionalString = (value: unknown, fieldName: string): string | undefined => {
+	if (value === undefined) {
+		return undefined;
+	}
+	if (typeof value === "string") {
+		return value;
+	}
+	throw new AppError({ message: `${fieldName} must be a string`, status: 400 });
+};
+
 export const extractString = (value: unknown): string | undefined => {
 	const candidate = Array.isArray(value) ? value[0] : value;
 	if (typeof candidate !== "string" || candidate.length === 0) {
@@ -132,6 +152,52 @@ export const extractString = (value: unknown): string | undefined => {
 	return candidate;
 };
 
+export const optionalNumber = (value: unknown, fieldName: string): number | undefined => {
+	if (value === undefined) {
+		return undefined;
+	}
+	if (typeof value === "number" && Number.isFinite(value)) {
+		return value;
+	}
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		if (!Number.isNaN(parsed)) {
+			return parsed;
+		}
+	}
+	throw new AppError({ message: `${fieldName} must be a number`, status: 400 });
+};
+
+export const parseMonitorTypeFilter = (value: unknown): MonitorType | MonitorType[] | undefined => {
+	const parseSingle = (input: unknown): MonitorType => {
+		if (typeof input !== "string") {
+			throw new AppError({ message: "Monitor type must be a string", status: 400 });
+		}
+		if (!MonitorTypes.includes(input as MonitorType)) {
+			throw new AppError({ message: `Invalid monitor type: ${input}`, status: 400 });
+		}
+		return input as MonitorType;
+	};
+
+	if (value === undefined) {
+		return undefined;
+	}
+	if (Array.isArray(value)) {
+		return value.map((entry) => parseSingle(entry));
+	}
+	return parseSingle(value);
+};
+
+export const parseSortOrder = (value: unknown): "asc" | "desc" | undefined => {
+	if (value === undefined) {
+		return undefined;
+	}
+	if (value === "asc" || value === "desc") {
+		return value;
+	}
+	throw new AppError({ message: "order must be either 'asc' or 'desc'", status: 400 });
+};
+
 export const requireTeamId = (teamId?: string): string => {
 	if (!teamId) {
 		throw new AppError({ message: "Team ID is required", status: 400 });

server/src/api/controllers/notificationController.ts

@@ -35,18 +35,11 @@ class NotificationController implements INotificationController {
 
 	testNotification = catchAsync(async (req: Request, res: Response) => {
 		const notification = testNotificationBodyValidation.parse(req.body);
-		let success = false;
-		let reason: string | undefined;
-		try {
-			success = await this.notificationsService.sendTestNotification(notification);
-		} catch (error: unknown) {
-			if (!(error instanceof AppError)) throw error;
-			reason = error.message;
-		}
+		const success = await this.notificationsService.sendTestNotification(notification);
 
 		return res.status(200).json({
 			success,
-			msg: success ? "Notification sent successfully" : (reason ?? "Notification could not be sent — check the destination details."),
+			msg: success ? "Notification sent successfully" : "Notification could not be sent — check the destination details.",
 			details: { service: SERVICE_NAME },
 		});
 	});

server/src/api/controllers/settingsController.ts

@@ -9,8 +9,6 @@ import { IProxiesService } from "@/domain/proxies/proxy.service.js";
 import { IEgressStateService } from "@/domain/egress/egress-state.service.js";
 import { Settings } from "@/domain/app-settings/app-settings.type.js";
 
-const SERVICE_NAME = "SettingsController";
-
 export interface ISettingsController {
 	getAppSettings: RequestHandler;
 	updateAppSettings: RequestHandler;
@@ -121,7 +119,7 @@ class SettingsController implements ISettingsController {
 
 		const html = await this.emailService.buildEmail("testEmailTemplate", context);
 		if (!html) {
-			throw new AppError({ message: "Failed to build email template.", status: 500, service: SERVICE_NAME, method: "sendTestEmail" });
+			throw new AppError({ message: "Failed to build email template.", status: 500 });
 		}
 		let messageId: string;
 		try {
@@ -144,11 +142,8 @@ class SettingsController implements ISettingsController {
 			// Surface the underlying SMTP failure: diagnosing the settings is the whole
 			// point of the test email endpoint.
 			throw new AppError({
-				message: error instanceof AppError ? error.message : "Failed to send test email.",
-				status: error instanceof AppError ? error.status : 500,
-				service: SERVICE_NAME,
-				method: "sendTestEmail",
-				details: error instanceof AppError ? error.details : undefined,
+				message: error instanceof Error ? `Failed to send test email. ${error.message}` : "Failed to send test email.",
+				status: 500,
 			});
 		}
 

server/src/api/middleware/sanitization.ts

@@ -53,10 +53,14 @@ export const sanitizeBody = (options = {}): ((req: Request, res: Response, next:
 
 export const sanitizeQuery = (options = {}): ((req: Request, res: Response, next: NextFunction) => void) => {
 	return (req: Request, res: Response, next: NextFunction) => {
-		const sanitized = Object.fromEntries(
-			Object.entries(req.query).map(([key, value]) => [key, typeof value === "string" ? sanitizeInput(value, options) : value])
-		);
-		Object.defineProperty(req, "query", { value: sanitized, writable: true, configurable: true, enumerable: true });
+		if (req.query && typeof req.query === "object") {
+			for (const key of Object.keys(req.query)) {
+				const value = req.query[key];
+				if (typeof value === "string") {
+					req.query[key] = sanitizeInput(value, options);
+				}
+			}
+		}
 		next();
 	};
 };

server/src/api/validation/monitorValidation.ts

@@ -220,8 +220,6 @@ export const createMonitorBodyValidation = z
 		geoCheckLocations: z.array(z.enum(GeoContinents)).optional(),
 		geoCheckInterval: z.number().min(300000).optional(),
 		dockerLogsEnabled: z.boolean().optional(),
-		dockerAlertOnStopped: z.boolean().optional(),
-		dockerAlertOnUnhealthy: z.boolean().optional(),
 		dockerTlsCa: z.union([z.string(), z.literal("")]).optional(),
 		dockerTlsCert: z.union([z.string(), z.literal("")]).optional(),
 		dockerTlsKey: z.union([z.string(), z.literal("")]).optional(),
@@ -272,8 +270,6 @@ export const editMonitorBodyValidation = z
 		geoCheckLocations: z.array(z.enum(GeoContinents)).optional(),
 		geoCheckInterval: z.number().min(300000).optional(),
 		dockerLogsEnabled: z.boolean().optional(),
-		dockerAlertOnStopped: z.boolean().optional(),
-		dockerAlertOnUnhealthy: z.boolean().optional(),
 		dockerTlsCa: z.union([z.string(), z.literal("")]).optional(),
 		dockerTlsCert: z.union([z.string(), z.literal("")]).optional(),
 		dockerTlsKey: z.union([z.string(), z.literal("")]).optional(),
@@ -354,8 +350,6 @@ const importedMonitorSchema = z
 		geoCheckLocations: z.array(z.enum(GeoContinents)).default([]),
 		geoCheckInterval: z.number().min(300000).default(300000),
 		dockerLogsEnabled: z.boolean().default(false),
-		dockerAlertOnStopped: z.boolean().default(false),
-		dockerAlertOnUnhealthy: z.boolean().default(false),
 		dnsServer: dnsServerValidation.optional(),
 		dnsRecordType: z.enum(DnsRecordTypes).optional(),
 		createdAt: z.string().optional(),
@@ -446,8 +440,6 @@ export const monitorResponseSchema = z
 		geoCheckLocations: z.array(z.enum(GeoContinents)),
 		geoCheckInterval: z.number(),
 		dockerLogsEnabled: z.boolean(),
-		dockerAlertOnStopped: z.boolean(),
-		dockerAlertOnUnhealthy: z.boolean(),
 		dockerTlsCa: z.string().optional(),
 		dockerTlsCert: z.string().optional(),
 		dockerTlsKeySet: z.boolean().optional(),

server/src/app.ts

@@ -122,7 +122,7 @@ export const createApp = ({
 	setupRoutes(app, controllers, services);
 
 	// FE routes
-	app.get("/{*splat}", (req, res) => {
+	app.get("*", (req, res) => {
 		res.sendFile(path.join(frontendPath, "index.html"));
 	});
 	app.use(handleErrors(services.logger));

server/src/config/services.worker.ts

@@ -1,4 +1,5 @@
 import { Resolver } from "dns/promises";
+import axios from "axios";
 import got from "got";
 import ping from "ping";
 import Docker from "dockerode";
@@ -12,7 +13,7 @@ import mongoose from "mongoose";
 
 import { EnvConfig } from "@/domain/app-settings/app-settings.service.js";
 import { SharedServices } from "@/config/services.shared.js";
-import { IProviderRegistry, ProviderRegistry } from "@/service/networkProviders/providerRegistry.js";
+import { INetworkService, NetworkService } from "@/service/networkService.js";
 import { IBufferService, BufferService } from "@/service/bufferService.js";
 import { IStatusService, StatusService } from "@/service/statusService.js";
 import { SecretsRotationService } from "@/service/encryption/secretsRotationService.js";
@@ -23,25 +24,25 @@ import { NotificationReactor } from "@/worker/reactors/reactor.notification.js";
 import { IncidentReactor } from "@/worker/reactors/reactor.incident.js";
 import { ReactorDispatcher } from "@/worker/reactors/reactor.dispatcher.js";
 import { DBQueueWorker } from "@/worker/worker.db-queue.js";
-import { ProxyResolver } from "@/service/networkProviders/ProxyResolver.js";
+import { ProxyResolver } from "@/service/network/ProxyResolver.js";
 import { IEgressService, EgressService } from "@/domain/egress/egress.service.js";
 // Network providers
-import { PingProvider } from "@/service/networkProviders/PingProvider.js";
-import { HttpProvider } from "@/service/networkProviders/HttpProvider.js";
-import { AdvancedMatcher } from "@/service/networkProviders/AdvancedMatcher.js";
-import { PageSpeedProvider } from "@/service/networkProviders/PageSpeedProvider.js";
-import { HardwareProvider } from "@/service/networkProviders/HardwareProvider.js";
-import { DockerProvider } from "@/service/networkProviders/DockerProvider.js";
-import { PortProvider } from "@/service/networkProviders/PortProvider.js";
-import { GameProvider } from "@/service/networkProviders/GameProvider.js";
-import { GrpcProvider } from "@/service/networkProviders/GrpcProvider.js";
-import { WebSocketProvider } from "@/service/networkProviders/WebSocketProvider.js";
-import { DNSProvider } from "@/service/networkProviders/DNSProvider.js";
+import { PingProvider } from "@/service/network/PingProvider.js";
+import { HttpProvider } from "@/service/network/HttpProvider.js";
+import { AdvancedMatcher } from "@/service/network/AdvancedMatcher.js";
+import { PageSpeedProvider } from "@/service/network/PageSpeedProvider.js";
+import { HardwareProvider } from "@/service/network/HardwareProvider.js";
+import { DockerProvider } from "@/service/network/DockerProvider.js";
+import { PortProvider } from "@/service/network/PortProvider.js";
+import { GameProvider } from "@/service/network/GameProvider.js";
+import { GrpcProvider } from "@/service/network/GrpcProvider.js";
+import { WebSocketProvider } from "@/service/network/WebSocketProvider.js";
+import { DNSProvider } from "@/service/network/DNSProvider.js";
 import { AppError } from "@/utils/AppError.js";
 import { WorkerPipeline } from "@/worker/worker.pipeline.js";
 export interface WorkerServices {
 	worker: IQueueWorker;
-	networkService: IProviderRegistry;
+	networkService: INetworkService;
 	bufferService: IBufferService;
 	statusService: IStatusService;
 	egressService: IEgressService;
@@ -86,7 +87,7 @@ export const buildWorker = async (shared: SharedServices, envSettings: EnvConfig
 	const webSocketProvider = new WebSocketProvider(WebSocket);
 	const dnsProvider = new DNSProvider(() => new Resolver());
 
-	const providerRegistry = new ProviderRegistry([
+	const networkService = new NetworkService(axios, logger, [
 		pingProvider,
 		httpProvider,
 		pageSpeedProvider,
@@ -104,7 +105,7 @@ export const buildWorker = async (shared: SharedServices, envSettings: EnvConfig
 		pipeline.ingestChecks(checks)
 	);
 	const statusService = new StatusService(logger, monitorsRepository, monitorStatsRepository);
-	const egressService = new EgressService(settingsService, egressStateRepository, jobsRepository, providerRegistry, proxyResolver, logger);
+	const egressService = new EgressService(settingsService, egressStateRepository, jobsRepository, networkService, proxyResolver, logger);
 
 	const notificationReactor = new NotificationReactor(notificationsService);
 	const incidentReactor = new IncidentReactor(incidentService);
@@ -117,7 +118,7 @@ export const buildWorker = async (shared: SharedServices, envSettings: EnvConfig
 		checksRepository,
 		jobsRepository,
 		checkService,
-		providerRegistry: providerRegistry,
+		networkService,
 		proxyResolver,
 		bufferService,
 		dockerLogsService,
@@ -187,5 +188,5 @@ export const buildWorker = async (shared: SharedServices, envSettings: EnvConfig
 		});
 	}
 
-	return { worker, networkService: providerRegistry, bufferService, statusService, egressService };
+	return { worker, networkService, bufferService, statusService, egressService };
 };

server/src/domain/checks/check.model.ts

@@ -220,7 +220,6 @@ const dockerContainerSchema = new Schema<DockerContainerInfo>(
 		startedAt: { type: String },
 		ports: { type: [dockerContainerPortSchema], default: undefined },
 		mounts: { type: [dockerContainerMountSchema], default: undefined },
-		exitCode: { type: Number, default: undefined },
 	},
 	{ _id: false }
 );

server/src/domain/checks/check.service.ts

@@ -13,6 +13,7 @@ const SERVICE_NAME = "checkService";
 export interface ICheckService {
 	createChecks(checks: Check[]): Promise<Check[]>;
 	toCheck(statusResponse: MonitorStatusResponse<MonitorPayloadMap[keyof MonitorPayloadMap]>): Check | undefined;
+	toStatusResponse(check: Check): MonitorStatusResponse<MonitorPayloadMap[keyof MonitorPayloadMap]>;
 	getChecksByMonitor(params: {
 		monitorId: string;
 		teamId: string;
@@ -134,6 +135,24 @@ export class CheckService implements ICheckService {
 		return check;
 	};
 
+	toStatusResponse = (check: Check) => {
+		const statusResponse: MonitorStatusResponse<MonitorPayloadMap[keyof MonitorPayloadMap]> = {
+			monitorId: check.metadata.monitorId,
+			teamId: check.metadata.teamId,
+			type: check.metadata.type,
+			status: check.status,
+			code: check.statusCode,
+			message: check.message,
+			responseTime: check.responseTime,
+			// re-nest hardware metrics so updateMonitorStatus / extractThresholdBreaches see payload.data
+			payload:
+				check.metadata.type === "hardware"
+					? ({ data: { cpu: check.cpu, memory: check.memory, disk: check.disk, host: check.host, net: check.net } } as HardwareStatusPayload)
+					: undefined,
+		};
+		return statusResponse;
+	};
+
 	getChecksByMonitor = async ({
 		monitorId,
 		teamId,

server/src/domain/checks/check.snapshot.ts

@@ -45,14 +45,12 @@ const mapMemory = (memory?: CheckMemoryInfo): SnapshotMemoryInfo | undefined =>
 	};
 
 const mapDisk = (disk?: CheckDiskInfo[]): SnapshotDiskInfo[] | undefined =>
-	disk
-		?.filter((entry) => entry != null)
-		.map((entry) => ({
-			device: entry.device,
-			total_bytes: entry.total_bytes,
-			used_bytes: entry.used_bytes,
-			usage_percent: entry.usage_percent,
-		}));
+	disk?.map((entry) => ({
+		device: entry.device,
+		total_bytes: entry.total_bytes,
+		used_bytes: entry.used_bytes,
+		usage_percent: entry.usage_percent,
+	}));
 
 const mapHost = (host?: CheckHostInfo): SnapshotHostInfo | undefined =>
 	host && {

server/src/domain/docker/docker-alert.ts

@@ -1,47 +0,0 @@
-import type { DockerContainerInfo } from "@/domain/docker/docker.type.js";
-import type { Monitor } from "@/domain/monitors/monitor.type.js";
-
-export const DockerAlertReasons = ["stopped", "unhealthy"] as const;
-export type DockerAlertReason = (typeof DockerAlertReasons)[number];
-
-export interface DockerContainerBreach {
-	name: string;
-	reason: DockerAlertReason;
-	exitCode?: number;
-}
-
-export const isContainerStopped = (container: DockerContainerInfo): boolean => {
-	// Container with exit code 0 is probably a one shot container don't report stopped
-	return container.state === "dead" || (container.state === "exited" && container.exitCode !== 0);
-};
-
-export const isContainerUnhealthy = (container: DockerContainerInfo): boolean => {
-	return container.health === "unhealthy";
-};
-
-export const findContainerBreaches = (monitor: Monitor, containers: DockerContainerInfo[]): DockerContainerBreach[] => {
-	const breaches: DockerContainerBreach[] = [];
-	for (const container of containers) {
-		if (monitor.dockerAlertOnStopped && isContainerStopped(container)) {
-			breaches.push({
-				name: container.name,
-				reason: "stopped",
-				exitCode: container.exitCode,
-			});
-		} else if (monitor.dockerAlertOnUnhealthy && isContainerUnhealthy(container)) {
-			breaches.push({
-				name: container.name,
-				reason: "unhealthy",
-			});
-		}
-	}
-	return breaches;
-};
-
-export const describeContainerBreach = (breach: DockerContainerBreach): string => {
-	if (breach.reason === "unhealthy") return `${breach.name}: unhealthy`;
-	if (breach.exitCode === undefined) {
-		return `${breach.name}: stopped`;
-	}
-	return `${breach.name}: stopped (exit code ${breach.exitCode})`;
-};

server/src/domain/docker/docker.type.ts

@@ -55,7 +55,6 @@ export interface DockerContainerInfo {
 	startedAt?: string; // ISO date
 	ports?: DockerContainerPort[];
 	mounts?: DockerContainerMount[];
-	exitCode?: number;
 }
 
 export interface DockerContainerSummary {

server/src/domain/egress/egress.service.ts

@@ -3,8 +3,8 @@ import type { ISettingsService } from "@/domain/app-settings/app-settings.servic
 import type { IEgressStateRepository } from "@/domain/egress/egress-state.repository.interface.js";
 import type { IJobsRepository } from "@/domain/jobs/job.repository.interface.js";
 import { jobId, type Job, type JobSeed } from "@/domain/jobs/job.type.js";
-import type { IProviderRegistry } from "@/service/networkProviders/providerRegistry.js";
-import type { IProxyResolver } from "@/service/networkProviders/ProxyResolver.js";
+import type { INetworkService } from "@/service/networkService.js";
+import type { IProxyResolver } from "@/service/network/ProxyResolver.js";
 import type { ILogger } from "@/utils/logger.js";
 import {
 	EGRESS_RECOVERY_POLL_SECONDS,
@@ -13,7 +13,7 @@ import {
 	type EgressProbeResult,
 	type EgressStatus,
 } from "@/domain/egress/egress.type.js";
-import { timeRequest } from "@/service/networkProviders/utils.js";
+import { timeRequest } from "@/service/network/utils.js";
 import { parseEgressTarget, type EgressTarget } from "@/utils/egressTarget.js";
 
 const SERVICE_NAME = "EgressService";
@@ -54,7 +54,7 @@ export class EgressService implements IEgressService {
 		private settingsService: ISettingsService,
 		private egressStateRepository: IEgressStateRepository,
 		private jobsRepository: IJobsRepository,
-		private providerRegistry: IProviderRegistry,
+		private networkService: INetworkService,
 		private proxyResolver: IProxyResolver,
 		private logger: ILogger
 	) {}
@@ -100,7 +100,7 @@ export class EgressService implements IEgressService {
 		const { response, responseTime, error } = await timeRequest(async () => {
 			const proxyUrl = await this.proxyResolver.resolve(monitor);
 			return Promise.race([
-				this.providerRegistry.probe(monitor, { proxyUrl }),
+				this.networkService.requestStatus(monitor, { proxyUrl }),
 				new Promise<never>((_, reject) => {
 					timer = setTimeout(() => reject(new Error(`Egress probe timed out after ${PROBE_TIMEOUT_MS}ms`)), PROBE_TIMEOUT_MS);
 				}),

server/src/domain/incidents/incident.service.ts

@@ -1,5 +1,6 @@
+const SERVICE_NAME = "incidentService";
 import type { Monitor } from "@/domain/monitors/monitor.type.js";
-import type { Check } from "@/domain/checks/check.type.js";
+import type { MonitorStatusResponse } from "@/types/network.js";
 import { AppError } from "@/utils/AppError.js";
 import { getDateForRange } from "@/utils/dataUtils.js";
 import type { IIncidentsRepository } from "@/domain/incidents/incident.repository.interface.js";
@@ -12,9 +13,13 @@ import type { INotificationMessageBuilder } from "@/domain/notifications/notific
 import type { ILogger } from "@/utils/logger.js";
 import { DateRange } from "@/types/query.js";
 
-const SERVICE_NAME = "incidentService";
 export interface IIncidentService {
-	handleIncident(monitor: Monitor, decision: MonitorActionDecision, check: Check): Promise<Incident | null>;
+	handleIncident(
+		monitor: Monitor,
+		code: number,
+		decision: MonitorActionDecision,
+		monitorStatusResponse?: MonitorStatusResponse
+	): Promise<Incident | null>;
 	resolveIncident(incidentId: string, userId: string, teamId: string, comment?: string, userEmail?: string): Promise<Incident>;
 	getIncidentsByTeam(
 		teamId: string,
@@ -53,38 +58,67 @@ export class IncidentService implements IIncidentService {
 		this.notificationMessageBuilder = notificationMessageBuilder;
 	}
 
-	handleIncident = async (monitor: Monitor, decision: MonitorActionDecision, check: Check): Promise<Incident | null> => {
-		const { transition } = decision;
-		if (transition === null) return null;
+	handleIncident = async (
+		monitor: Monitor,
+		code: number,
+		decision: MonitorActionDecision,
+		monitorStatusResponse?: MonitorStatusResponse
+	): Promise<Incident | null> => {
+		if (!decision.shouldCreateIncident && !decision.shouldResolveIncident) {
+			return null;
+		}
 
 		const activeIncident = await this.incidentsRepository.findActiveByMonitorId(monitor.id, monitor.teamId);
 
-		switch (transition) {
-			case "status_down":
-			case "threshold_breach": {
-				if (activeIncident) return activeIncident;
-				// A threshold breach has no HTTP status
-				const isBreach = transition === "threshold_breach";
-				return await this.incidentsRepository.create({
+		if (decision.shouldCreateIncident) {
+			if (activeIncident) {
+				return activeIncident;
+			} else {
+				let statusCode = code;
+				let message: string | undefined;
+
+				// For threshold breaches, use 9999 status code and build descriptive message
+				if (decision.incidentReason === "threshold_breach") {
+					statusCode = 9999;
+					message = this.buildThresholdBreachMessage(monitor, monitorStatusResponse);
+				}
+
+				const incident = {
 					monitorId: monitor.id,
 					teamId: monitor.teamId,
 					startTime: Date.now().toString(),
 					status: true,
-					statusCode: isBreach ? 9999 : check.statusCode,
-					message: isBreach ? this.notificationMessageBuilder.buildThresholdBreachMessage(monitor, check, decision.thresholdBreaches) : undefined,
-				});
-			}
-			case "status_up":
-			case "threshold_resolved": {
-				if (!activeIncident) return null;
-				activeIncident.status = false;
-				activeIncident.endTime = Date.now().toString();
-				activeIncident.resolutionType = "automatic";
-				return await this.incidentsRepository.updateById(activeIncident.id, activeIncident.teamId, activeIncident);
+					statusCode,
+					message,
+				};
+				return await this.incidentsRepository.create(incident);
 			}
 		}
+
+		if (!decision.shouldResolveIncident || !activeIncident) {
+			return null;
+		}
+
+		activeIncident.status = false;
+		activeIncident.endTime = Date.now().toString();
+		activeIncident.resolutionType = "automatic";
+		return await this.incidentsRepository.updateById(activeIncident.id, activeIncident.teamId, activeIncident);
 	};
 
+	private buildThresholdBreachMessage(monitor: Monitor, monitorStatusResponse?: MonitorStatusResponse): string {
+		if (!monitorStatusResponse) {
+			return "Threshold breach detected";
+		}
+
+		const breaches = this.notificationMessageBuilder.extractThresholdBreaches(monitor, monitorStatusResponse);
+
+		if (breaches.length === 0) {
+			return "Threshold breach detected";
+		}
+
+		return breaches.map((b) => `${b.metric.toUpperCase()}: ${b.formattedValue} (threshold: ${b.threshold}${b.unit})`).join(", ");
+	}
+
 	resolveIncident = async (incidentId: string, userId: string, teamId: string, comment?: string, userEmail?: string) => {
 		try {
 			if (!incidentId) {

server/src/domain/monitors/monitor.model.ts

@@ -307,14 +307,6 @@ const MonitorSchema = new Schema<MonitorDocument>(
 			type: Boolean,
 			default: false,
 		},
-		dockerAlertOnStopped: {
-			type: Boolean,
-			default: false,
-		},
-		dockerAlertOnUnhealthy: {
-			type: Boolean,
-			default: false,
-		},
 		dockerTlsCa: {
 			type: String,
 		},

server/src/domain/monitors/monitor.repository.mongo.ts

@@ -101,12 +101,7 @@ class MongoMonitorsRepository implements IMonitorsRepository {
 
 	private pageOptions = (config: TeamQueryConfig) => {
 		const { page = 0, rowsPerPage = 0, field = "createdAt", order = "desc" } = config ?? {};
-		const direction: 1 | -1 = order === "asc" ? 1 : -1;
-		const sort: Record<string, 1 | -1> = { [field]: direction };
-		if (field !== "createdAt") {
-			sort.createdAt = 1;
-		}
-		return { sort, skip: Math.max(page, 0) * rowsPerPage, limit: rowsPerPage };
+		return { sort: { [field]: order === "asc" ? 1 : -1 } as const, skip: Math.max(page, 0) * rowsPerPage, limit: rowsPerPage };
 	};
 
 	findByTeamId = async (teamId: string, config: TeamQueryConfig, options?: { includeRecentChecks?: boolean }): Promise<Monitor[]> => {
@@ -473,8 +468,6 @@ class MongoMonitorsRepository implements IMonitorsRepository {
 			geoCheckLocations: doc.geoCheckLocations ?? [],
 			geoCheckInterval: doc.geoCheckInterval ?? 300000,
 			dockerLogsEnabled: doc.dockerLogsEnabled ?? false,
-			dockerAlertOnStopped: doc.dockerAlertOnStopped ?? false,
-			dockerAlertOnUnhealthy: doc.dockerAlertOnUnhealthy ?? false,
 			dockerTlsCa: doc.dockerTlsCa ?? undefined,
 			dockerTlsCert: doc.dockerTlsCert ?? undefined,
 			dockerTlsKeySet: doc.dockerTlsKeySet ?? false,

server/src/domain/monitors/monitor.type.ts

@@ -51,22 +51,6 @@ export const UptimeDetailsSupportedTypes = ["http", "ping", "port", "game", "grp
 export type UptimeDetailsSupportedType = (typeof UptimeDetailsSupportedTypes)[number];
 export const supportsUptimeDetails = (type: MonitorType): type is UptimeDetailsSupportedType => UptimeDetailsSupportedTypes.some((t) => t === type);
 
-const MonitorPaths: Record<MonitorType, string> = {
-	http: "uptime",
-	port: "uptime",
-	ping: "uptime",
-	game: "uptime",
-	grpc: "uptime",
-	websocket: "uptime",
-	dns: "uptime",
-	unknown: "uptime",
-	docker: "docker/host",
-	hardware: "infrastructure",
-	pagespeed: "pagespeed",
-};
-
-export const getMonitorPath = (type: MonitorType): string => MonitorPaths[type];
-
 // Types whose check leaves the instance, and whose failure to reach the target can therefore be the instance's
 // own loss of egress. A hardware check is an ordinary outbound HTTP request to the Capture agent, so it counts
 // however far away the agent is. `unknown` is excluded because no request is made for it.
@@ -150,8 +134,6 @@ export interface Monitor {
 	geoCheckLocations?: GeoContinent[];
 	geoCheckInterval?: number;
 	dockerLogsEnabled?: boolean;
-	dockerAlertOnStopped?: boolean;
-	dockerAlertOnUnhealthy?: boolean;
 	dockerTlsCa?: string;
 	dockerTlsCert?: string;
 	// EncryptionService ciphertext. Normally excluded
@@ -240,8 +222,3 @@ export type GamesMap = Record<string, Game>;
 export type MonitorScheduleFields = Pick<Monitor, "id" | "type" | "isActive" | "interval" | "geoCheckEnabled" | "geoCheckInterval">;
 
 export type DockerContainerLogsResult = DockerLogPage;
-
-export const HardwareMetricKeys = ["cpu", "memory", "disk", "temp"] as const;
-export type HardwareMetricKey = (typeof HardwareMetricKeys)[number];
-export type HardwareBreaches = Record<HardwareMetricKey, boolean>;
-export type HardwareCounters = Record<HardwareMetricKey, number>;

server/src/domain/notifications/notification.message-builder.ts

@@ -1,4 +1,5 @@
-import { HardwareMetricKeys, type HardwareBreaches, type HardwareMetricKey, type Monitor } from "@/domain/monitors/monitor.type.js";
+import type { Monitor } from "@/domain/monitors/monitor.type.js";
+import type { HardwareStatusPayload, MonitorStatusResponse } from "@/types/network.js";
 import type { MonitorActionDecision } from "@/worker/worker.interface.js";
 import type {
 	NotificationMessage,
@@ -7,12 +8,15 @@ import type {
 	ThresholdBreach,
 	NotificationContent,
 } from "@/domain/notifications/notification.type.js";
-import { describeContainerBreach, findContainerBreaches } from "@/domain/docker/docker-alert.js";
-import type { Check } from "@/domain/checks/check.type.js";
 
 export interface INotificationMessageBuilder {
-	buildMessage(monitor: Monitor, check: Check, decision: MonitorActionDecision, clientHost: string): NotificationMessage;
-	buildThresholdBreachMessage(monitor: Monitor, check: Check, thresholdBreaches: HardwareBreaches | undefined): string;
+	buildMessage(
+		monitor: Monitor,
+		monitorStatusResponse: MonitorStatusResponse,
+		decision: MonitorActionDecision,
+		clientHost: string
+	): NotificationMessage;
+	extractThresholdBreaches(monitor: Monitor, monitorStatusResponse: MonitorStatusResponse): ThresholdBreach[];
 }
 
 const SERVICE_NAME = "NotificationMessageBuilder";
@@ -20,10 +24,15 @@ const SERVICE_NAME = "NotificationMessageBuilder";
 export class NotificationMessageBuilder implements INotificationMessageBuilder {
 	static SERVICE_NAME = SERVICE_NAME;
 
-	buildMessage(monitor: Monitor, check: Check, decision: MonitorActionDecision, clientHost: string): NotificationMessage {
+	buildMessage(
+		monitor: Monitor,
+		monitorStatusResponse: MonitorStatusResponse,
+		decision: MonitorActionDecision,
+		clientHost: string
+	): NotificationMessage {
 		const type = this.determineNotificationType(decision, monitor);
 		const severity = this.determineSeverity(type);
-		const content = this.buildContent(type, monitor, check, decision);
+		const content = this.buildContent(type, monitor, monitorStatusResponse);
 
 		return {
 			type,
@@ -39,37 +48,43 @@ export class NotificationMessageBuilder implements INotificationMessageBuilder {
 			clientHost,
 			metadata: {
 				teamId: monitor.teamId,
+				notificationReason: decision.notificationReason || "status_change",
 			},
 		};
 	}
 
 	private determineNotificationType(decision: MonitorActionDecision, monitor: Monitor): NotificationType {
-		const isDocker = monitor.type === "docker";
-		switch (decision.transition) {
-			case "status_down":
-				return "monitor_down";
-			case "threshold_breach":
-				return isDocker ? "container_breach" : "threshold_breach";
-			case "threshold_resolved":
-				return isDocker ? "container_resolved" : "threshold_resolved";
-			case "status_up":
-			case null:
-				return "monitor_up";
+		// Down status has highest priority (critical)
+		if (monitor.status === "down") {
+			return "monitor_down";
 		}
+
+		// Threshold breach (only if not down)
+		if (decision.notificationReason === "threshold_breach") {
+			return "threshold_breach";
+		}
+
+		// Recovery from threshold breach (only for hardware monitors)
+		if (decision.notificationReason === "status_change" && monitor.status === "up" && monitor.type === "hardware") {
+			return "threshold_resolved";
+		}
+
+		// Standard recovery (up)
+		if (monitor.status === "up") {
+			return "monitor_up";
+		}
+
+		// Default to monitor_up for any other case
+		return "monitor_up";
 	}
 
 	private determineSeverity(type: NotificationType): NotificationSeverity {
 		switch (type) {
-			case "monitor_up":
-				return "success";
 			case "monitor_down":
 				return "critical";
-			case "container_breach":
-				return "warning";
 			case "threshold_breach":
 				return "warning";
-			case "container_resolved":
-				return "success";
+			case "monitor_up":
 			case "threshold_resolved":
 				return "success";
 			case "test":
@@ -79,38 +94,34 @@ export class NotificationMessageBuilder implements INotificationMessageBuilder {
 		}
 	}
 
-	private buildContent(type: NotificationType, monitor: Monitor, check: Check, decision: MonitorActionDecision): NotificationContent {
+	private buildContent(type: NotificationType, monitor: Monitor, monitorStatusResponse: MonitorStatusResponse): NotificationContent {
 		switch (type) {
 			case "monitor_down":
-				return this.buildMonitorDownContent(monitor, check);
+				return this.buildMonitorDownContent(monitor, monitorStatusResponse);
 			case "monitor_up":
 				return this.buildMonitorUpContent(monitor);
 			case "threshold_breach":
-				return this.buildThresholdBreachContent(monitor, check, decision.thresholdBreaches);
+				return this.buildThresholdBreachContent(monitor, monitorStatusResponse as MonitorStatusResponse<HardwareStatusPayload>);
 			case "threshold_resolved":
 				return this.buildThresholdResolvedContent(monitor);
-			case "container_breach":
-				return this.buildContainerBreachContent(monitor, check);
-			case "container_resolved":
-				return this.buildContainersRecoveredContent(monitor);
 			default:
 				return this.buildDefaultContent(monitor);
 		}
 	}
 
-	private buildMonitorDownContent(monitor: Monitor, check: Check): NotificationContent {
+	private buildMonitorDownContent(monitor: Monitor, monitorStatusResponse: MonitorStatusResponse): NotificationContent {
 		const title = `Monitor Down: ${monitor.name}`;
 		const summary = `Monitor "${monitor.name}" is currently down and unreachable.`;
 		const details = [`URL: ${monitor.url}`, `Status: Down`, `Type: ${monitor.type}`];
 
 		// Add response code if available
-		if (check.statusCode) {
-			details.push(`Response Code: ${check.statusCode}`);
+		if (monitorStatusResponse.code) {
+			details.push(`Response Code: ${monitorStatusResponse.code}`);
 		}
 
 		// Add error message if available
-		if (check.message) {
-			details.push(`Error: ${check.message}`);
+		if (monitorStatusResponse.message) {
+			details.push(`Error: ${monitorStatusResponse.message}`);
 		}
 
 		return {
@@ -134,12 +145,12 @@ export class NotificationMessageBuilder implements INotificationMessageBuilder {
 		};
 	}
 
-	private buildThresholdBreachContent(monitor: Monitor, check: Check, thresholdBreaches: HardwareBreaches | undefined): NotificationContent {
+	private buildThresholdBreachContent(monitor: Monitor, monitorStatusResponse: MonitorStatusResponse<HardwareStatusPayload>): NotificationContent {
 		const title = `Threshold Exceeded: ${monitor.name}`;
 		const summary = `Monitor "${monitor.name}" has exceeded one or more thresholds.`;
 		const details = [`URL: ${monitor.url}`, `Status: Threshold exceeded`, `Type: ${monitor.type}`];
 
-		const thresholds = this.extractThresholdBreaches(monitor, check, thresholdBreaches);
+		const thresholds = this.extractThresholdBreaches(monitor, monitorStatusResponse);
 
 		return {
 			title,
@@ -163,21 +174,6 @@ export class NotificationMessageBuilder implements INotificationMessageBuilder {
 		};
 	}
 
-	private buildContainerBreachContent(monitor: Monitor, check: Check): NotificationContent {
-		const lines = this.describeContainerBreaches(monitor, check);
-		const title = `Container Alert: ${monitor.name}`;
-		const summary = `${lines.length} container(s) on "${monitor.name}" need attention.`;
-		const details = [`URL: ${monitor.url}`, `Type: ${monitor.type}`, ...lines];
-		return { title, summary, details, timestamp: new Date() };
-	}
-
-	private buildContainersRecoveredContent(monitor: Monitor): NotificationContent {
-		const title = `Containers Recovered: ${monitor.name}`;
-		const summary = `All containers on "${monitor.name}" are back to normal.`;
-		const details = [`URL: ${monitor.url}`, `Status: Up`, `Type: ${monitor.type}`];
-		return { title, summary, details, timestamp: new Date() };
-	}
-
 	private buildDefaultContent(monitor: Monitor): NotificationContent {
 		return {
 			title: `Monitor: ${monitor.name}`,
@@ -187,57 +183,93 @@ export class NotificationMessageBuilder implements INotificationMessageBuilder {
 		};
 	}
 
-	private describeBreach(metric: HardwareMetricKey, monitor: Monitor, check: Check): ThresholdBreach {
-		switch (metric) {
-			case "cpu": {
-				const currentValue = (check.cpu?.usage_percent ?? 0) * 100;
-				return { metric, currentValue, threshold: monitor.cpuAlertThreshold, unit: "%", formattedValue: `${currentValue.toFixed(1)}%` };
-			}
-			case "memory": {
-				const currentValue = (check.memory?.usage_percent ?? 0) * 100;
-				return { metric, currentValue, threshold: monitor.memoryAlertThreshold, unit: "%", formattedValue: `${currentValue.toFixed(1)}%` };
-			}
-			case "disk": {
-				const currentValue = Math.max(0, ...(check.disk ?? []).map((disk) => disk?.usage_percent ?? 0)) * 100;
-				return { metric, currentValue, threshold: monitor.diskAlertThreshold, unit: "%", formattedValue: `${currentValue.toFixed(1)}%` };
-			}
-			case "temp": {
-				const currentValue = Math.max(0, ...(check.cpu?.temperature ?? []));
-				return { metric, currentValue, threshold: monitor.tempAlertThreshold, unit: "°C", formattedValue: `${currentValue.toFixed(1)}°C` };
-			}
-		}
-	}
-
-	private extractThresholdBreaches(monitor: Monitor, check: Check, thresholdBreaches: HardwareBreaches | undefined): ThresholdBreach[] {
+	public extractThresholdBreaches(monitor: Monitor, monitorStatusResponse: MonitorStatusResponse<HardwareStatusPayload>): ThresholdBreach[] {
 		const breaches: ThresholdBreach[] = [];
 
 		// Check if this is a hardware monitor with threshold data
-		if (monitor.type !== "hardware" || thresholdBreaches === undefined) {
+		if (monitor.type !== "hardware" || !monitorStatusResponse.payload || typeof monitorStatusResponse.payload === "string") {
 			return breaches;
 		}
 
-		for (const metric of HardwareMetricKeys) {
-			if (!thresholdBreaches[metric]) continue;
-			breaches.push(this.describeBreach(metric, monitor, check));
+		// Cast to HardwareStatusPayload type
+		const payload = monitorStatusResponse.payload;
+		const hardware = payload.data;
+
+		if (!hardware) {
+			return breaches;
+		}
+
+		// Note: usage_percent values in hardware payload are decimals (0-1)
+		if (monitor.cpuAlertThreshold !== undefined && monitor.cpuAlertThreshold !== null && hardware.cpu?.usage_percent !== undefined) {
+			const cpuUsageDecimal = hardware.cpu.usage_percent;
+			const cpuPercent = cpuUsageDecimal * 100;
+			const threshold = monitor.cpuAlertThreshold;
+			if (cpuPercent > threshold) {
+				breaches.push({
+					metric: "cpu",
+					currentValue: cpuPercent,
+					threshold,
+					unit: "%",
+					formattedValue: `${cpuPercent.toFixed(1)}%`,
+				});
+			}
+		}
+
+		// Memory threshold breach
+		if (monitor.memoryAlertThreshold !== undefined && monitor.memoryAlertThreshold !== null && hardware.memory?.usage_percent !== undefined) {
+			const memoryUsageDecimal = hardware.memory.usage_percent;
+			const memoryPercent = memoryUsageDecimal * 100;
+			const threshold = monitor.memoryAlertThreshold;
+			if (memoryPercent > threshold) {
+				breaches.push({
+					metric: "memory",
+					currentValue: memoryPercent,
+					threshold,
+					unit: "%",
+					formattedValue: `${memoryPercent.toFixed(1)}%`,
+				});
+			}
+		}
+
+		// Disk threshold breach
+		if (monitor.diskAlertThreshold !== undefined && monitor.diskAlertThreshold !== null && Array.isArray(hardware.disk)) {
+			// Find the highest disk usage
+			let maxDiskUsageDecimal = 0;
+			for (const disk of hardware.disk) {
+				if (disk.usage_percent !== undefined && disk.usage_percent > maxDiskUsageDecimal) {
+					maxDiskUsageDecimal = disk.usage_percent;
+				}
+			}
+			const maxDiskPercent = maxDiskUsageDecimal * 100;
+			const threshold = monitor.diskAlertThreshold;
+			if (maxDiskPercent > threshold) {
+				breaches.push({
+					metric: "disk",
+					currentValue: maxDiskPercent,
+					threshold,
+					unit: "%",
+					formattedValue: `${maxDiskPercent.toFixed(1)}%`,
+				});
+			}
+		}
+
+		// Temperature threshold breach
+		if (monitor.tempAlertThreshold !== undefined && monitor.tempAlertThreshold !== null && hardware.cpu?.temperature) {
+			// Temperature is an array in cpu.temperature
+			const temps = Array.isArray(hardware.cpu.temperature) ? hardware.cpu.temperature : [hardware.cpu.temperature];
+			const maxTemp = Math.max(...temps.filter((t: number) => !isNaN(t)));
+			const threshold = monitor.tempAlertThreshold;
+			if (maxTemp > threshold) {
+				breaches.push({
+					metric: "temp",
+					currentValue: maxTemp,
+					threshold,
+					unit: "°C",
+					formattedValue: `${maxTemp.toFixed(1)}°C`,
+				});
+			}
 		}
 
 		return breaches;
 	}
-
-	private describeContainerBreaches(monitor: Monitor, check: Check): string[] {
-		return findContainerBreaches(monitor, check.containers ?? []).map(describeContainerBreach);
-	}
-
-	public buildThresholdBreachMessage(monitor: Monitor, check: Check, thresholdBreaches: HardwareBreaches | undefined): string {
-		if (monitor.type === "docker") {
-			const lines = this.describeContainerBreaches(monitor, check);
-			return lines.length > 0 ? lines.join(", ") : "Container alert";
-		}
-
-		const breaches = this.extractThresholdBreaches(monitor, check, thresholdBreaches);
-		if (breaches.length === 0) {
-			return "Threshold breach detected";
-		}
-		return breaches.map((b) => `${b.metric.toUpperCase()}: ${b.formattedValue} (threshold: ${b.threshold}${b.unit})`).join(", ");
-	}
 }

server/src/domain/notifications/notification.service.ts

@@ -1,5 +1,6 @@
 import type { Monitor } from "@/domain/monitors/monitor.type.js";
 import type { Notification } from "@/domain/notifications/notification.type.js";
+import type { MonitorStatusResponse } from "@/types/network.js";
 import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
 import { IMonitorsRepository } from "@/domain/monitors/monitor.repository.interface.js";
 import { INotificationsRepository } from "@/domain/notifications/notification.repository.interface.js";
@@ -9,7 +10,6 @@ import type { ISettingsService } from "@/domain/app-settings/app-settings.servic
 import { ILogger } from "@/utils/logger.js";
 import type { INotificationMessageBuilder } from "@/domain/notifications/notification.message-builder.js";
 import type { NotificationChannel } from "@/domain/notifications/notification.type.js";
-import type { Check } from "@/domain/checks/check.type.js";
 
 export type NotificationProviderRegistry = Record<NotificationChannel, INotificationProvider>;
 
@@ -19,7 +19,7 @@ export interface INotificationsService {
 	findNotificationsByTeamId: (teamId: string) => Promise<Notification[]>;
 	updateById(id: string, teamId: string, updateData: Partial<Notification>): Promise<Notification>;
 	deleteById: (id: string, teamId: string) => Promise<Notification>;
-	handleNotifications: (monitor: Monitor, check: Check, decision: MonitorActionDecision) => Promise<boolean>;
+	handleNotifications: (monitor: Monitor, monitorStatusResponse: MonitorStatusResponse, decision: MonitorActionDecision) => Promise<boolean>;
 
 	sendTestNotification: (notification: Partial<Notification>) => Promise<boolean>;
 	testAllNotifications: (notificationIds: string[]) => Promise<boolean>;
@@ -63,7 +63,7 @@ export class NotificationsService implements INotificationsService {
 	private send = async (
 		notification: Notification,
 		monitor: Monitor,
-		check: Check,
+		monitorStatusResponse: MonitorStatusResponse,
 		decision: MonitorActionDecision,
 		notificationMessage: NotificationMessage | undefined
 	): Promise<boolean> => {
@@ -89,16 +89,16 @@ export class NotificationsService implements INotificationsService {
 		return await provider.sendMessage(notification, notificationMessage);
 	};
 
-	private sendNotifications = async (monitor: Monitor, check: Check, decision: MonitorActionDecision) => {
+	private sendNotifications = async (monitor: Monitor, monitorStatusResponse: MonitorStatusResponse, decision: MonitorActionDecision) => {
 		const notificationIds = monitor.notifications ?? [];
 		const notifications = await this.notificationsRepository.findNotificationsByIds(notificationIds);
 
 		// Build notification message once for all notifications
 		const settings = this.settingsService.getSettings();
 		const clientHost = settings.clientHost || "Host not defined";
-		const notificationMessage = this.notificationMessageBuilder.buildMessage(monitor, check, decision, clientHost);
+		const notificationMessage = this.notificationMessageBuilder.buildMessage(monitor, monitorStatusResponse, decision, clientHost);
 
-		const tasks = notifications.map((notification) => this.send(notification, monitor, check, decision, notificationMessage));
+		const tasks = notifications.map((notification) => this.send(notification, monitor, monitorStatusResponse, decision, notificationMessage));
 
 		const outcomes = await Promise.all(tasks);
 		const succeeded = outcomes.filter(Boolean).length;
@@ -114,11 +114,13 @@ export class NotificationsService implements INotificationsService {
 		return succeeded === notifications.length;
 	};
 
-	handleNotifications = async (monitor: Monitor, check: Check, decision: MonitorActionDecision) => {
-		if (decision.transition === null) return false;
+	handleNotifications = async (monitor: Monitor, monitorStatusResponse: MonitorStatusResponse, decision: MonitorActionDecision) => {
+		if (!decision.shouldSendNotification) {
+			return false;
+		}
 
 		// Send notifications based on decision
-		return await this.sendNotifications(monitor, check, decision);
+		return await this.sendNotifications(monitor, monitorStatusResponse, decision);
 	};
 
 	sendTestNotification = async (notification: Partial<Notification>) => {
@@ -146,17 +148,7 @@ export class NotificationsService implements INotificationsService {
 
 	testAllNotifications = async (notificationIds: string[]) => {
 		const notifications = await this.notificationsRepository.findNotificationsByIds(notificationIds);
-		const tasks = notifications.map((notification) =>
-			this.sendTestNotification(notification).catch((error: unknown) => {
-				this.logger.warn({
-					message: `Test notification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-					service: SERVICE_NAME,
-					method: "testAllNotifications",
-					details: { notificationId: notification.id, type: notification.type },
-				});
-				return false;
-			})
-		);
+		const tasks = notifications.map((notification) => this.sendTestNotification(notification));
 		const outcomes = await Promise.all(tasks);
 		const succeeded = outcomes.filter(Boolean).length;
 		const failed = outcomes.length - succeeded;

server/src/domain/notifications/notification.type.ts

@@ -1,5 +1,3 @@
-import type { HardwareMetricKey } from "@/domain/monitors/monitor.type.js";
-
 export const NotificationChannels = [
 	"email",
 	"slack",
@@ -73,8 +71,7 @@ export interface AlertDiscordPayload {
  * Part of notification system unification effort
  */
 
-export type NotificationType =
-	"monitor_down" | "monitor_up" | "threshold_breach" | "threshold_resolved" | "container_breach" | "container_resolved" | "test";
+export type NotificationType = "monitor_down" | "monitor_up" | "threshold_breach" | "threshold_resolved" | "test";
 
 export type NotificationSeverity = "critical" | "warning" | "info" | "success";
 
@@ -87,7 +84,7 @@ export interface MonitorInfo {
 }
 
 export interface ThresholdBreach {
-	metric: HardwareMetricKey;
+	metric: "cpu" | "memory" | "disk" | "temp";
 	currentValue: number;
 	threshold: number;
 	unit: string;
@@ -119,5 +116,6 @@ export interface NotificationMessage {
 	clientHost: string;
 	metadata: {
 		teamId: string;
+		notificationReason: string;
 	};
 }

server/src/domain/notifications/providers/email.ts

@@ -1,7 +1,6 @@
 const SERVICE_NAME = "EmailProvider";
 import type { Notification } from "@/domain/notifications/notification.type.js";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
-import { AppError } from "@/utils/AppError.js";
 import { buildTestEmail } from "@/domain/notifications/providers/utils.js";
 import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
 import type { ILogger } from "@/utils/logger.js";
@@ -41,13 +40,11 @@ export class EmailProvider extends NotificationProvider {
 			return true;
 		} catch (error: unknown) {
 			this.logger.warn({
-				message: `Email test alert failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+				message: "Email test alert failed",
 				service: SERVICE_NAME,
 				method: "sendTestAlert",
-				details: error instanceof AppError ? error.details : undefined,
 				stack: error instanceof Error ? error.stack : undefined,
 			});
-			if (error instanceof AppError) throw error;
 			return false;
 		}
 	}
@@ -76,10 +73,9 @@ export class EmailProvider extends NotificationProvider {
 			return true;
 		} catch (error: unknown) {
 			this.logger.warn({
-				message: `Email notification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+				message: "Email notification failed",
 				service: SERVICE_NAME,
 				method: "sendMessage",
-				details: error instanceof AppError ? error.details : undefined,
 				stack: error instanceof Error ? error.stack : undefined,
 			});
 			return false;
@@ -96,10 +92,6 @@ export class EmailProvider extends NotificationProvider {
 				return `Monitor ${message.monitor.name} threshold exceeded`;
 			case "threshold_resolved":
 				return `Monitor ${message.monitor.name} thresholds resolved`;
-			case "container_breach":
-				return `Monitor ${message.monitor.name} container alert`;
-			case "container_resolved":
-				return `Monitor ${message.monitor.name} containers recovered`;
 			default:
 				return `Alert: ${message.monitor.name}`;
 		}

server/src/domain/notifications/providers/matrix.ts

@@ -3,7 +3,7 @@ import got from "got";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
 import type { AlertMatrixPayload, Notification } from "@/domain/notifications/notification.type.js";
 import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
-import { getTestMessage, incidentUrl } from "@/domain/notifications/providers/utils.js";
+import { getTestMessage } from "@/domain/notifications/providers/utils.js";
 import { randomUUID } from "crypto";
 
 export class MatrixProvider extends NotificationProvider {
@@ -172,10 +172,10 @@ export class MatrixProvider extends NotificationProvider {
 
 		// Incident link (if incident exists)
 		if (message.content.incident) {
-			const url = incidentUrl(message);
+			const incidentUrl = `${message.clientHost}/infrastructure/${message.monitor.id}`;
 			plainLines.push("");
-			plainLines.push(`View Incident: ${url}`);
-			htmlLines.push(`<p><a href="${this.escapeHtml(url)}">View Incident</a></p>`);
+			plainLines.push(`View Incident: ${incidentUrl}`);
+			htmlLines.push(`<p><a href="${this.escapeHtml(incidentUrl)}">View Incident</a></p>`);
 		}
 
 		// Footer with timestamp

server/src/domain/notifications/providers/ntfy.ts

@@ -2,7 +2,7 @@ const SERVICE_NAME = "NtfyProvider";
 import type { Notification } from "@/domain/notifications/notification.type.js";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
 import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
-import { getTestMessage, incidentUrl } from "@/domain/notifications/providers/utils.js";
+import { getTestMessage } from "@/domain/notifications/providers/utils.js";
 import got from "got";
 
 export class NtfyProvider extends NotificationProvider {
@@ -142,7 +142,7 @@ export class NtfyProvider extends NotificationProvider {
 		}
 
 		if (message.content.incident) {
-			lines.push("", incidentUrl(message));
+			lines.push("", `${message.clientHost}/infrastructure/${message.monitor.id}`);
 		}
 
 		return lines.join("\n");

server/src/domain/notifications/providers/pagerduty.ts

@@ -75,8 +75,7 @@ export class PagerDutyProvider extends NotificationProvider {
 
 	private buildPagerDutyPayload(notification: Notification, message: NotificationMessage): AlertPagerDutyPayload {
 		// Map our notification type to PagerDuty event_action
-		const eventAction =
-			message.type === "monitor_up" || message.type === "threshold_resolved" || message.type === "container_resolved" ? "resolve" : "trigger";
+		const eventAction = message.type === "monitor_up" || message.type === "threshold_resolved" ? "resolve" : "trigger";
 
 		// Map severity to PagerDuty severity levels
 		const severityMap: Record<string, string> = {

server/src/domain/notifications/providers/pushover.ts

@@ -2,7 +2,7 @@ const SERVICE_NAME = "PushoverProvider";
 import type { Notification } from "@/domain/notifications/notification.type.js";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
 import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
-import { getTestMessage, incidentUrl } from "@/domain/notifications/providers/utils.js";
+import { getTestMessage } from "@/domain/notifications/providers/utils.js";
 import got from "got";
 
 export class PushoverProvider extends NotificationProvider {
@@ -101,7 +101,7 @@ export class PushoverProvider extends NotificationProvider {
 
 		if (message.content.incident) {
 			lines.push("");
-			lines.push(`View Incident: ${incidentUrl(message)}`);
+			lines.push(`View Incident: ${message.clientHost}/incidents/${message.monitor.id}`);
 		}
 
 		return lines.join("\n");

server/src/domain/notifications/providers/rocketChat.ts

@@ -1,5 +1,5 @@
 const SERVICE_NAME = "RocketChatProvider";
-import { getMonitorPath, type MonitorType } from "@/domain/monitors/monitor.type.js";
+import { supportsUptimeDetails, type MonitorType } from "@/domain/monitors/monitor.type.js";
 import type { Notification, NotificationMessage } from "@/domain/notifications/notification.type.js";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
 import { getTestMessage } from "@/domain/notifications/providers/utils.js";
@@ -139,7 +139,19 @@ export class RocketChatProvider extends NotificationProvider {
 			return undefined;
 		}
 
-		return `${clientHost}/${getMonitorPath(message.monitor.type as MonitorType)}/${message.monitor.id}`;
+		if (message.monitor.type === "hardware") {
+			return `${clientHost}/infrastructure/${message.monitor.id}`;
+		}
+
+		if (message.monitor.type === "pagespeed") {
+			return `${clientHost}/pagespeed/${message.monitor.id}`;
+		}
+
+		if (supportsUptimeDetails(message.monitor.type as MonitorType)) {
+			return `${clientHost}/uptime/${message.monitor.id}`;
+		}
+
+		return undefined;
 	}
 
 	private severityColor(severity: NotificationMessage["severity"]): string {

server/src/domain/notifications/providers/signalgrid.ts

@@ -1,7 +1,7 @@
 const SERVICE_NAME = "SignalgridProvider";
 import type { Notification, NotificationMessage, NotificationSeverity } from "@/domain/notifications/notification.type.js";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
-import { getTestMessage, incidentUrl } from "@/domain/notifications/providers/utils.js";
+import { getTestMessage } from "@/domain/notifications/providers/utils.js";
 import got from "got";
 
 export class SignalgridProvider extends NotificationProvider {
@@ -115,7 +115,7 @@ export class SignalgridProvider extends NotificationProvider {
 
 		if (message.content.incident) {
 			lines.push("");
-			lines.push(`View Incident: ${incidentUrl(message)}`);
+			lines.push(`View Incident: ${message.clientHost}/incidents/${message.monitor.id}`);
 		}
 
 		return lines.join("\n");

server/src/domain/notifications/providers/slack.ts

@@ -2,7 +2,7 @@ const SERVICE_NAME = "SlackProvider";
 import type { Notification } from "@/domain/notifications/notification.type.js";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
 import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
-import { getTestMessage, incidentUrl } from "@/domain/notifications/providers/utils.js";
+import { getTestMessage } from "@/domain/notifications/providers/utils.js";
 import got, { HTTPError } from "got";
 
 export class SlackProvider extends NotificationProvider {
@@ -161,7 +161,7 @@ export class SlackProvider extends NotificationProvider {
 							text: "View Incident",
 							emoji: true,
 						},
-						url: incidentUrl(message),
+						url: `${message.clientHost}/infrastructure/${message.monitor.id}`,
 						style: "primary",
 					},
 				],

server/src/domain/notifications/providers/teams.ts

@@ -2,7 +2,7 @@ const SERVICE_NAME = "TeamsProvider";
 import type { Notification } from "@/domain/notifications/notification.type.js";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
 import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
-import { getTestMessage, incidentUrl } from "@/domain/notifications/providers/utils.js";
+import { getTestMessage } from "@/domain/notifications/providers/utils.js";
 import got, { HTTPError } from "got";
 
 // Types for Adaptive Card elements
@@ -254,7 +254,7 @@ export class TeamsProvider extends NotificationProvider {
 			actions.push({
 				type: "Action.OpenUrl",
 				title: "View Incident",
-				url: incidentUrl(message),
+				url: `${message.clientHost}/incidents/${message.content.incident.id}`,
 			});
 		}
 

server/src/domain/notifications/providers/telegram.ts

@@ -2,7 +2,7 @@ const SERVICE_NAME = "TelegramProvider";
 import type { Notification } from "@/domain/notifications/notification.type.js";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
 import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
-import { getTestMessage, incidentUrl } from "@/domain/notifications/providers/utils.js";
+import { getTestMessage } from "@/domain/notifications/providers/utils.js";
 import got from "got";
 
 export class TelegramProvider extends NotificationProvider {
@@ -101,7 +101,7 @@ export class TelegramProvider extends NotificationProvider {
 
 		if (message.content.incident) {
 			lines.push("");
-			lines.push(`<a href="${incidentUrl(message)}">View Incident</a>`);
+			lines.push(`<a href="${message.clientHost}/incidents/${message.monitor.id}">View Incident</a>`);
 		}
 
 		return lines.join("\n");

server/src/domain/notifications/providers/utils.ts

@@ -1,8 +1,4 @@
 import { IEmailService } from "@/service/emailService.js";
-import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
-
-export const incidentUrl = (message: NotificationMessage): string => `${message.clientHost}/incidents/${message.monitor.id}`;
-
 export const buildTestEmail = async (emailService: IEmailService) => {
 	const context = { testName: "Monitoring System" };
 	const html = await emailService.buildEmail("testEmailTemplate", context);

server/src/domain/notifications/providers/webhook.ts

@@ -2,7 +2,7 @@ const SERVICE_NAME = "WebhookProvider";
 import type { Notification } from "@/domain/notifications/notification.type.js";
 import { NotificationProvider } from "@/domain/notifications/providers/INotificationProvider.js";
 import type { NotificationMessage } from "@/domain/notifications/notification.type.js";
-import { getTestMessage, incidentUrl } from "@/domain/notifications/providers/utils.js";
+import { getTestMessage } from "@/domain/notifications/providers/utils.js";
 import got from "got";
 
 export class WebhookProvider extends NotificationProvider {
@@ -74,7 +74,7 @@ export class WebhookProvider extends NotificationProvider {
 
 		// Incident link
 		if (message.content.incident) {
-			lines.push(`[View Incident](${incidentUrl(message)})`);
+			lines.push(`[View Incident](${message.clientHost}/infrastructure/${message.monitor.id})`);
 		}
 
 		// Return webhook payload with both text and structured data

server/src/service/bufferService.ts

@@ -55,15 +55,42 @@ export class BufferService implements IBufferService {
 	}
 
 	addToBuffer(check: Check) {
-		this.buffer.push(check);
+		try {
+			this.buffer.push(check);
+		} catch (error: unknown) {
+			this.logger.error({
+				message: error instanceof Error ? error.message : "Unknown error",
+				service: this.SERVICE_NAME,
+				method: "addToBuffer",
+				stack: error instanceof Error ? error.stack : undefined,
+			});
+		}
 	}
 
 	addGeoCheckToBuffer(geoCheck: GeoCheck) {
-		this.geoBuffer.push(geoCheck);
+		try {
+			this.geoBuffer.push(geoCheck);
+		} catch (error: unknown) {
+			this.logger.error({
+				message: error instanceof Error ? error.message : "Unknown error",
+				service: this.SERVICE_NAME,
+				method: "addGeoCheckToBuffer",
+				stack: error instanceof Error ? error.stack : undefined,
+			});
+		}
 	}
 
 	addDockerLogToBuffer(dockerLog: DockerLog): void {
-		this.dockerLogBuffer.push(dockerLog);
+		try {
+			this.dockerLogBuffer.push(dockerLog);
+		} catch (error: unknown) {
+			this.logger.error({
+				message: error instanceof Error ? error.message : "Unknown error",
+				service: this.SERVICE_NAME,
+				method: "addDockerLogToBuffer",
+				stack: error instanceof Error ? error.stack : undefined,
+			});
+		}
 	}
 
 	scheduleNextFlush() {

server/src/service/emailService.ts

@@ -12,23 +12,6 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const SERVICE_NAME = "EmailService";
-
-const SMTP_FAILURE_REASONS: Record<string, string> = {
-	EAUTH: "rejected the login. Check the user name and password",
-	ENOAUTH: "requires a login. Set the user name and password",
-	EDNS: "could not be resolved. Check the host name",
-	ECONNECTION: "refused the connection. Check the host and port",
-	ESOCKET: "refused the connection. Check the host and port",
-	ETIMEDOUT: "did not respond. Check the port and the secure setting",
-	ETLS: "failed the TLS handshake. Check the secure and TLS settings",
-	EPROTOCOL: "sent an invalid response. Check the port and the secure setting",
-};
-
-const describeSmtpFailure = (error: unknown, host: string, port: number): string => {
-	const code = typeof error === "object" && error !== null && "code" in error ? String((error as { code: unknown }).code) : undefined;
-	const reason = (code !== undefined && SMTP_FAILURE_REASONS[code]) || "failed verification";
-	return `SMTP host ${host}:${port} ${reason}.`;
-};
 type MjmlFn = typeof mjml2html;
 type FileSystem = typeof fs;
 type PathModule = typeof path;
@@ -140,15 +123,6 @@ export class EmailService implements IEmailService {
 			systemEmailRejectUnauthorized,
 		} = config;
 
-		if (!systemEmailHost) {
-			throw new AppError({
-				message: "Email is not configured. Set the system email host in settings.",
-				status: 400,
-				service: SERVICE_NAME,
-				method: "sendEmail",
-			});
-		}
-
 		const emailConfig = {
 			host: systemEmailHost,
 			port: Number(systemEmailPort),
@@ -172,20 +146,17 @@ export class EmailService implements IEmailService {
 		try {
 			await this.transporter.verify();
 		} catch (error: unknown) {
-			const cause = error instanceof Error ? error.message : "Unknown error";
 			this.logger.warn({
-				message: `Email transporter verification failed: ${cause}`,
+				message: "Email transporter verification failed",
 				service: SERVICE_NAME,
 				method: "verifyTransporter",
-				details: { host: systemEmailHost, port: emailConfig.port },
 				stack: error instanceof Error ? error.stack : undefined,
 			});
 			throw new AppError({
-				message: describeSmtpFailure(error, systemEmailHost, emailConfig.port),
-				status: 502,
+				message: "Email transporter verification failed",
 				service: SERVICE_NAME,
 				method: "sendEmail",
-				details: { cause },
+				details: { cause: error instanceof Error ? error.message : "Unknown error" },
 			});
 		}
 
@@ -209,7 +180,6 @@ export class EmailService implements IEmailService {
 			});
 			throw new AppError({
 				message: "Failed to send email",
-				status: 502,
 				service: SERVICE_NAME,
 				method: "sendEmail",
 				details: { cause: error instanceof Error ? error.message : "Unknown error" },

server/src/service/globalPingService.ts

@@ -3,7 +3,7 @@ import { supportsGeoCheck, type HttpStatusCode } from "@/domain/monitors/monitor
 import { MonitorType } from "@/domain/monitors/monitor.type.js";
 import type { ILogger } from "@/utils/logger.js";
 import got from "got";
-import { isStatusUp } from "@/service/networkProviders/utils.js";
+import { isStatusUp } from "@/service/network/utils.js";
 
 const SERVICE_NAME = "GlobalPingService";
 const GLOBAL_PING_API_BASE = "https://api.globalping.io/v1";

server/src/service/network/DNSProvider.ts

@@ -1,10 +1,10 @@
 import { DNSStatusPayload, MonitorStatusResponse } from "@/types/network.js";
-import { IStatusProvider } from "@/service/networkProviders/IStatusProvider.js";
+import { IStatusProvider } from "@/service/network/IStatusProvider.js";
 import dns from "dns";
 import type { Resolver } from "dns/promises";
 import { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
 import { AppError } from "@/utils/AppError.js";
-import { timeRequest } from "@/service/networkProviders/utils.js";
+import { timeRequest } from "@/service/network/utils.js";
 import { NETWORK_ERROR } from "@/types/network.js";
 
 const SERVICE_NAME = "DNSProvider";

server/src/service/network/DockerProvider.ts

@@ -1,7 +1,7 @@
 import https from "node:https";
 
-import { IStatusProvider } from "@/service/networkProviders/IStatusProvider.js";
-import { HttpProvider } from "@/service/networkProviders/HttpProvider.js";
+import { IStatusProvider } from "@/service/network/IStatusProvider.js";
+import { HttpProvider } from "@/service/network/HttpProvider.js";
 import { CaptureDockerContainer, CaptureDockerStatusPayload, CheckContext, DockerStatusPayload, MonitorStatusResponse } from "@/types/network.js";
 
 import {
@@ -24,7 +24,7 @@ import { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
 import { ILogger } from "@/utils/logger.js";
 import { AppError } from "@/utils/AppError.js";
 import Dockerode from "dockerode";
-import { timeRequest, peerAnsweredFromError } from "@/service/networkProviders/utils.js";
+import { timeRequest, peerAnsweredFromError } from "@/service/network/utils.js";
 import { NETWORK_ERROR } from "@/types/network.js";
 import { IEncryptionService } from "@/service/encryption/encryptionService.js";
 import { DOCKER_TLS_URL, isCaptureDockerUrl, isDockerTlsUrl } from "@/utils/dockerHost.js";
@@ -42,8 +42,6 @@ const DOCKER_LOG_TRUNCATION_MARKER = " …[truncated]";
 const DOCKER_LOG_TS_REGEX = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?Z /;
 const DOCKER_TLS_DEFAULT_PORT = 2376;
 const CAPTURE_FATAL_ERROR_METRICS = new Set(["docker.client", "docker.container.list"]);
-const EXITED_STATUS = /^Exited \((\d+)\)/;
-const HEALTH_STATUS = /\((healthy|unhealthy|health: starting)\)$/;
 
 export interface DockerError extends Error {
 	statusCode?: number;
@@ -142,17 +140,6 @@ export class DockerProvider implements IStatusProvider<DockerStatusPayload> {
 		return status && (DockerHealthStatuses as readonly string[]).includes(status) ? (status as DockerHealthStatus) : "none";
 	}
 
-	private exitCodeFromStatus = (status: string): number | undefined => {
-		const match = EXITED_STATUS.exec(status);
-		return match ? Number(match[1]) : undefined;
-	};
-
-	private healthFromStatus = (status: string): DockerHealthStatus => {
-		const match = HEALTH_STATUS.exec(status);
-		if (!match) return "none";
-		return match[1] === "health: starting" ? "starting" : (match[1] as DockerHealthStatus);
-	};
-
 	private toContainerSummary(containers: DockerContainerInfo[]): DockerContainerSummary {
 		return {
 			total: containers.length,
@@ -286,10 +273,7 @@ export class DockerProvider implements IStatusProvider<DockerStatusPayload> {
 			info.health = this.toHealthStatus(inspectResult.value.State?.Health?.Status);
 			info.ports = this.toPorts(inspectResult.value.NetworkSettings?.Ports);
 			info.mounts = this.toMounts(inspectResult.value.Mounts);
-			info.exitCode = inspectResult.value.State?.ExitCode;
 		} else {
-			info.exitCode = this.exitCodeFromStatus(summary.Status);
-			info.health = this.healthFromStatus(summary.Status);
 			this.logger.warn({
 				message: `Failed to inspect container ${info.name}`,
 				service: SERVICE_NAME,

server/src/service/network/GameProvider.ts

@@ -1,4 +1,4 @@
-import { IStatusProvider } from "@/service/networkProviders/IStatusProvider.js";
+import { IStatusProvider } from "@/service/network/IStatusProvider.js";
 import { GameStatusPayload, MonitorStatusResponse } from "@/types/network.js";
 import { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
 import { GameDig } from "gamedig";

server/src/service/network/GrpcProvider.ts

@@ -1,8 +1,8 @@
-import { IStatusProvider } from "@/service/networkProviders/IStatusProvider.js";
+import { IStatusProvider } from "@/service/network/IStatusProvider.js";
 import { GrpcStatusPayload, MonitorStatusResponse } from "@/types/network.js";
 import { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
 import { AppError } from "@/utils/AppError.js";
-import { timeRequest } from "@/service/networkProviders/utils.js";
+import { timeRequest } from "@/service/network/utils.js";
 import * as grpc from "@grpc/grpc-js";
 import * as protoLoader from "@grpc/proto-loader";
 

server/src/service/network/HardwareProvider.ts

@@ -1,7 +1,7 @@
-import { IStatusProvider } from "@/service/networkProviders/IStatusProvider.js";
+import { IStatusProvider } from "@/service/network/IStatusProvider.js";
 import { HardwareStatusPayload, MonitorStatusResponse } from "@/types/network.js";
 import { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
-import { HttpProvider } from "@/service/networkProviders/HttpProvider.js";
+import { HttpProvider } from "@/service/network/HttpProvider.js";
 import { AppError } from "@/utils/AppError.js";
 
 export class HardwareProvider implements IStatusProvider<HardwareStatusPayload> {

server/src/service/network/HttpProvider.ts

@@ -1,12 +1,12 @@
 import { type Got, HTTPError, RequestError } from "got";
-import { IAdvancedMatcher } from "@/service/networkProviders/AdvancedMatcher.js";
-import { IStatusProvider } from "@/service/networkProviders/IStatusProvider.js";
+import { IAdvancedMatcher } from "@/service/network/AdvancedMatcher.js";
+import { IStatusProvider } from "@/service/network/IStatusProvider.js";
 import { HttpStatusPayload } from "@/types/network.js";
 import { MonitorStatusResponse } from "@/types/network.js";
 import { Agent as HttpsAgent } from "https";
 import { Agent as HttpAgent } from "http";
 import { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
-import { isStatusUp, peerAnsweredFromError } from "@/service/networkProviders/utils.js";
+import { isStatusUp, peerAnsweredFromError } from "@/service/network/utils.js";
 import { NETWORK_ERROR } from "@/types/network.js";
 import CacheableLookup from "cacheable-lookup";
 import { HttpProxyAgent, HttpsProxyAgent } from "hpagent";

server/src/service/network/PageSpeedProvider.ts

@@ -1,7 +1,7 @@
-import { IStatusProvider } from "@/service/networkProviders/IStatusProvider.js";
+import { IStatusProvider } from "@/service/network/IStatusProvider.js";
 import { MonitorStatusResponse, PageSpeedStatusPayload } from "@/types/network.js";
 import { Monitor, MonitorType, DefaultPageSpeedStrategy } from "@/domain/monitors/monitor.type.js";
-import { HttpProvider } from "@/service/networkProviders/HttpProvider.js";
+import { HttpProvider } from "@/service/network/HttpProvider.js";
 import { ISettingsService } from "@/domain/app-settings/app-settings.service.js";
 import { ILogger } from "@/utils/logger.js";
 import { AppError } from "@/utils/AppError.js";

server/src/service/network/PingProvider.ts

@@ -5,7 +5,7 @@ import { MonitorStatusResponse } from "@/types/network.js";
 import { AppError } from "@/utils/AppError.js";
 import ping from "ping";
 import * as net from "net";
-import { timeRequest } from "@/service/networkProviders/utils.js";
+import { timeRequest } from "@/service/network/utils.js";
 const SERVICE_NAME = "PingProvider";
 
 type Ping = typeof ping;

server/src/service/network/PortProvider.ts

@@ -1,8 +1,8 @@
-import { IStatusProvider } from "@/service/networkProviders/IStatusProvider.js";
+import { IStatusProvider } from "@/service/network/IStatusProvider.js";
 import { PortStatusPayload, MonitorStatusResponse } from "@/types/network.js";
 import { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
 import { AppError } from "@/utils/AppError.js";
-import { timeRequest, peerAnsweredFromError } from "@/service/networkProviders/utils.js";
+import { timeRequest, peerAnsweredFromError } from "@/service/network/utils.js";
 import { NETWORK_ERROR } from "@/types/network.js";
 import * as net from "net";
 type NetType = typeof net;

server/src/service/network/WebSocketProvider.ts

@@ -1,8 +1,8 @@
-import { IStatusProvider } from "@/service/networkProviders/IStatusProvider.js";
+import { IStatusProvider } from "@/service/network/IStatusProvider.js";
 import { WebSocketStatusPayload, MonitorStatusResponse } from "@/types/network.js";
 import { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
 import { AppError } from "@/utils/AppError.js";
-import { timeRequest, peerAnsweredFromError } from "@/service/networkProviders/utils.js";
+import { timeRequest, peerAnsweredFromError } from "@/service/network/utils.js";
 import { NETWORK_ERROR } from "@/types/network.js";
 import type WebSocket from "ws";
 

server/src/service/networkProviders/providerRegistry.ts

@@ -1,34 +0,0 @@
-import type { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
-import type { CheckContext, MonitorPayloadMap, MonitorStatusResponse } from "@/types/network.js";
-import { NETWORK_ERROR } from "@/types/network.js";
-import { IStatusProvider } from "./IStatusProvider.js";
-const SERVICE_NAME = "ProviderRegistry";
-
-export interface IProviderRegistry {
-	probe<T extends MonitorType>(monitor: Monitor & { type: T }, ctx?: CheckContext): Promise<MonitorStatusResponse<MonitorPayloadMap[T]>>;
-}
-
-export class ProviderRegistry implements IProviderRegistry {
-	static SERVICE_NAME = SERVICE_NAME;
-
-	constructor(private providers: IStatusProvider<unknown>[]) {}
-
-	async probe<T extends MonitorType>(monitor: Monitor & { type: T }, ctx?: CheckContext): Promise<MonitorStatusResponse<MonitorPayloadMap[T]>> {
-		const provider = this.providers.find((p) => p.supports(monitor.type));
-		if (!provider) {
-			return this.handleUnsupportedType(monitor.type) as Promise<MonitorStatusResponse<MonitorPayloadMap[T]>>;
-		}
-		return provider.handle(monitor, ctx) as Promise<MonitorStatusResponse<MonitorPayloadMap[T]>>;
-	}
-
-	private async handleUnsupportedType(type: string): Promise<MonitorStatusResponse> {
-		return {
-			monitorId: "unknown",
-			teamId: "unknown",
-			type: "unknown",
-			status: false,
-			code: NETWORK_ERROR,
-			message: `Unsupported type: ${type}`,
-		};
-	}
-}

server/src/service/networkService.ts

@@ -0,0 +1,198 @@
+import type { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
+import type { CheckContext, MonitorPayloadMap, MonitorStatusResponse } from "@/types/network.js";
+import type { AxiosStatic } from "axios";
+import { AppError } from "@/utils/AppError.js";
+import { NETWORK_ERROR } from "@/types/network.js";
+import { ILogger } from "@/utils/logger.js";
+import { IStatusProvider } from "./network/IStatusProvider.js";
+const SERVICE_NAME = "NetworkService";
+
+export interface INetworkService {
+	requestStatus<T extends MonitorType>(monitor: Monitor & { type: T }, ctx?: CheckContext): Promise<MonitorStatusResponse<MonitorPayloadMap[T]>>;
+	requestWebhook(
+		type: string,
+		url: string,
+		body: unknown
+	): Promise<{ type: string; status: boolean; code: number; message: string; payload?: unknown }>;
+	requestPagerDuty(args: { message: string; routingKey: string; monitorUrl: string }): Promise<boolean>;
+	requestMatrix(args: { homeserverUrl: string; accessToken: string; roomId: string; message: string }): Promise<{
+		status: boolean;
+		code: number;
+		message: string;
+		payload?: unknown;
+	}>;
+}
+
+export class NetworkService implements INetworkService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	private axios: AxiosStatic;
+	private logger: ILogger;
+
+	constructor(
+		axios: AxiosStatic,
+		logger: ILogger,
+		private providers: IStatusProvider<unknown>[]
+	) {
+		this.axios = axios;
+		this.logger = logger;
+	}
+
+	// Main entry point
+	async requestStatus<T extends MonitorType>(
+		monitor: Monitor & { type: T },
+		ctx?: CheckContext
+	): Promise<MonitorStatusResponse<MonitorPayloadMap[T]>> {
+		const provider = this.providers.find((p) => p.supports(monitor.type));
+		if (!provider) {
+			return this.handleUnsupportedType(monitor.type) as Promise<MonitorStatusResponse<MonitorPayloadMap[T]>>;
+		}
+		return provider.handle(monitor, ctx) as Promise<MonitorStatusResponse<MonitorPayloadMap[T]>>;
+	}
+
+	private async handleUnsupportedType(type: string): Promise<MonitorStatusResponse> {
+		return {
+			monitorId: "unknown",
+			teamId: "unknown",
+			type: "unknown",
+			status: false,
+			code: NETWORK_ERROR,
+			message: `Unsupported type: ${type}`,
+		};
+	}
+
+	// Other network requests unrelated to monitoring:
+	async requestWebhook(type: string, url: string, body: unknown) {
+		try {
+			const response = await this.axios.post(url, body, {
+				headers: {
+					"Content-Type": "application/json",
+				},
+			});
+
+			return {
+				type: "webhook",
+				status: true,
+				code: response.status,
+				message: `Successfully sent ${type} notification`,
+				payload: response.data,
+			};
+		} catch (err: unknown) {
+			this.logger.warn({
+				message: err instanceof Error ? err.message : String(err),
+				service: SERVICE_NAME,
+				method: "requestWebhook",
+			});
+
+			if (err && typeof err === "object" && "response" in err) {
+				const axiosError = err as { response?: { status?: number; data?: unknown } };
+				return {
+					type: "webhook",
+					status: false,
+					code: axiosError.response?.status ?? NETWORK_ERROR,
+					message: `Failed to send ${type} notification`,
+					payload: axiosError.response?.data,
+				};
+			}
+
+			return {
+				type: "webhook",
+				status: false,
+				code: NETWORK_ERROR,
+				message: `Failed to send ${type} notification`,
+			};
+		}
+	}
+
+	async requestPagerDuty({ message, routingKey, monitorUrl }: { message: string; routingKey: string; monitorUrl: string }) {
+		try {
+			const response = await this.axios.post(`https://events.pagerduty.com/v2/enqueue`, {
+				routing_key: routingKey,
+				event_action: "trigger",
+				payload: {
+					summary: message,
+					severity: "critical",
+					source: monitorUrl,
+					timestamp: new Date().toISOString(),
+				},
+			});
+
+			if (response.data?.status !== "success") return false;
+			return true;
+		} catch (err: unknown) {
+			const originalMessage = err instanceof Error ? err.message : String(err);
+
+			throw new AppError({
+				message: originalMessage || "Error sending PagerDuty notification",
+				service: SERVICE_NAME,
+				method: "requestPagerDuty",
+				details: {
+					responseData: err && typeof err === "object" && "response" in err ? (err as { response?: { data?: unknown } }).response?.data : undefined,
+				},
+			});
+		}
+	}
+
+	async requestMatrix({
+		homeserverUrl,
+		accessToken,
+		roomId,
+		message,
+	}: {
+		homeserverUrl: string;
+		accessToken: string;
+		roomId: string;
+		message: string;
+	}) {
+		try {
+			const url = `${homeserverUrl}/_matrix/client/v3/rooms/${roomId}/send/m.room.message?access_token=${accessToken}`;
+			const body = {
+				msgtype: "m.text",
+				body: message,
+				format: "org.matrix.custom.html",
+				formatted_body: message,
+			};
+			const response = await this.axios.post(url, body, {
+				headers: {
+					"Content-Type": "application/json",
+				},
+			});
+
+			return {
+				status: true,
+				code: response.status,
+				message: "Successfully sent Matrix notification",
+			};
+		} catch (err: unknown) {
+			if (err instanceof Error) {
+				this.logger.warn({
+					message: err.message,
+					service: SERVICE_NAME,
+					method: "requestMatrix",
+				});
+
+				if (err && typeof err === "object" && "response" in err) {
+					const axiosError = err as { response?: { status?: number; data?: unknown } };
+					return {
+						status: false,
+						code: axiosError.response?.status || NETWORK_ERROR,
+						message: "Failed to send Matrix notification",
+						payload: axiosError.response?.data,
+					};
+				}
+			}
+
+			this.logger.warn({
+				message: String(err),
+				service: SERVICE_NAME,
+				method: "requestMatrix",
+			});
+
+			return {
+				status: false,
+				code: NETWORK_ERROR,
+				message: "Failed to send Matrix notification",
+			};
+		}
+	}
+}

server/src/service/statusService.ts

@@ -1,27 +1,49 @@
 import { IMonitorStatsRepository } from "@/domain/monitor-stats/monitor-stats.repository.interface.js";
 import { IMonitorsRepository } from "@/domain/monitors/monitor.repository.interface.js";
 import type { Check, CheckDiskInfo } from "@/domain/checks/check.type.js";
-import {
-	HardwareMetricKeys,
-	MonitorStatuses,
-	type HardwareBreaches,
-	type HardwareCounters,
-	type Monitor,
-	type MonitorStatus,
-} from "@/domain/monitors/monitor.type.js";
-import type { StatusChangeResult } from "@/types/network.js";
+import { MonitorStatuses, type Monitor, type MonitorStatus } from "@/domain/monitors/monitor.type.js";
+import type {
+	DockerStatusPayload,
+	GameStatusPayload,
+	GrpcStatusPayload,
+	HardwareStatusPayload,
+	HttpStatusPayload,
+	MonitorStatusResponse,
+	PageSpeedStatusPayload,
+	PingStatusPayload,
+	PortStatusPayload,
+	StatusChangeResult,
+} from "@/types/network.js";
 import { AppError } from "@/utils/AppError.js";
 import { ILogger } from "@/utils/logger.js";
 import type { HardwareStatusMetrics } from "@/types/network.js";
 import { MAX_RECENT_CHECKS } from "@/domain/monitors/monitor.type.js";
 import { toCheckSnapshot } from "@/domain/checks/check.snapshot.js";
-import { findContainerBreaches } from "@/domain/docker/docker-alert.js";
 
 const SERVICE_NAME = "StatusService";
 const HARDWARE_ALERT_COUNTER_START = 5;
+const HARDWARE_METRIC_KEYS = ["cpu", "memory", "disk", "temp"] as const;
+type HardwareMetricKey = (typeof HARDWARE_METRIC_KEYS)[number];
+type HardwareBreaches = Record<HardwareMetricKey, boolean>;
+type HardwareCounters = Record<HardwareMetricKey, number>;
 
 export interface IStatusService {
-	updateMonitorStatus(check: Check, monitor: Monitor): Promise<StatusChangeResult>;
+	updateRunningStats(monitor: Monitor, networkResponse: MonitorStatusResponse): Promise<boolean>;
+	updateMonitorStatus(
+		statusResponse: MonitorStatusResponse<
+			| PingStatusPayload
+			| HttpStatusPayload
+			| PageSpeedStatusPayload
+			| HardwareStatusPayload
+			| DockerStatusPayload
+			| PortStatusPayload
+			| GameStatusPayload
+			| GrpcStatusPayload
+			| undefined
+		>,
+		check: Check,
+		monitor: Monitor
+	): Promise<StatusChangeResult>;
 }
 
 export class StatusService implements IStatusService {
@@ -36,20 +58,33 @@ export class StatusService implements IStatusService {
 		this.monitorStatsRepository = monitorStatsRepository;
 	}
 
-	private tryUpdateRunningStats = async (check: Check, monitor: Monitor) => {
+	async updateRunningStats(monitor: Monitor, networkResponse: MonitorStatusResponse) {
 		try {
 			await this.monitorStatsRepository.updateByMonitorId(monitor.id, {
-				status: check.status === true,
-				responseTime: check.responseTime ?? 0,
+				status: networkResponse.status === true,
+				responseTime: networkResponse.responseTime ?? 0,
 				now: Date.now(),
 			});
+			return true;
 		} catch (error: unknown) {
-			this.logger.warn({
+			this.logger.error({
 				service: SERVICE_NAME,
 				message: error instanceof Error ? error.message : "Unknown error",
-				method: "tryUpdateRunningStats",
+				method: "updateRunningStats",
 				stack: error instanceof Error ? error.stack : undefined,
 			});
+			return false;
+		}
+	}
+
+	private tryUpdateRunningStats = async (monitor: Monitor, statusResponse: MonitorStatusResponse) => {
+		const statsOk = await this.updateRunningStats(monitor, statusResponse);
+		if (!statsOk) {
+			this.logger.warn({
+				service: SERVICE_NAME,
+				method: "updateMonitorStatus",
+				message: `Stats update failed for monitor ${monitor.id}`,
+			});
 		}
 	};
 
@@ -100,7 +135,7 @@ export class StatusService implements IStatusService {
 
 		// Update counters: decrement (floored at 0) if breached, reset to start otherwise.
 		const nextCounters = { ...counters };
-		for (const key of HardwareMetricKeys) {
+		for (const key of HARDWARE_METRIC_KEYS) {
 			nextCounters[key] = breaches[key] ? Math.max(0, counters[key] - 1) : HARDWARE_ALERT_COUNTER_START;
 		}
 
@@ -112,8 +147,8 @@ export class StatusService implements IStatusService {
 		if (!reachabilityDown) {
 			// A counter can only reach zero via the decrement path, which only runs when that
 			// metric is currently breaching — so anyCounterZero already implies anyBreached.
-			const anyCounterZero = HardwareMetricKeys.some((k) => nextCounters[k] === 0);
-			const allNormal = HardwareMetricKeys.every((k) => !breaches[k]);
+			const anyCounterZero = HARDWARE_METRIC_KEYS.some((k) => nextCounters[k] === 0);
+			const allNormal = HARDWARE_METRIC_KEYS.every((k) => !breaches[k]);
 
 			if (anyCounterZero && currentStatus !== "breached") {
 				nextStatus = "breached";
@@ -127,29 +162,26 @@ export class StatusService implements IStatusService {
 		return { nextStatus, transitioned, breaches, nextCounters };
 	};
 
-	private computeDockerStatus = (params: { currentStatus: MonitorStatus; reachabilityDown: boolean; breaching: boolean }) => {
-		const { currentStatus, reachabilityDown, breaching } = params;
-		let nextStatus: MonitorStatus = currentStatus;
-		let transitioned = false;
-
-		if (!reachabilityDown) {
-			if (breaching && currentStatus !== "breached") {
-				nextStatus = "breached";
-				transitioned = true;
-			} else if (!breaching && currentStatus === "breached") {
-				nextStatus = "up";
-				transitioned = true;
-			}
-		}
-		return { nextStatus, transitioned };
-	};
-
-	updateMonitorStatus = async (check: Check, monitor: Monitor): Promise<StatusChangeResult> => {
+	updateMonitorStatus = async (
+		statusResponse: MonitorStatusResponse<
+			| PingStatusPayload
+			| HttpStatusPayload
+			| PageSpeedStatusPayload
+			| HardwareStatusPayload
+			| DockerStatusPayload
+			| PortStatusPayload
+			| GameStatusPayload
+			| GrpcStatusPayload
+			| undefined
+		>,
+		check: Check,
+		monitor: Monitor
+	): Promise<StatusChangeResult> => {
 		try {
-			const { status } = check;
+			const { status, code } = statusResponse;
 
 			// Update running stats
-			await this.tryUpdateRunningStats(check, monitor);
+			await this.tryUpdateRunningStats(monitor, statusResponse);
 
 			const prevStatus = monitor.status;
 			const checkSnapshot = toCheckSnapshot(check);
@@ -174,63 +206,70 @@ export class StatusService implements IStatusService {
 				statusChanged = newStatus === "down";
 			}
 
-			let thresholdBreaches: HardwareBreaches | undefined;
+			// Not enough data points yet — record the check and return
+			if (projectedWindow.length < monitor.statusWindowSize) {
+				const updated = await this.monitorsRepository.updateStatusWindowAndChecks(
+					monitor.id,
+					monitor.teamId,
+					check.status,
+					checkSnapshot,
+					monitor.statusWindowSize,
+					MAX_RECENT_CHECKS,
+					patch
+				);
 
-			if (projectedWindow.length >= monitor.statusWindowSize) {
-				// First evaluate reachability status changes, which apply to all monitor types
-				// and take precedence over hardware breaches.
-				const reachabilityResult = this.computeReachability(newStatus, projectedWindow, monitor.statusWindowThreshold);
-				if (reachabilityResult.transitioned) {
-					newStatus = reachabilityResult.nextStatus;
+				return {
+					monitor: updated,
+					statusChanged,
+					prevStatus,
+					code,
+					timestamp: Date.now(),
+				};
+			}
+
+			// First evaluate reachability status changes, which apply to all monitor types
+			// and take precedence over hardware breaches.
+			const reachabilityResult = this.computeReachability(newStatus, projectedWindow, monitor.statusWindowThreshold);
+			if (reachabilityResult.transitioned) {
+				newStatus = reachabilityResult.nextStatus;
+				statusChanged = true;
+			}
+
+			// Evaluate hardware threshold breaches (only for hardware monitors with metrics payload)
+			let thresholdBreaches: HardwareBreaches | undefined;
+			const hardwarePayload = statusResponse.payload as HardwareStatusPayload | undefined;
+			if (monitor.type === "hardware" && hardwarePayload?.data) {
+				const hardware = this.computeHardwareStatus({
+					currentStatus: newStatus,
+					reachabilityDown: newStatus === "down",
+					metrics: hardwarePayload.data,
+					thresholds: {
+						cpu: monitor.cpuAlertThreshold,
+						memory: monitor.memoryAlertThreshold,
+						disk: monitor.diskAlertThreshold,
+						temp: monitor.tempAlertThreshold,
+					},
+					counters: {
+						cpu: monitor.cpuAlertCounter,
+						memory: monitor.memoryAlertCounter,
+						disk: monitor.diskAlertCounter,
+						temp: monitor.tempAlertCounter,
+					},
+				});
+
+				patch.cpuAlertCounter = hardware.nextCounters.cpu;
+				patch.memoryAlertCounter = hardware.nextCounters.memory;
+				patch.diskAlertCounter = hardware.nextCounters.disk;
+				patch.tempAlertCounter = hardware.nextCounters.temp;
+				thresholdBreaches = hardware.breaches;
+				if (hardware.transitioned) {
+					newStatus = hardware.nextStatus;
 					statusChanged = true;
 				}
-
-				// Evaluate hardware threshold breaches
-				if (monitor.type === "hardware") {
-					const hardware = this.computeHardwareStatus({
-						currentStatus: newStatus,
-						reachabilityDown: newStatus === "down",
-						metrics: check,
-						thresholds: {
-							cpu: monitor.cpuAlertThreshold,
-							memory: monitor.memoryAlertThreshold,
-							disk: monitor.diskAlertThreshold,
-							temp: monitor.tempAlertThreshold,
-						},
-						counters: {
-							cpu: monitor.cpuAlertCounter,
-							memory: monitor.memoryAlertCounter,
-							disk: monitor.diskAlertCounter,
-							temp: monitor.tempAlertCounter,
-						},
-					});
-
-					patch.cpuAlertCounter = hardware.nextCounters.cpu;
-					patch.memoryAlertCounter = hardware.nextCounters.memory;
-					patch.diskAlertCounter = hardware.nextCounters.disk;
-					patch.tempAlertCounter = hardware.nextCounters.temp;
-					thresholdBreaches = hardware.breaches;
-					if (hardware.transitioned) {
-						newStatus = hardware.nextStatus;
-						statusChanged = true;
-					}
-				}
-
-				if (monitor.type === "docker" && check.containers) {
-					const breaches = findContainerBreaches(monitor, check.containers);
-					const docker = this.computeDockerStatus({
-						currentStatus: newStatus,
-						reachabilityDown: newStatus === "down",
-						breaching: breaches.length > 0,
-					});
-					if (docker.transitioned) {
-						newStatus = docker.nextStatus;
-						statusChanged = true;
-					}
-				}
-				patch.status = newStatus;
 			}
 
+			patch.status = newStatus;
+
 			// Single atomic write: push arrays + set status/counters
 			const updated = await this.monitorsRepository.updateStatusWindowAndChecks(
 				monitor.id,
@@ -246,6 +285,8 @@ export class StatusService implements IStatusService {
 				monitor: updated,
 				statusChanged,
 				prevStatus,
+				code,
+				timestamp: new Date().getTime(),
 				thresholdBreaches,
 			};
 		} catch (error: unknown) {

server/src/types/network.ts

@@ -10,7 +10,7 @@ import type {
 	ILighthouseAudit,
 } from "@/domain/checks/check.type.js";
 import { DockerContainerInfo, DockerContainerLogs, DockerContainerSummary } from "@/domain/docker/docker.type.js";
-import type { DnsRecordType, HardwareBreaches, Monitor, MonitorMatchMethod, MonitorStatus, MonitorType } from "@/domain/monitors/monitor.type.js";
+import type { DnsRecordType, Monitor, MonitorMatchMethod, MonitorStatus, MonitorType } from "@/domain/monitors/monitor.type.js";
 
 import type { QueryResult } from "gamedig";
 
@@ -182,7 +182,14 @@ export type StatusChangeResult = {
 	monitor: Monitor;
 	statusChanged: boolean;
 	prevStatus: MonitorStatus;
-	thresholdBreaches?: HardwareBreaches;
+	code: number;
+	timestamp: number;
+	thresholdBreaches?: {
+		cpu: boolean;
+		memory: boolean;
+		disk: boolean;
+		temp: boolean;
+	};
 };
 
 export type MonitorStatusResponseOverrides<T> = Partial<Omit<MonitorStatusResponse<T>, "monitorId" | "teamId" | "type">>;

server/src/utils/logger.ts

@@ -60,18 +60,21 @@ class Logger implements ILogger {
 			if (formattedDetails) msg += ` (details: ${formattedDetails})`;
 
 			if (typeof stack === "string") {
-				const stackTrace = stack.split("\n").map((line: string) => {
-					const match = line.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
-					if (match) {
-						return {
-							function: match[1],
-							file: match[2],
-							line: parseInt(match[3] ?? "0", 10),
-							column: parseInt(match[4] ?? "0", 10),
-						};
-					}
-					return line.trim();
-				});
+				const stackTrace = stack
+					.split("\n")
+					.slice(1) // Remove first line (error message)
+					.map((line: string) => {
+						const match = line.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
+						if (match) {
+							return {
+								function: match[1],
+								file: match[2],
+								line: parseInt(match[3] ?? "0", 10),
+								column: parseInt(match[4] ?? "0", 10),
+							};
+						}
+						return line.trim();
+					});
 				msg += ` (stack: ${JSON.stringify(stackTrace, null, 2)})`;
 			}
 

server/src/worker/reactors/reactor.incident.ts

@@ -8,6 +8,6 @@ export class IncidentReactor implements IMonitorReactor {
 	constructor(private incidentService: IIncidentService) {}
 
 	react = async (evaluation: MonitorEvaluation) => {
-		await this.incidentService.handleIncident(evaluation.monitor, evaluation.decision, evaluation.check);
+		await this.incidentService.handleIncident(evaluation.monitor, evaluation.statusChange.code, evaluation.decision, evaluation.status);
 	};
 }

server/src/worker/reactors/reactor.notification.ts

@@ -7,6 +7,7 @@ export class NotificationReactor implements IMonitorReactor {
 	constructor(private notificationService: INotificationsService) {}
 
 	react = async (evaluation: MonitorEvaluation) => {
-		await this.notificationService.handleNotifications(evaluation.monitor, evaluation.check, evaluation.decision);
+		if (!evaluation.decision.shouldSendNotification) return;
+		await this.notificationService.handleNotifications(evaluation.monitor, evaluation.status, evaluation.decision);
 	};
 }

server/src/worker/worker.interface.ts

@@ -1,23 +1,31 @@
-import { HardwareBreaches, Monitor } from "@/domain/monitors/monitor.type.js";
+import { Monitor } from "@/domain/monitors/monitor.type.js";
 import { Check } from "@/domain/checks/check.type.js";
 import { Job, JobType } from "@/domain/jobs/job.type.js";
+import { MonitorPayloadMap, MonitorStatusResponse, StatusChangeResult } from "@/types/network.js";
 import { QueueWorker } from "@/domain/queue-workers/queue-worker.type.js";
 import type { QueueMode } from "@/domain/app-settings/app-settings.type.js";
 
 export type JobHandler = (job: Job) => Promise<void>;
 export type JobHandlers = Record<JobType, JobHandler>;
-
-export const MonitorTransitions = ["status_down", "status_up", "threshold_breach", "threshold_resolved"] as const;
-export type MonitorTransition = (typeof MonitorTransitions)[number];
-
 export interface MonitorActionDecision {
-	transition: MonitorTransition | null;
-	thresholdBreaches?: HardwareBreaches;
+	shouldCreateIncident: boolean;
+	shouldResolveIncident: boolean;
+	shouldSendNotification: boolean;
+	incidentReason: "status_down" | "threshold_breach" | null;
+	notificationReason: "status_change" | "threshold_breach" | null;
+	thresholdBreaches?: {
+		cpu?: boolean;
+		memory?: boolean;
+		disk?: boolean;
+		temp?: boolean;
+	};
 }
 
 export type MonitorEvaluation = {
 	monitor: Monitor;
+	status: MonitorStatusResponse<MonitorPayloadMap[keyof MonitorPayloadMap]>; // raw result from networkService.requestStatus
 	check: Check;
+	statusChange: StatusChangeResult; // from statusService.updateMonitorStatus
 	decision: MonitorActionDecision;
 };
 

server/src/worker/worker.pipeline.ts

@@ -3,14 +3,15 @@ import { ICheckService } from "@/domain/checks/check.service.js";
 import { Check } from "@/domain/checks/check.type.js";
 import { IDockerLogsService } from "@/domain/docker/docker-log.service.js";
 import { IEgressService, isHttpStatusCode } from "@/domain/egress/egress.service.js";
+import type { EgressStatus } from "@/domain/egress/egress.type.js";
 import { IJobsRepository } from "@/domain/jobs/job.repository.interface.js";
 import { PendingCheck } from "@/domain/jobs/job.type.js";
 import { IMaintenanceWindowsRepository } from "@/domain/maintenance-windows/maintenance-window.repository.interface.js";
 import { IMonitorsRepository } from "@/domain/monitors/monitor.repository.interface.js";
 import { isEgressAttributable, Monitor } from "@/domain/monitors/monitor.type.js";
 import { IBufferService } from "@/service/bufferService.js";
-import { IProxyResolver } from "@/service/networkProviders/ProxyResolver.js";
-import { IProviderRegistry } from "@/service/networkProviders/providerRegistry.js";
+import { IProxyResolver } from "@/service/network/ProxyResolver.js";
+import { INetworkService } from "@/service/networkService.js";
 import { IStatusService } from "@/service/statusService.js";
 import { DockerStatusPayload, MonitorStatusResponse, StatusChangeResult } from "@/types/network.js";
 import { AppError } from "@/utils/AppError.js";
@@ -36,7 +37,7 @@ export interface WorkerPipelineDependencies {
 	checksRepository: IChecksRepository;
 	jobsRepository: IJobsRepository;
 	checkService: ICheckService;
-	providerRegistry: IProviderRegistry;
+	networkService: INetworkService;
 	proxyResolver: IProxyResolver;
 	bufferService: IBufferService;
 	dockerLogsService: IDockerLogsService;
@@ -103,7 +104,7 @@ export class WorkerPipeline implements IWorkerPipeline {
 		const proxyUrl = await this.deps.proxyResolver.resolve(monitor);
 		const dockerTlsKey = await this.resolveDockerTlsKey(monitor);
 
-		const status = await this.deps.providerRegistry.probe(monitor, { proxyUrl, dockerTlsKey });
+		const status = await this.deps.networkService.requestStatus(monitor, { proxyUrl, dockerTlsKey });
 		if (!status) {
 			throw new Error("No network response");
 		}
@@ -127,7 +128,7 @@ export class WorkerPipeline implements IWorkerPipeline {
 
 		// Step 2b: On a transport failure, ask whether the instance itself can reach anything before blaming the
 		// target. Null means the egress check is disabled (or failed internally) and the check is treated as usual.
-		const egressStatus = this.isTransportFailure(monitor, status) ? await this.deps.egressService.assessAfterFailure() : null;
+		const egressStatus = this.isTransportFailure(monitor, status) ? await this.assessEgress(monitor.id) : null;
 		if (egressStatus !== null) {
 			check.egressStatus = egressStatus;
 		}
@@ -170,6 +171,20 @@ export class WorkerPipeline implements IWorkerPipeline {
 		return status.status === false && isEgressAttributable(monitor) && !this.peerAnswered(status);
 	}
 
+	// The egress check must never stop a check being recorded, so a rejection is logged and treated as unknown.
+	private async assessEgress(monitorId: string): Promise<EgressStatus | null> {
+		try {
+			return await this.deps.egressService.assessAfterFailure();
+		} catch (error: unknown) {
+			this.deps.logger.warn({
+				message: `Egress assessment failed for monitor ${monitorId}: ${error instanceof Error ? error.message : String(error)}`,
+				service: SERVICE_NAME,
+				method: "assessEgress",
+			});
+			return null;
+		}
+	}
+
 	// ****************************************************************
 	// Stage 2: Ingestion
 	// Called by the buffer, checks are inserted and evaluation jobs created
@@ -225,7 +240,8 @@ export class WorkerPipeline implements IWorkerPipeline {
 
 		let current = monitor;
 		for (const check of checks) {
-			const evaluation = await this.evaluateCheck(check, current);
+			const status = this.deps.checkService.toStatusResponse(check);
+			const evaluation = await this.evaluateCheck(status, check, current);
 			await this.deps.dispatcher.dispatch(evaluation); // Handle incidents and notifications
 			const leaseHeld = await this.deps.jobsRepository.pullEvaluated(job.id, [check.id]);
 			if (!leaseHeld) {
@@ -237,7 +253,7 @@ export class WorkerPipeline implements IWorkerPipeline {
 				});
 				return;
 			}
-			current = evaluation.monitor; // fresh statusWindow/status/counters for the next check
+			current = evaluation.statusChange.monitor; // fresh statusWindow/status/counters for the next check
 		}
 
 		// Ids whose check was not returned (deleted by retention cleanup) would otherwise sit on the row forever
@@ -256,47 +272,65 @@ export class WorkerPipeline implements IWorkerPipeline {
 	// A check taken while the instance had no outbound connectivity says nothing about the target.
 	// It is left out of the status window, running stats and monitor status entirely, so that no incident
 	// opens for it and no spurious "resolved"/"up" fires once egress returns.
-	private skipDegradedEgressCheck = (check: Check, monitor: Monitor): MonitorEvaluation => {
+	private skipDegradedEgressCheck = (status: MonitorStatusResponse, check: Check, monitor: Monitor): MonitorEvaluation => {
 		this.deps.logger.debug({
 			message: `Skipping evaluation of check ${check.id} for monitor ${monitor.id}: instance egress was degraded`,
 			service: SERVICE_NAME,
 			method: "evaluateCheck",
 		});
-
+		const decision: MonitorActionDecision = {
+			shouldCreateIncident: false,
+			shouldResolveIncident: false,
+			shouldSendNotification: false,
+			incidentReason: null,
+			notificationReason: null,
+		};
 		return {
 			monitor,
+			status,
 			check,
-			decision: { transition: null },
+			statusChange: { monitor, statusChanged: false, prevStatus: monitor.status, code: status.code, timestamp: Date.now() },
+			decision,
 		};
 	};
 
-	evaluateCheck = async (check: Check, monitor: Monitor): Promise<MonitorEvaluation> => {
+	evaluateCheck = async (status: MonitorStatusResponse, check: Check, monitor: Monitor): Promise<MonitorEvaluation> => {
 		if (check.egressStatus === "degraded") {
-			return this.skipDegradedEgressCheck(check, monitor);
+			return this.skipDegradedEgressCheck(status, check, monitor);
 		}
 
-		const statusChange = await this.deps.statusService.updateMonitorStatus(check, monitor);
+		const statusChange = await this.deps.statusService.updateMonitorStatus(status, check, monitor);
 
 		const decision = this.decide(statusChange);
-		return { monitor: statusChange.monitor, check, decision };
+		return { monitor: statusChange.monitor, status, check, statusChange, decision };
 	};
 
 	private decide = (statusChange: StatusChangeResult): MonitorActionDecision => {
-		const { monitor, statusChanged, prevStatus, thresholdBreaches } = statusChange;
-		if (!statusChanged) return { transition: null };
+		const { monitor, statusChanged, prevStatus } = statusChange;
+		const decision: MonitorActionDecision = {
+			shouldCreateIncident: false,
+			shouldResolveIncident: false,
+			shouldSendNotification: false,
+			incidentReason: null,
+			notificationReason: null,
+		};
+		if (!statusChanged) return decision;
 
-		if (monitor.status === "down") return { transition: "status_down" };
-
-		if (monitor.status === "breached") {
-			return thresholdBreaches
-				? // Hardware
-					{ transition: "threshold_breach", thresholdBreaches }
-				: // Docker
-					{ transition: "threshold_breach" };
+		if (monitor.status === "down") {
+			decision.shouldCreateIncident = true;
+			decision.shouldSendNotification = true;
+			decision.incidentReason = "status_down";
+			decision.notificationReason = "status_change";
+		} else if (monitor.status === "breached") {
+			decision.shouldCreateIncident = true;
+			decision.shouldSendNotification = true;
+			decision.incidentReason = "threshold_breach";
+			decision.notificationReason = "threshold_breach";
+		} else if (monitor.status === "up" && (prevStatus === "down" || prevStatus === "breached")) {
+			decision.shouldResolveIncident = true;
+			decision.shouldSendNotification = true;
+			decision.notificationReason = "status_change";
 		}
-
-		if (monitor.status === "up" && prevStatus === "breached") return { transition: "threshold_resolved" };
-		if (monitor.status === "up" && prevStatus === "down") return { transition: "status_up" };
-		return { transition: null };
+		return decision;
 	};
 }

server/test/helpers/heartbeatTestHarness.ts

@@ -5,17 +5,17 @@ import { IncidentReactor } from "../../src/worker/reactors/reactor.incident.ts";
 import { ReactorDispatcher } from "../../src/worker/reactors/reactor.dispatcher.ts";
 import { StatusService } from "../../src/service/statusService.ts";
 import { IncidentService } from "../../src/domain/incidents/incident.service.ts";
-import { CheckService } from "../../src/domain/checks/check.service.ts";
 import { InMemoryMonitorsRepository } from "./InMemoryMonitorsRepository.ts";
 import { InMemoryIncidentsRepository } from "./InMemoryIncidentsRepository.ts";
 import { createMockLogger } from "./createMockLogger.ts";
 import type { Monitor } from "../../src/domain/monitors/monitor.type.ts";
-import type { Check } from "../../src/domain/checks/check.type.ts";
-import type { MonitorActionDecision } from "../../src/worker/worker.interface.ts";
 import type { MonitorStatusResponse } from "../../src/types/network.ts";
+import type { Check } from "../../src/domain/checks/check.type.ts";
 import type { MaintenanceWindow } from "../../src/domain/maintenance-windows/maintenance-window.type.ts";
 import type { EgressStatus } from "../../src/domain/egress/egress.type.ts";
 
+let checkCounter = 0;
+
 export const makeMonitor = (overrides?: Partial<Monitor>): Monitor =>
 	({
 		id: "mon-1",
@@ -45,6 +45,20 @@ export const makeStatusResponse = (status: boolean, code: number): MonitorStatus
 	responseTime: status ? 150 : 0,
 });
 
+export const makeCheck = (status: boolean, code: number): Check => {
+	const now = new Date().toISOString();
+	return {
+		id: `check-${++checkCounter}`,
+		metadata: { monitorId: "mon-1", teamId: "team-1", type: "http" },
+		status,
+		statusCode: code,
+		responseTime: status ? 150 : 0,
+		message: status ? "OK" : "Service Unavailable",
+		createdAt: now,
+		updatedAt: now,
+	};
+};
+
 const createStubMonitorStatsRepo = () => ({
 	findByMonitorId: jest.fn().mockRejectedValue(new Error("no stats")),
 	create: jest.fn().mockResolvedValue({}),
@@ -60,10 +74,10 @@ export interface HeartbeatTestHarness {
 	statusService: StatusService;
 	incidentService: IncidentService;
 	notificationsService: { handleNotifications: jest.Mock };
-	providerRegistry: { probe: jest.Mock };
+	networkService: { requestStatus: jest.Mock };
 	bufferStub: { addToBuffer: jest.Mock; addGeoCheckToBuffer: jest.Mock; scheduleNextFlush: jest.Mock };
 	maintenanceWindowsRepo: { findByMonitorId: jest.Mock };
-	messageBuilder: { buildThresholdBreachMessage: jest.Mock };
+	messageBuilder: { extractThresholdBreaches: jest.Mock };
 	egressService: { assessAfterFailure: jest.Mock };
 	heartbeatJob: (monitor: Monitor) => Promise<void>;
 	setNextResponse: (status: boolean, code: number) => void;
@@ -72,6 +86,8 @@ export interface HeartbeatTestHarness {
 }
 
 export function createHeartbeatTestHarness(): HeartbeatTestHarness {
+	checkCounter = 0;
+
 	const monitorsRepo = new InMemoryMonitorsRepository();
 	const incidentsRepo = new InMemoryIncidentsRepository();
 	const logger = createMockLogger() as any;
@@ -79,7 +95,7 @@ export function createHeartbeatTestHarness(): HeartbeatTestHarness {
 
 	const statusService = new StatusService(logger, monitorsRepo as any, createStubMonitorStatsRepo() as any);
 
-	const messageBuilder = { buildThresholdBreachMessage: jest.fn().mockReturnValue("") };
+	const messageBuilder = { extractThresholdBreaches: jest.fn().mockReturnValue([]) };
 	const incidentService = new IncidentService(logger, incidentsRepo, monitorsRepo as any, { findById: jest.fn() } as any, messageBuilder as any);
 
 	const notificationsService = { handleNotifications: jest.fn().mockResolvedValue(true) };
@@ -87,17 +103,19 @@ export function createHeartbeatTestHarness(): HeartbeatTestHarness {
 	let nextResponse: MonitorStatusResponse | null = null;
 	let nextStatus = true;
 	let nextCode = 200;
-	const providerRegistry = {
-		probe: jest.fn().mockImplementation(() => {
+	const networkService = {
+		requestStatus: jest.fn().mockImplementation(() => {
 			if (nextResponse) {
 				return Promise.resolve(nextResponse);
 			}
 			return Promise.resolve(makeStatusResponse(nextStatus, nextCode));
 		}),
 	};
-	// The real mapper, so the stored check carries the hardware/docker payload the evaluator reads.
-	// Only toCheck is reached; the repositories are never touched.
-	const checkService = new CheckService(monitorsRepo as any, logger, {} as any);
+	const checkService = {
+		toCheck: jest.fn().mockImplementation((response: MonitorStatusResponse) => {
+			return makeCheck(response.status, response.code);
+		}),
+	};
 
 	const setNextResponse = (status: boolean, code: number) => {
 		nextResponse = null;
@@ -119,13 +137,7 @@ export function createHeartbeatTestHarness(): HeartbeatTestHarness {
 		nextEgressStatus = status;
 	};
 
-	// The real NotificationsService ignores decisions with no transition; the stub is reached only for the ones it
-	// would act on, so tests can assert on handleNotifications calls as "notifications sent".
-	const guardedNotificationsService = {
-		handleNotifications: (monitor: Monitor, check: Check, decision: MonitorActionDecision) =>
-			decision.transition !== null ? notificationsService.handleNotifications(monitor, check, decision) : Promise.resolve(false),
-	};
-	const notificationReactor = new NotificationReactor(guardedNotificationsService as any);
+	const notificationReactor = new NotificationReactor(notificationsService as any);
 	const incidentReactor = new IncidentReactor(incidentService as any);
 	const reactorDispatcher = new ReactorDispatcher(logger, [notificationReactor, incidentReactor]);
 
@@ -137,7 +149,7 @@ export function createHeartbeatTestHarness(): HeartbeatTestHarness {
 		checksRepository: { findUnevaluatedByMonitorId: jest.fn() } as any,
 		jobsRepository: { upsertEvaluate: jest.fn(), pullEvaluated: jest.fn() } as any,
 		checkService: checkService as any,
-		providerRegistry: providerRegistry as any,
+		networkService: networkService as any,
 		proxyResolver: proxyResolver as any,
 		bufferService: bufferStub as any,
 		dockerLogsService: dockerLogsService as any,
@@ -153,7 +165,7 @@ export function createHeartbeatTestHarness(): HeartbeatTestHarness {
 		if (!monitor) return;
 		const result = await pipeline.produce(monitor);
 		if (!result) return; // skipped (e.g. maintenance window)
-		const evaluation = await pipeline.evaluateCheck(result.check, monitor);
+		const evaluation = await pipeline.evaluateCheck(result.status, result.check, monitor);
 		await reactorDispatcher.dispatch(evaluation);
 	};
 
@@ -163,7 +175,7 @@ export function createHeartbeatTestHarness(): HeartbeatTestHarness {
 		statusService,
 		incidentService,
 		notificationsService,
-		providerRegistry,
+		networkService,
 		bufferStub,
 		maintenanceWindowsRepo,
 		messageBuilder,

server/test/helpers/notificationMessage.ts

@@ -21,7 +21,7 @@ export const makeMessage = (overrides?: Partial<NotificationMessage>): Notificat
 		timestamp: new Date("2025-01-01T00:00:00Z"),
 	},
 	clientHost: "https://app.example.com",
-	metadata: { teamId: "team-1" },
+	metadata: { teamId: "team-1", notificationReason: "status_change" },
 	...overrides,
 });
 

server/test/helpers/notificationProviderContract.ts

@@ -14,7 +14,7 @@ const makeMessage = (): NotificationMessage => ({
 		timestamp: new Date("2025-01-01T00:00:00Z"),
 	},
 	clientHost: "https://app.example.com",
-	metadata: { teamId: "team-1" },
+	metadata: { teamId: "team-1", notificationReason: "status_change" },
 });
 
 export const testNotificationProviderContract = (

server/test/helpers/statusProviderContract.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "@jest/globals";
-import type { IStatusProvider } from "../../src/service/networkProviders/IStatusProvider.ts";
+import type { IStatusProvider } from "../../src/service/network/IStatusProvider.ts";
 import type { Monitor } from "../../src/domain/monitors/monitor.type.ts";
 
 /**

server/test/integration/evaluateCursorMultiWorker.test.ts

@@ -126,14 +126,14 @@ describe("Evaluate cursor with more than one processing worker", () => {
 			checksRepository,
 			jobsRepository,
 			checkService,
-			providerRegistry: { probe: jest.fn<any>() } as any,
+			networkService: { requestStatus: jest.fn<any>() } as any,
 			proxyResolver: { resolve: jest.fn<any>() } as any,
 			bufferService,
 			dockerLogsService: { buildDockerLogs: jest.fn<any>() } as any,
 			statusService: {
-				updateMonitorStatus: async (check: Check, monitor: Monitor) => {
+				updateMonitorStatus: async (_status: MonitorStatusResponse, check: Check, monitor: Monitor) => {
 					evaluatedCheckIds.push(check.id);
-					return { monitor, statusChanged: false, prevStatus: monitor.status };
+					return { monitor, statusChanged: false, prevStatus: monitor.status, code: 200, timestamp: 0 };
 				},
 			} as any,
 			dispatcher: { dispatch: jest.fn<any>().mockResolvedValue(undefined) } as any,

server/test/integration/heartbeatJobMaintenance.test.ts

@@ -44,7 +44,7 @@ describe("Heartbeat job: maintenance windows", () => {
 		expect(storedMonitor.status).toBe("maintenance");
 
 		// No network request should have been made
-		expect(h.providerRegistry.probe).not.toHaveBeenCalled();
+		expect(h.networkService.requestStatus).not.toHaveBeenCalled();
 
 		// No check should have been buffered
 		expect(h.bufferStub.addToBuffer).not.toHaveBeenCalled();
@@ -68,7 +68,7 @@ describe("Heartbeat job: maintenance windows", () => {
 		// since status was already "maintenance"
 		const storedMonitor = await h.monitorsRepo.findById("mon-1", "team-1");
 		expect(storedMonitor.status).toBe("maintenance");
-		expect(h.providerRegistry.probe).not.toHaveBeenCalled();
+		expect(h.networkService.requestStatus).not.toHaveBeenCalled();
 	});
 
 	it("resumes normal checks when maintenance window expires", async () => {
@@ -88,7 +88,7 @@ describe("Heartbeat job: maintenance windows", () => {
 		await h.heartbeatJob(monitor);
 
 		// Network request should have been made this time
-		expect(h.providerRegistry.probe).toHaveBeenCalledTimes(1);
+		expect(h.networkService.requestStatus).toHaveBeenCalledTimes(1);
 
 		// Check should have been buffered
 		expect(h.bufferStub.addToBuffer).toHaveBeenCalledTimes(1);
@@ -105,7 +105,7 @@ describe("Heartbeat job: maintenance windows", () => {
 		await h.heartbeatJob(monitor);
 
 		// Normal check should proceed since window is inactive
-		expect(h.providerRegistry.probe).toHaveBeenCalledTimes(1);
+		expect(h.networkService.requestStatus).toHaveBeenCalledTimes(1);
 		expect(h.bufferStub.addToBuffer).toHaveBeenCalledTimes(1);
 	});
 
@@ -123,7 +123,7 @@ describe("Heartbeat job: maintenance windows", () => {
 
 		expect((await h.monitorsRepo.findById("mon-a", "team-1")).status).toBe("maintenance");
 		expect((await h.monitorsRepo.findById("mon-b", "team-1")).status).toBe("maintenance");
-		expect(h.providerRegistry.probe).not.toHaveBeenCalled();
+		expect(h.networkService.requestStatus).not.toHaveBeenCalled();
 	});
 
 	it("skips checks when window is in the past (expired)", async () => {
@@ -141,6 +141,6 @@ describe("Heartbeat job: maintenance windows", () => {
 		await h.heartbeatJob(monitor);
 
 		// Window is in the past — normal check should proceed
-		expect(h.providerRegistry.probe).toHaveBeenCalledTimes(1);
+		expect(h.networkService.requestStatus).toHaveBeenCalledTimes(1);
 	});
 });

server/test/integration/heartbeatJobThresholdBreach.test.ts

@@ -49,7 +49,7 @@ describe("Heartbeat job: hardware threshold breach", () => {
 		h.setNextResponseFull(makeHardwareResponse(0.9));
 
 		// Configure message builder for when incident is created
-		h.messageBuilder.buildThresholdBreachMessage.mockReturnValue("CPU: 90% (threshold: 80%)");
+		h.messageBuilder.extractThresholdBreaches.mockReturnValue([{ metric: "cpu", formattedValue: "90%", threshold: 80, unit: "%" }]);
 
 		// 4 heartbeats: counter goes 5→4→3→2→1, status still "up"
 		for (let i = 0; i < 4; i++) {
@@ -191,7 +191,7 @@ describe("Heartbeat job: hardware threshold breach", () => {
 		h.monitorsRepo.seed(monitor);
 
 		h.setNextResponseFull(makeHardwareResponse(0.9));
-		h.messageBuilder.buildThresholdBreachMessage.mockReturnValue("CPU: 90% (threshold: 80%)");
+		h.messageBuilder.extractThresholdBreaches.mockReturnValue([{ metric: "cpu", formattedValue: "90%", threshold: 80, unit: "%" }]);
 
 		// 5 heartbeats to trigger breach, then 5 more while still breaching
 		for (let i = 0; i < 10; i++) {

server/test/integration/incidentLifecycle.test.ts

@@ -7,7 +7,6 @@ import type { IUsersRepository } from "../../src/domain/users/user.repository.in
 import type { INotificationMessageBuilder } from "../../src/domain/notifications/notification.message-builder.ts";
 import type { Monitor } from "../../src/domain/monitors/monitor.type.ts";
 import type { MonitorActionDecision } from "../../src/worker/worker.interface.ts";
-import type { Check } from "../../src/domain/checks/check.type.ts";
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -23,21 +22,14 @@ const makeMonitor = (overrides?: Partial<Monitor>): Monitor =>
 	}) as Monitor;
 
 const makeDecision = (overrides?: Partial<MonitorActionDecision>): MonitorActionDecision => ({
-	transition: null,
+	shouldCreateIncident: false,
+	shouldResolveIncident: false,
+	shouldSendNotification: false,
+	incidentReason: null,
+	notificationReason: null,
 	...overrides,
 });
 
-const makeCheck = (statusCode: number): Check => ({
-	id: "check-1",
-	metadata: { monitorId: "mon-1", teamId: "team-1", type: "http" },
-	status: statusCode < 400,
-	statusCode,
-	responseTime: 100,
-	message: statusCode < 400 ? "OK" : "Service Unavailable",
-	createdAt: "2026-01-01T00:00:00Z",
-	updatedAt: "2026-01-01T00:00:00Z",
-});
-
 // ── Test suite ───────────────────────────────────────────────────────────────
 
 describe("Incident lifecycle (integration)", () => {
@@ -51,7 +43,7 @@ describe("Incident lifecycle (integration)", () => {
 		repo = new InMemoryIncidentsRepository();
 		monitorsRepo = { findById: jest.fn() } as unknown as jest.Mocked<IMonitorsRepository>;
 		usersRepo = { findById: jest.fn() } as unknown as jest.Mocked<IUsersRepository>;
-		messageBuilder = { buildThresholdBreachMessage: jest.fn() } as unknown as jest.Mocked<INotificationMessageBuilder>;
+		messageBuilder = { extractThresholdBreaches: jest.fn() } as unknown as jest.Mocked<INotificationMessageBuilder>;
 		service = new IncidentService(createMockLogger() as any, repo, monitorsRepo, usersRepo, messageBuilder);
 	});
 
@@ -59,9 +51,9 @@ describe("Incident lifecycle (integration)", () => {
 
 	it("creates an incident when monitor goes down", async () => {
 		const monitor = makeMonitor({ status: "down" });
-		const decision = makeDecision({ transition: "status_down" });
+		const decision = makeDecision({ shouldCreateIncident: true, incidentReason: "status_down" });
 
-		const incident = await service.handleIncident(monitor, decision, makeCheck(503));
+		const incident = await service.handleIncident(monitor, 503, decision);
 
 		expect(incident).not.toBeNull();
 		expect(incident!.monitorId).toBe("mon-1");
@@ -80,10 +72,10 @@ describe("Incident lifecycle (integration)", () => {
 
 	it("does not create a duplicate incident for the same monitor", async () => {
 		const monitor = makeMonitor({ status: "down" });
-		const decision = makeDecision({ transition: "status_down" });
+		const decision = makeDecision({ shouldCreateIncident: true, incidentReason: "status_down" });
 
-		const first = await service.handleIncident(monitor, decision, makeCheck(503));
-		const second = await service.handleIncident(monitor, decision, makeCheck(503));
+		const first = await service.handleIncident(monitor, 503, decision);
+		const second = await service.handleIncident(monitor, 503, decision);
 
 		expect(second!.id).toBe(first!.id);
 		expect(repo.getAll()).toHaveLength(1);
@@ -93,11 +85,11 @@ describe("Incident lifecycle (integration)", () => {
 
 	it("auto-resolves an incident when monitor recovers", async () => {
 		const monitor = makeMonitor({ status: "down" });
-		const createDecision = makeDecision({ transition: "status_down" });
-		const created = await service.handleIncident(monitor, createDecision, makeCheck(503));
+		const createDecision = makeDecision({ shouldCreateIncident: true, incidentReason: "status_down" });
+		const created = await service.handleIncident(monitor, 503, createDecision);
 
-		const resolveDecision = makeDecision({ transition: "status_up" });
-		const resolved = await service.handleIncident(monitor, resolveDecision, makeCheck(200));
+		const resolveDecision = makeDecision({ shouldResolveIncident: true });
+		const resolved = await service.handleIncident(monitor, 200, resolveDecision);
 
 		expect(resolved).not.toBeNull();
 		expect(resolved!.id).toBe(created!.id);
@@ -110,9 +102,9 @@ describe("Incident lifecycle (integration)", () => {
 
 	it("returns null when resolving with no active incident", async () => {
 		const monitor = makeMonitor({ status: "up" });
-		const decision = makeDecision({ transition: "status_up" });
+		const decision = makeDecision({ shouldResolveIncident: true });
 
-		const result = await service.handleIncident(monitor, decision, makeCheck(200));
+		const result = await service.handleIncident(monitor, 200, decision);
 
 		expect(result).toBeNull();
 	});
@@ -121,8 +113,8 @@ describe("Incident lifecycle (integration)", () => {
 
 	it("manually resolves an active incident with comment", async () => {
 		const monitor = makeMonitor({ status: "down" });
-		const decision = makeDecision({ transition: "status_down" });
-		const created = await service.handleIncident(monitor, decision, makeCheck(500));
+		const decision = makeDecision({ shouldCreateIncident: true, incidentReason: "status_down" });
+		const created = await service.handleIncident(monitor, 500, decision);
 
 		const resolved = await service.resolveIncident(created!.id, "user-1", "team-1", "Root cause identified", "user@test.com");
 
@@ -136,8 +128,8 @@ describe("Incident lifecycle (integration)", () => {
 
 	it("throws when manually resolving an already-resolved incident", async () => {
 		const monitor = makeMonitor({ status: "down" });
-		const decision = makeDecision({ transition: "status_down" });
-		const created = await service.handleIncident(monitor, decision, makeCheck(500));
+		const decision = makeDecision({ shouldCreateIncident: true, incidentReason: "status_down" });
+		const created = await service.handleIncident(monitor, 500, decision);
 
 		await service.resolveIncident(created!.id, "user-1", "team-1");
 
@@ -148,10 +140,13 @@ describe("Incident lifecycle (integration)", () => {
 
 	it("creates a threshold breach incident with statusCode 9999 and descriptive message", async () => {
 		const monitor = makeMonitor({ status: "breached", type: "hardware" });
-		(messageBuilder.buildThresholdBreachMessage as jest.Mock).mockReturnValue("CPU: 92% (threshold: 80%), MEMORY: 88% (threshold: 85%)");
-		const decision = makeDecision({ transition: "threshold_breach" });
+		(messageBuilder.extractThresholdBreaches as jest.Mock).mockReturnValue([
+			{ metric: "cpu", formattedValue: "92%", threshold: 80, unit: "%" },
+			{ metric: "memory", formattedValue: "88%", threshold: 85, unit: "%" },
+		]);
+		const decision = makeDecision({ shouldCreateIncident: true, incidentReason: "threshold_breach" });
 
-		const incident = await service.handleIncident(monitor, decision, makeCheck(200));
+		const incident = await service.handleIncident(monitor, 200, decision, { monitorId: "mon-1" } as any);
 
 		expect(incident!.statusCode).toBe(9999);
 		expect(incident!.message).toBe("CPU: 92% (threshold: 80%), MEMORY: 88% (threshold: 85%)");
@@ -163,7 +158,7 @@ describe("Incident lifecycle (integration)", () => {
 		const monitor = makeMonitor({ status: "up" });
 		const decision = makeDecision();
 
-		const result = await service.handleIncident(monitor, decision, makeCheck(200));
+		const result = await service.handleIncident(monitor, 200, decision);
 
 		expect(result).toBeNull();
 		expect(repo.getAll()).toHaveLength(0);
@@ -175,19 +170,19 @@ describe("Incident lifecycle (integration)", () => {
 		const monitor = makeMonitor({ status: "down" });
 
 		// First outage
-		const first = await service.handleIncident(monitor, makeDecision({ transition: "status_down" }), makeCheck(503));
+		const first = await service.handleIncident(monitor, 503, makeDecision({ shouldCreateIncident: true, incidentReason: "status_down" }));
 		expect(first!.status).toBe(true);
 
 		// Manually resolved
 		await service.resolveIncident(first!.id, "user-1", "team-1", "Restarted server");
 
 		// Second outage — new incident since previous was resolved
-		const second = await service.handleIncident(monitor, makeDecision({ transition: "status_down" }), makeCheck(502));
+		const second = await service.handleIncident(monitor, 502, makeDecision({ shouldCreateIncident: true, incidentReason: "status_down" }));
 		expect(second!.id).not.toBe(first!.id);
 		expect(second!.statusCode).toBe(502);
 
 		// Auto-resolve
-		const resolved = await service.handleIncident(monitor, makeDecision({ transition: "status_up" }), makeCheck(200));
+		const resolved = await service.handleIncident(monitor, 200, makeDecision({ shouldResolveIncident: true }));
 		expect(resolved!.id).toBe(second!.id);
 		expect(resolved!.status).toBe(false);
 		expect(resolved!.resolutionType).toBe("automatic");
@@ -203,16 +198,16 @@ describe("Incident lifecycle (integration)", () => {
 	it("incidents for different monitors do not interfere", async () => {
 		const monitorA = makeMonitor({ id: "mon-a", status: "down" });
 		const monitorB = makeMonitor({ id: "mon-b", status: "down" });
-		const decision = makeDecision({ transition: "status_down" });
+		const decision = makeDecision({ shouldCreateIncident: true, incidentReason: "status_down" });
 
-		const incidentA = await service.handleIncident(monitorA, decision, makeCheck(500));
-		const incidentB = await service.handleIncident(monitorB, decision, makeCheck(502));
+		const incidentA = await service.handleIncident(monitorA, 500, decision);
+		const incidentB = await service.handleIncident(monitorB, 502, decision);
 
 		expect(incidentA!.id).not.toBe(incidentB!.id);
 		expect(repo.getAll()).toHaveLength(2);
 
 		// Resolving monitor A does not affect monitor B
-		const resolved = await service.handleIncident(monitorA, makeDecision({ transition: "status_up" }), makeCheck(200));
+		const resolved = await service.handleIncident(monitorA, 200, makeDecision({ shouldResolveIncident: true }));
 		expect(resolved!.id).toBe(incidentA!.id);
 
 		const bStillActive = await repo.findActiveByMonitorId("mon-b", "team-1");

server/test/integration/monitorRepository.test.ts

@@ -69,34 +69,6 @@ describe("MongoMonitorsRepository", () => {
 		});
 	});
 
-	describe("sorting", () => {
-		it("uses creation time as the fallback for equal primary values", async () => {
-			const repo = new MongoMonitorsRepository();
-			const teamId = new mongoose.Types.ObjectId();
-			const createMonitor = (name: string, type: string, status: string, createdAt: Date) =>
-				MonitorModel.create({
-					userId: new mongoose.Types.ObjectId(),
-					teamId,
-					name,
-					type,
-					status,
-					url: "https://example.com",
-					createdAt,
-				});
-
-			await createMonitor("newer-up", "hardware", "up", new Date("2026-03-01T00:00:00.000Z"));
-			await createMonitor("down", "http", "down", new Date("2026-04-01T00:00:00.000Z"));
-			await createMonitor("older-up", "pagespeed", "up", new Date("2026-01-01T00:00:00.000Z"));
-			await createMonitor("middle-up", "docker", "up", new Date("2026-02-01T00:00:00.000Z"));
-
-			const ascending = await repo.findByTeamIdWithStats(teamId.toString(), { field: "status", order: "asc" });
-			const descending = await repo.findByTeamIdWithStats(teamId.toString(), { field: "status", order: "desc" });
-
-			expect(ascending.map((monitor) => monitor.name)).toEqual(["down", "older-up", "middle-up", "newer-up"]);
-			expect(descending.map((monitor) => monitor.name)).toEqual(["older-up", "middle-up", "newer-up", "down"]);
-		});
-	});
-
 	describe("findByIds recentChecks modes", () => {
 		const seedFixtures = async () => {
 			const teamId = new mongoose.Types.ObjectId();

server/test/unit/middleware/sanitization.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it, jest } from "@jest/globals";
-import type { NextFunction, Request, Response } from "express";
-import { sanitizeBody, sanitizeInput, sanitizeObject, sanitizeQuery } from "../../../src/api/middleware/sanitization.ts";
-
-// Express 5 exposes req.query as a getter on the request prototype that re-parses the URL on
-// every read, so writes into the returned object are lost. The middleware must shadow the
-// getter with an own property, which is what this fixture checks.
-const makeExpress5Request = (query: Record<string, unknown>) => {
-	const proto = {};
-	Object.defineProperty(proto, "query", {
-		get: () => ({ ...query }),
-		configurable: true,
-		enumerable: true,
-	});
-	return Object.create(proto) as Request;
-};
-
-describe("sanitizeInput", () => {
-	it("strips html tags and keeps the text content", () => {
-		expect(sanitizeInput('<script>alert("x")</script>hello <b>bold</b>')).toBe("hello bold");
-	});
-
-	it("returns non-string values unchanged", () => {
-		expect(sanitizeInput(42)).toBe(42);
-		expect(sanitizeInput(null)).toBeNull();
-		expect(sanitizeInput(undefined)).toBeUndefined();
-	});
-});
-
-describe("sanitizeObject", () => {
-	it("sanitizes nested strings and arrays, leaving other values untouched", () => {
-		const result = sanitizeObject({
-			name: "<img src=x onerror=alert(1)>Alice",
-			count: 3,
-			active: true,
-			items: [{ note: "<i>one</i>" }, { note: "two" }],
-			nested: { note: "<p>hi</p>" },
-		});
-
-		expect(result).toEqual({
-			name: "Alice",
-			count: 3,
-			active: true,
-			items: [{ note: "one" }, { note: "two" }],
-			nested: { note: "hi" },
-		});
-	});
-
-	it("returns primitives and null unchanged", () => {
-		expect(sanitizeObject("<b>x</b>")).toBe("<b>x</b>");
-		expect(sanitizeObject(null)).toBeNull();
-	});
-});
-
-describe("sanitizeBody middleware", () => {
-	it("replaces req.body with a sanitized copy and calls next", () => {
-		const req = { body: { name: "<b>Alice</b>", nested: { note: "<i>x</i>" } } } as unknown as Request;
-		const next = jest.fn() as unknown as NextFunction;
-
-		sanitizeBody()(req, {} as Response, next);
-
-		expect(req.body).toEqual({ name: "Alice", nested: { note: "x" } });
-		expect(next).toHaveBeenCalledWith();
-	});
-
-	it("leaves req.body alone when there is no body", () => {
-		const req = {} as unknown as Request;
-		const next = jest.fn() as unknown as NextFunction;
-
-		sanitizeBody()(req, {} as Response, next);
-
-		expect(req.body).toBeUndefined();
-		expect(next).toHaveBeenCalledWith();
-	});
-});
-
-describe("sanitizeQuery middleware", () => {
-	it("sanitizes string values so that later reads of req.query see them", () => {
-		const req = makeExpress5Request({ filter: "<script>x</script>term", page: "2" });
-		const next = jest.fn() as unknown as NextFunction;
-
-		sanitizeQuery()(req, {} as Response, next);
-
-		expect(req.query).toEqual({ filter: "term", page: "2" });
-		expect(req.query).toEqual({ filter: "term", page: "2" }); // stable across reads
-		expect(next).toHaveBeenCalledWith();
-	});
-
-	it("does not sanitize inside array values", () => {
-		const req = makeExpress5Request({ type: ["<b>http</b>", "ping"] });
-		const next = jest.fn() as unknown as NextFunction;
-
-		sanitizeQuery()(req, {} as Response, next);
-
-		expect(req.query).toEqual({ type: ["<b>http</b>", "ping"] });
-	});
-
-	it("handles an empty query", () => {
-		const req = makeExpress5Request({});
-		const next = jest.fn() as unknown as NextFunction;
-
-		sanitizeQuery()(req, {} as Response, next);
-
-		expect(req.query).toEqual({});
-		expect(next).toHaveBeenCalledWith();
-	});
-});

server/test/unit/providers/network/advancedMatcher.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, jest } from "@jest/globals";
-import { AdvancedMatcher } from "../../../../src/service/networkProviders/AdvancedMatcher.ts";
+import { AdvancedMatcher } from "../../../../src/service/network/AdvancedMatcher.ts";
 import type { Monitor } from "../../../../src/domain/monitors/monitor.type.ts";
 
 // ── Helpers ──────────────────────────────────────────────────────────────────