Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
import { useRelativeTimeNow } from '@/utils/relativeTimeClock';
import { Show, createEffect, createMemo, createSignal, onMount, type Component } from 'solid-js';
import type { Resource } from '@/types/resource';
import { isAgentlessAvailabilityResource } from '@/features/standalone/standalonePageModel';
import { useLocation, useNavigate } from '@solidjs/router';
import Plus from 'lucide-solid/icons/plus';
import RotateCw from 'lucide-solid/icons/rotate-cw';
import Activity from 'lucide-solid/icons/activity';
import X from 'lucide-solid/icons/x';
import { Button } from '@/components/shared/Button';
import { EmptyState } from '@/components/shared/EmptyState';
import SettingsPanel from '@/components/shared/SettingsPanel';
import { Dialog } from '@/components/shared/Dialog';
import { MetadataBadge } from '@/components/shared/MetadataBadge';
import { PlatformWindowedList } from '@/features/platformPage/PlatformWindowedList';
import { useResources } from '@/hooks/useResources';
import { buildProbeAgentOptions } from '@/utils/availabilityProbeAgents';
import {
AvailabilityTargetsAPI,
type AvailabilityTarget,
type AvailabilityTargetKind,
} from '@/api/availabilityTargets';
import { AvailabilityTargetSlot } from './ConnectionEditor/CredentialSlots/AvailabilityTargetSlot';
import {
buildAvailabilitySettingsPath,
buildAvailabilityTargetAddPath,
getAvailabilityTargetAddKind,
getAvailabilityTargetAddressLabel,
getAvailabilityTargetKindLabel,
getAvailabilityTargetMethodLabel,
getAvailabilityTargetProbeSourceLabel,
getAvailabilityTargetStatusClass,
getAvailabilityTargetStatusLabel,
getAvailabilityTargetStatusTitle,
getAvailabilityTargetsSummary,
shouldOpenAvailabilityTargetAddDialog,
} from './availabilitySettingsModel';
type AvailabilityDialogState =
| { mode: 'add'; initialTargetKind?: AvailabilityTargetKind }
| { mode: 'edit'; target: AvailabilityTarget }
| null;
const sortTargets = (targets: readonly AvailabilityTarget[]): AvailabilityTarget[] =>
[...targets].sort((left, right) => left.name.localeCompare(right.name));
export const AvailabilitySettingsPanel: Component = () => {
const now = useRelativeTimeNow();
const location = useLocation();
const navigate = useNavigate();
const { resources } = useResources();
const probeAgentOptions = createMemo(() => buildProbeAgentOptions(resources()));
// The Machines availability tab reads these same resources, so the counts and
// colours here come from the same status logic when they are loaded.
const availabilityResourceByTargetId = createMemo(() => {
const byId = new Map<string, Resource>();
for (const resource of resources()) {
if (!isAgentlessAvailabilityResource(resource)) continue;
const targetId = resource.availability?.targetId;
if (targetId) byId.set(targetId, resource);
}
return byId;
});
const resourceForTarget = (target: AvailabilityTarget) =>
availabilityResourceByTargetId().get(target.id);
const [targets, setTargets] = createSignal<AvailabilityTarget[]>([]);
const [loading, setLoading] = createSignal(false);
const [error, setError] = createSignal<string | null>(null);
const [dialog, setDialog] = createSignal<AvailabilityDialogState>(null);
const [pendingActionId, setPendingActionId] = createSignal<string | null>(null);
const [deleteConfirmingId, setDeleteConfirmingId] = createSignal<string | null>(null);
const sortedTargets = createMemo(() => sortTargets(targets()));
const loadTargets = async () => {
setLoading(true);
setError(null);
try {
setTargets(await AvailabilityTargetsAPI.list());
} catch (err) {
setError(err instanceof Error ? err.message : 'Failed to load availability checks.');
} finally {
setLoading(false);
}
};
const openAddDialog = (targetKind: AvailabilityTargetKind = 'service') => {
setDeleteConfirmingId(null);
navigate(buildAvailabilityTargetAddPath(targetKind), { scroll: false });
};
const closeDialog = (replace = false) => {
setDialog(null);
setDeleteConfirmingId(null);
if (location.pathname === buildAvailabilitySettingsPath() && location.search) {
navigate(buildAvailabilitySettingsPath(), { replace, scroll: false });
}
};
const handleSaved = () => {
void loadTargets();
closeDialog(true);
};
const toggleTarget = async (target: AvailabilityTarget) => {
setPendingActionId(target.id);
setError(null);
try {
await AvailabilityTargetsAPI.update(target.id, { enabled: !target.enabled });
await loadTargets();
const currentDialog = dialog();
if (currentDialog?.mode === 'edit' && currentDialog.target.id === target.id) {
const updated = targets().find((item) => item.id === target.id);
if (updated) setDialog({ mode: 'edit', target: updated });
}
} catch (err) {
setError(err instanceof Error ? err.message : 'Failed to update availability check.');
} finally {
setPendingActionId(null);
}
};
const testTarget = async (target: AvailabilityTarget) => {
setPendingActionId(target.id);
setError(null);
try {
await AvailabilityTargetsAPI.testSaved(target.id);
await loadTargets();
} catch (err) {
setError(err instanceof Error ? err.message : 'Availability test failed.');
} finally {
setPendingActionId(null);
}
};
const requestRemoveTarget = async (target: AvailabilityTarget) => {
if (deleteConfirmingId() !== target.id) {
setDeleteConfirmingId(target.id);
return;
}
setPendingActionId(target.id);
setError(null);
try {
await AvailabilityTargetsAPI.remove(target.id);
await loadTargets();
closeDialog(true);
} catch (err) {
setError(err instanceof Error ? err.message : 'Failed to remove availability check.');
} finally {
setPendingActionId(null);
}
};
createEffect(() => {
if (shouldOpenAvailabilityTargetAddDialog(location.pathname, location.search)) {
setDialog({
mode: 'add',
initialTargetKind: getAvailabilityTargetAddKind(location.pathname, location.search),
});
return;
}
const current = dialog();
if (current?.mode === 'add') {
setDialog(null);
}
});
onMount(() => {
void loadTargets();
});
const dialogTitle = createMemo(() => {
const current = dialog();
if (current?.mode === 'edit') return `Manage ${current.target.name}`;
if (current?.mode === 'add' && current.initialTargetKind === 'machine') {
return 'Add machine check';
}
if (
current?.mode === 'add' &&
(current.initialTargetKind === 'service' || current.initialTargetKind === 'device')
) {
return 'Add service/device check';
}
return 'Add availability check';
});
const dialogDescription = createMemo(() => {
const current = dialog();
if (current?.mode === 'edit') {
return `${getAvailabilityTargetMethodLabel(current.target)} · ${getAvailabilityTargetAddressLabel(current.target)}`;
}
if (current?.mode === 'add' && current.initialTargetKind === 'machine') {
return 'Use reachability checks for servers, desktops, laptops, and other computers that do not run Pulse Agent.';
}
return 'Use ICMP ping, TCP port, or HTTP checks for devices and services that cannot run Pulse Agent.';
});
return (
<div class="space-y-6">
<SettingsPanel title="Availability checks" noPadding>
<div class="border-b border-border bg-surface px-4 py-3">
<div class="flex flex-wrap items-center justify-between gap-3">
<div class="min-w-0">
<div class="text-sm font-semibold text-base-content">
{getAvailabilityTargetsSummary(targets(), resourceForTarget, now())}
</div>
<p class="mt-1 text-xs leading-5 text-muted">
Monitor endpoint-only devices and services with ICMP, TCP, and HTTP probes.
</p>
</div>
<div class="flex flex-wrap items-center gap-2">
<Button
type="button"
variant="secondary"
size="mdCompact"
class="min-h-11 gap-2 sm:min-h-9"
onClick={() => void loadTargets()}
disabled={loading()}
>
<RotateCw class={`h-4 w-4 ${loading() ? 'animate-spin' : ''}`} />
Refresh
</Button>
<Button
type="button"
variant="primary"
size="mdCompact"
class="min-h-11 gap-2 sm:min-h-9"
onClick={() => openAddDialog('service')}
>
<Plus class="h-4 w-4" />
Add service/device check
</Button>
</div>
</div>
</div>
<div class="divide-y divide-border">
<Show when={loading() && targets().length === 0}>
<div class="p-4 text-sm text-muted">Loading availability checks...</div>
</Show>
<Show when={error()}>
{(message) => (
<div
role="alert"
class="border-b border-rose-200 bg-rose-50 px-4 py-3 text-sm text-rose-800 dark:border-rose-900/25 dark:bg-rose-950/25 dark:text-rose-200"
>
{message()}
</div>
)}
</Show>
<Show
when={sortedTargets().length > 0}
fallback={
<EmptyState
variant="panel"
icon={<Activity class="h-5 w-5" />}
title="No availability checks yet"
description="Add a ping, TCP port, MQTT broker, ESPHome device, HTTP health check, or another endpoint that only needs reachability monitoring."
actions={
<Button
type="button"
variant="primary"
size="mdCompact"
class="min-h-9! gap-2"
onClick={() => openAddDialog('service')}
>
<Plus class="h-4 w-4" />
Add service/device check
</Button>
}
/>
}
>
<PlatformWindowedList
items={sortedTargets}
estimatedItemHeight={92}
enableThreshold={24}
windowSize={32}
>
{(target) => {
const pending = () => pendingActionId() === target.id;
return (
<div class="grid gap-3 px-4 py-4 md:grid-cols-[minmax(0,1fr)_auto] md:items-center">
<div class="min-w-0 space-y-2">
<div class="flex flex-wrap items-center gap-2">
<div class="truncate text-sm font-semibold text-base-content">
{target.name}
</div>
<span
class={`inline-flex items-center rounded-full px-2 py-0.5 text-[11px] font-medium ${getAvailabilityTargetStatusClass(target, resourceForTarget(target), now())}`}
title={getAvailabilityTargetStatusTitle(
target,
resourceForTarget(target),
now(),
)}
>
{getAvailabilityTargetStatusLabel(
target,
resourceForTarget(target),
now(),
)}
</span>
<Show
when={getAvailabilityTargetProbeSourceLabel(target, probeAgentOptions())}
>
{(sourceLabel) => (
<MetadataBadge
tone="muted"
size="xs"
appearance="outline"
data-availability-probe-source={target.status?.probeAgentId}
>
{sourceLabel()}
</MetadataBadge>
)}
</Show>
</div>
<div class="flex flex-wrap items-center gap-x-3 gap-y-1 text-xs text-muted">
<span>{getAvailabilityTargetKindLabel(target)}</span>
<span aria-hidden="true">·</span>
<span>{getAvailabilityTargetMethodLabel(target)}</span>
<span aria-hidden="true">·</span>
<span class="break-all">{getAvailabilityTargetAddressLabel(target)}</span>
</div>
</div>
<div class="flex flex-wrap items-center gap-2 md:justify-end">
<Button
type="button"
variant="outline"
size="xs"
class="min-h-11 sm:min-h-8"
onClick={() => void testTarget(target)}
disabled={pending()}
>
{pending() ? 'Testing...' : 'Test'}
</Button>
<Button
type="button"
variant="outline"
size="xs"
class="min-h-11 sm:min-h-8"
onClick={() => void toggleTarget(target)}
disabled={pending()}
>
{target.enabled ? 'Pause' : 'Resume'}
</Button>
<Button
type="button"
variant="outline"
size="xs"
class="min-h-11 sm:min-h-8"
onClick={() => {
setDeleteConfirmingId(null);
setDialog({ mode: 'edit', target });
}}
>
Manage
</Button>
</div>
</div>
);
}}
</PlatformWindowedList>
</Show>
</div>
</SettingsPanel>
<Show when={dialog()}>
{(dialogAccessor) => {
const current = dialogAccessor();
const editingTarget = current.mode === 'edit' ? current.target : null;
return (
<Dialog
isOpen={true}
onClose={() => closeDialog(true)}
ariaLabel={dialogTitle()}
panelClass="max-w-4xl"
>
<div class="flex h-full min-h-0 flex-col">
<div class="flex items-start justify-between gap-4 border-b border-border bg-surface-alt px-4 py-4 sm:px-6">
<div class="space-y-1">
<h2 class="text-base font-semibold text-base-content">{dialogTitle()}</h2>
<p class="text-sm text-muted">{dialogDescription()}</p>
</div>
<Button
type="button"
variant="outline"
size="iconMd"
onClick={() => closeDialog(true)}
aria-label="Close availability check dialog"
>
<X class="h-4 w-4" />
</Button>
</div>
<div class="min-h-0 flex-1 overflow-y-auto p-4">
<AvailabilityTargetSlot
editingTargetId={editingTarget?.id}
initialTargetKind={
current.mode === 'add' ? current.initialTargetKind : undefined
}
onCancel={() => closeDialog(true)}
onSaved={handleSaved}
onToggleEnabled={
editingTarget ? () => void toggleTarget(editingTarget) : undefined
}
togglePending={editingTarget ? pendingActionId() === editingTarget.id : false}
connectionEnabled={editingTarget?.enabled}
onDelete={
editingTarget ? () => void requestRemoveTarget(editingTarget) : undefined
}
deletePending={editingTarget ? pendingActionId() === editingTarget.id : false}
deleteConfirming={
editingTarget ? deleteConfirmingId() === editingTarget.id : false
}
deleteError={null}
/>
</div>
</div>
</Dialog>
);
}}
</Show>
</div>
);
};