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 { Accessor, Setter, createSignal } from 'solid-js';
import { SettingsAPI, type TelemetryPreviewResponse } from '@/api/settings';
import { UpdatesAPI } from '@/api/updates';
import type { UpdateInfo, UpdatePlan } from '@/api/updates';
import { notificationStore } from '@/stores/notifications';
import { logger } from '@/utils/logger';
import { updateStore } from '@/stores/updates';
import { copyToClipboard } from '@/utils/clipboard';
import { loadRuntimeBranding, updateDockerUpdateActionsSetting } from '@/stores/systemSettings';
import type { ReportBrandSettings } from '@/types/config';
import {
BACKUP_INTERVAL_OPTIONS,
getCheckForUpdatesErrorMessage,
getBackupIntervalSelectValue,
getBackupIntervalSummary,
getDockerUpdateActionsUpdateErrorMessage,
getGuestDockerInventoryUpdateErrorMessage,
getHideLocalLoginUpdateErrorMessage,
getSystemSettingsSaveErrorMessage,
getTelemetryUpdateErrorMessage,
getTemperatureMonitoringUpdateErrorMessage,
PVE_POLLING_MAX_SECONDS,
PVE_POLLING_MIN_SECONDS,
PVE_POLLING_PRESETS,
} from '@/utils/systemSettingsPresentation';
import { getSettingsTabSaveBehavior } from './settingsTabSaveBehavior';
import type { SettingsTab } from './settingsTypes';
interface UseSystemSettingsStateParams {
activeTab: Accessor<SettingsTab>;
loadSecurityStatus: () => Promise<void>;
setDiscoveryEnabled: Setter<boolean>;
applySavedDiscoverySubnet: (subnet?: string | null) => void;
}
export function useSystemSettingsState({
activeTab,
loadSecurityStatus,
setDiscoveryEnabled,
applySavedDiscoverySubnet,
}: UseSystemSettingsStateParams) {
const normalizeAutoUpdateEnabled = (channel: 'stable' | 'rc', enabled: boolean) =>
channel === 'stable' && enabled;
const [hasUnsavedChanges, setHasUnsavedChanges] = createSignal(false);
const [pvePollingInterval, setPVEPollingInterval] = createSignal<number>(PVE_POLLING_MIN_SECONDS);
const [pvePollingSelection, setPVEPollingSelection] = createSignal<number | 'custom'>(
PVE_POLLING_MIN_SECONDS,
);
const [pvePollingCustomSeconds, setPVEPollingCustomSeconds] = createSignal(30);
const [allowedOrigins, setAllowedOrigins] = createSignal('');
const [allowEmbedding, setAllowEmbedding] = createSignal(false);
const [allowedEmbedOrigins, setAllowedEmbedOrigins] = createSignal('');
const [webhookAllowedPrivateCIDRs, setWebhookAllowedPrivateCIDRs] = createSignal('');
const [publicURL, setPublicURL] = createSignal('');
const [envOverrides, setEnvOverrides] = createSignal<Record<string, boolean>>({});
const [temperatureMonitoringEnabled, setTemperatureMonitoringEnabled] = createSignal(true);
const [savingTemperatureSetting, setSavingTemperatureSetting] = createSignal(false);
const [hideLocalLogin, setHideLocalLogin] = createSignal(false);
const [savingHideLocalLogin, setSavingHideLocalLogin] = createSignal(false);
const [disableDockerUpdateActions, setDisableDockerUpdateActions] = createSignal(false);
const [savingDockerUpdateActions, setSavingDockerUpdateActions] = createSignal(false);
const [enableProxmoxGuestDockerInventory, setEnableProxmoxGuestDockerInventory] =
createSignal(false);
const [savingGuestDockerInventory, setSavingGuestDockerInventory] = createSignal(false);
const [telemetryEnabled, setTelemetryEnabled] = createSignal(true);
const [reportBrandDisplayName, setReportBrandDisplayName] = createSignal('');
const [reportBrandLogoBase64, setReportBrandLogoBase64] = createSignal('');
const [reportBrandLogoFormat, setReportBrandLogoFormat] =
createSignal<NonNullable<ReportBrandSettings['logoFormat']>>('');
const [savingTelemetry, setSavingTelemetry] = createSignal(false);
const [telemetryPreview, setTelemetryPreview] = createSignal<TelemetryPreviewResponse | null>(
null,
);
const [loadingTelemetryPreview, setLoadingTelemetryPreview] = createSignal(false);
const [resettingTelemetryInstallID, setResettingTelemetryInstallID] = createSignal(false);
const versionInfo = updateStore.versionInfo;
const [updateInfo, setUpdateInfo] = createSignal<UpdateInfo | null>(null);
const [checkingForUpdates, setCheckingForUpdates] = createSignal(false);
const [updateChannel, setUpdateChannel] = createSignal<'stable' | 'rc'>('stable');
const [autoUpdateEnabled, setAutoUpdateEnabled] = createSignal(false);
const [updatePlan, setUpdatePlan] = createSignal<UpdatePlan | null>(null);
const [isInstallingUpdate, setIsInstallingUpdate] = createSignal(false);
const [showUpdateConfirmation, setShowUpdateConfirmation] = createSignal(false);
const [backupPollingEnabled, setBackupPollingEnabled] = createSignal(true);
const [backupPollingInterval, setBackupPollingInterval] = createSignal(0);
const [backupPollingCustomMinutes, setBackupPollingCustomMinutes] = createSignal(60);
const [backupPollingUseCustom, setBackupPollingUseCustom] = createSignal(false);
const temperatureMonitoringLocked = () =>
Boolean(
envOverrides().temperatureMonitoringEnabled ||
envOverrides()['ENABLE_TEMPERATURE_MONITORING'],
);
const hideLocalLoginLocked = () =>
Boolean(envOverrides().hideLocalLogin || envOverrides()['PULSE_AUTH_HIDE_LOCAL_LOGIN']);
const disableDockerUpdateActionsLocked = () =>
Boolean(
envOverrides().disableDockerUpdateActions ||
envOverrides()['PULSE_DISABLE_DOCKER_UPDATE_ACTIONS'],
);
const guestDockerInventoryLocked = () =>
Boolean(
envOverrides().enableProxmoxGuestDockerInventory ||
envOverrides()['PULSE_ENABLE_PROXMOX_GUEST_DOCKER_INVENTORY'],
);
const telemetryEnabledLocked = () =>
Boolean(envOverrides().telemetryEnabled || envOverrides()['PULSE_TELEMETRY']);
const pvePollingEnvLocked = () =>
Boolean(envOverrides().pvePollingInterval || envOverrides().PVE_POLLING_INTERVAL);
const backupPollingEnvLocked = () =>
Boolean(envOverrides()['ENABLE_BACKUP_POLLING'] || envOverrides()['BACKUP_POLLING_INTERVAL']);
const backupIntervalSelectValue = () =>
getBackupIntervalSelectValue(backupPollingUseCustom(), backupPollingInterval());
const backupIntervalSummary = () =>
getBackupIntervalSummary(backupPollingEnabled(), backupPollingInterval());
const telemetryPreviewPayload = () =>
telemetryPreview() ? JSON.stringify(telemetryPreview()!.payload, null, 2) : '';
const telemetryPreviewEnabled = () => telemetryPreview()?.enabled ?? telemetryEnabled();
const applyPVEPollingSeconds = (rawSeconds: number) => {
const clamped = Math.min(
PVE_POLLING_MAX_SECONDS,
Math.max(PVE_POLLING_MIN_SECONDS, Math.round(rawSeconds)),
);
setPVEPollingInterval(clamped);
const presetMatch = PVE_POLLING_PRESETS.find((opt) => opt.value === clamped);
if (presetMatch) {
setPVEPollingSelection(presetMatch.value);
} else {
setPVEPollingSelection('custom');
setPVEPollingCustomSeconds(clamped);
}
};
const initializeSystemSettingsState = async () => {
try {
const systemSettings = await SettingsAPI.getSystemSettings();
applyPVEPollingSeconds(
typeof systemSettings.pvePollingInterval === 'number'
? systemSettings.pvePollingInterval
: PVE_POLLING_MIN_SECONDS,
);
setAllowedOrigins(systemSettings.allowedOrigins ?? '');
setDiscoveryEnabled(systemSettings.discoveryEnabled ?? false);
applySavedDiscoverySubnet(systemSettings.discoverySubnet);
setAllowEmbedding(systemSettings.allowEmbedding ?? false);
setAllowedEmbedOrigins(systemSettings.allowedEmbedOrigins || '');
setWebhookAllowedPrivateCIDRs(systemSettings.webhookAllowedPrivateCIDRs || '');
setPublicURL(systemSettings.publicURL || '');
setTemperatureMonitoringEnabled(
typeof systemSettings.temperatureMonitoringEnabled === 'boolean'
? systemSettings.temperatureMonitoringEnabled
: true,
);
setHideLocalLogin(systemSettings.hideLocalLogin ?? false);
setDisableDockerUpdateActions(systemSettings.disableDockerUpdateActions ?? false);
setEnableProxmoxGuestDockerInventory(
systemSettings.enableProxmoxGuestDockerInventory ?? false,
);
setTelemetryEnabled(systemSettings.telemetryEnabled ?? true);
setReportBrandDisplayName(systemSettings.reportBranding?.displayName ?? '');
setReportBrandLogoBase64(systemSettings.reportBranding?.logoBase64 ?? '');
setReportBrandLogoFormat(systemSettings.reportBranding?.logoFormat ?? '');
if (typeof systemSettings.backupPollingEnabled === 'boolean') {
setBackupPollingEnabled(systemSettings.backupPollingEnabled);
} else {
setBackupPollingEnabled(true);
}
const intervalSeconds =
typeof systemSettings.backupPollingInterval === 'number'
? Math.max(0, Math.floor(systemSettings.backupPollingInterval))
: 0;
setBackupPollingInterval(intervalSeconds);
if (intervalSeconds > 0) {
setBackupPollingCustomMinutes(Math.max(1, Math.round(intervalSeconds / 60)));
}
const isPresetInterval = BACKUP_INTERVAL_OPTIONS.some((opt) => opt.value === intervalSeconds);
setBackupPollingUseCustom(!isPresetInterval && intervalSeconds > 0);
const savedUpdateChannel =
systemSettings.updateChannel === 'rc' ? ('rc' as const) : ('stable' as const);
setUpdateChannel(savedUpdateChannel);
setAutoUpdateEnabled(
normalizeAutoUpdateEnabled(savedUpdateChannel, systemSettings.autoUpdateEnabled || false),
);
if (systemSettings.envOverrides) {
setEnvOverrides(systemSettings.envOverrides);
}
} catch (error) {
logger.error('Failed to load settings', error);
// Viewers cannot read the admin settings payload, but they still need to
// see the effective server-wide state of read-only controls. Use the
// deliberately narrow authenticated-session projection for those values.
try {
const runtimeDisplay = await SettingsAPI.getRuntimeDisplay();
const dockerActionsDisabled = runtimeDisplay.disableDockerUpdateActions ?? false;
setDisableDockerUpdateActions(dockerActionsDisabled);
updateDockerUpdateActionsSetting(dockerActionsDisabled);
setTelemetryEnabled(runtimeDisplay.telemetryEnabled ?? true);
// Without this, the Monitoring Cadence card shows the Realtime (10s)
// default instead of the interval the server actually polls at.
if (
typeof runtimeDisplay.pvePollingInterval === 'number' &&
runtimeDisplay.pvePollingInterval > 0
) {
applyPVEPollingSeconds(runtimeDisplay.pvePollingInterval);
}
} catch (runtimeDisplayError) {
logger.warn('Failed to load read-only runtime settings', runtimeDisplayError);
}
}
try {
await updateStore.checkForUpdates();
const storeInfo = updateStore.updateInfo();
if (storeInfo) {
setUpdateInfo(storeInfo);
if (storeInfo.available && storeInfo.latestVersion) {
try {
const plan = await UpdatesAPI.getUpdatePlan(storeInfo.latestVersion);
setUpdatePlan(plan);
} catch (planError) {
logger.warn('Failed to fetch update plan on load', planError);
}
}
}
const version = versionInfo();
if (version?.channel && !updateChannel()) {
setUpdateChannel(version.channel as 'stable' | 'rc');
}
} catch (error) {
logger.error('Failed to load version', error);
}
};
const saveSettings = async () => {
const initiatingTab = activeTab();
try {
if (getSettingsTabSaveBehavior(initiatingTab) === 'system') {
await SettingsAPI.updateSystemSettings({
pvePollingInterval: pvePollingInterval(),
allowedOrigins: allowedOrigins(),
updateChannel: updateChannel(),
autoUpdateEnabled: normalizeAutoUpdateEnabled(updateChannel(), autoUpdateEnabled()),
backupPollingEnabled: backupPollingEnabled(),
backupPollingInterval: backupPollingInterval(),
allowEmbedding: allowEmbedding(),
allowedEmbedOrigins: allowedEmbedOrigins(),
webhookAllowedPrivateCIDRs: webhookAllowedPrivateCIDRs(),
publicURL: publicURL(),
reportBranding: {
displayName: reportBrandDisplayName().trim(),
logoBase64: reportBrandLogoBase64(),
logoFormat: reportBrandLogoFormat(),
},
});
await loadRuntimeBranding();
}
const isNetworkTab = initiatingTab === 'system-network';
notificationStore.success(
isNetworkTab
? 'Settings saved successfully. Service restart may be required for network changes.'
: 'Settings saved successfully.',
);
setHasUnsavedChanges(false);
if (isNetworkTab) {
setTimeout(() => {
window.location.reload();
}, 3000);
}
} catch (error) {
notificationStore.error(
getSystemSettingsSaveErrorMessage(error instanceof Error ? error.message : undefined),
);
}
};
const handleHideLocalLoginChange = async (enabled: boolean): Promise<void> => {
if (hideLocalLoginLocked() || savingHideLocalLogin()) {
return;
}
const previous = hideLocalLogin();
setHideLocalLogin(enabled);
setSavingHideLocalLogin(true);
try {
await SettingsAPI.updateSystemSettings({ hideLocalLogin: enabled });
if (enabled) {
notificationStore.success('Local login hidden', 2000);
} else {
notificationStore.info('Local login visible', 2000);
}
await loadSecurityStatus();
} catch (error) {
logger.error('Failed to update hide local login setting', error);
notificationStore.error(
getHideLocalLoginUpdateErrorMessage(error instanceof Error ? error.message : undefined),
);
setHideLocalLogin(previous);
} finally {
setSavingHideLocalLogin(false);
}
};
const handleDisableDockerUpdateActionsChange = async (disabled: boolean): Promise<void> => {
if (disableDockerUpdateActionsLocked() || savingDockerUpdateActions()) {
return;
}
const previous = disableDockerUpdateActions();
setDisableDockerUpdateActions(disabled);
setSavingDockerUpdateActions(true);
try {
await SettingsAPI.updateSystemSettings({ disableDockerUpdateActions: disabled });
updateDockerUpdateActionsSetting(disabled);
if (disabled) {
notificationStore.success('Docker update buttons hidden', 2000);
} else {
notificationStore.info('Docker update buttons visible', 2000);
}
} catch (error) {
logger.error('Failed to update Docker update actions setting', error);
notificationStore.error(
getDockerUpdateActionsUpdateErrorMessage(
error instanceof Error ? error.message : undefined,
),
);
setDisableDockerUpdateActions(previous);
} finally {
setSavingDockerUpdateActions(false);
}
};
const handleGuestDockerInventoryChange = async (enabled: boolean): Promise<void> => {
if (guestDockerInventoryLocked() || savingGuestDockerInventory()) {
return;
}
const previous = enableProxmoxGuestDockerInventory();
setEnableProxmoxGuestDockerInventory(enabled);
setSavingGuestDockerInventory(true);
try {
await SettingsAPI.updateSystemSettings({ enableProxmoxGuestDockerInventory: enabled });
if (enabled) {
notificationStore.success('Docker discovery in LXC guests enabled', 2000);
} else {
notificationStore.info('Docker discovery in LXC guests disabled', 2000);
}
} catch (error) {
logger.error('Failed to update guest Docker discovery setting', error);
notificationStore.error(
getGuestDockerInventoryUpdateErrorMessage(
error instanceof Error ? error.message : undefined,
),
);
setEnableProxmoxGuestDockerInventory(previous);
} finally {
setSavingGuestDockerInventory(false);
}
};
const handleTelemetryEnabledChange = async (enabled: boolean): Promise<void> => {
if (telemetryEnabledLocked() || savingTelemetry()) {
return;
}
const previous = telemetryEnabled();
setTelemetryEnabled(enabled);
setSavingTelemetry(true);
try {
await SettingsAPI.updateSystemSettings({ telemetryEnabled: enabled });
notificationStore.success(
enabled ? 'Outbound usage telemetry enabled' : 'Outbound usage telemetry disabled',
3000,
);
} catch (error) {
logger.error('Failed to update telemetry setting', error);
notificationStore.error(
getTelemetryUpdateErrorMessage(error instanceof Error ? error.message : undefined),
);
setTelemetryEnabled(previous);
} finally {
setSavingTelemetry(false);
}
};
const handleLoadTelemetryPreview = async (): Promise<void> => {
if (loadingTelemetryPreview()) {
return;
}
setLoadingTelemetryPreview(true);
try {
const preview = await SettingsAPI.getTelemetryPreview();
setTelemetryPreview(preview);
} catch (error) {
logger.error('Failed to load telemetry preview', error);
notificationStore.error('Failed to load telemetry preview');
} finally {
setLoadingTelemetryPreview(false);
}
};
const handleCopyTelemetryPreview = async (): Promise<void> => {
const payload = telemetryPreviewPayload();
if (!payload) {
return;
}
const copied = await copyToClipboard(payload);
if (copied) {
notificationStore.success('Telemetry payload copied to clipboard', 2000);
return;
}
notificationStore.error('Failed to copy telemetry payload');
};
const handleResetTelemetryInstallID = async (): Promise<void> => {
if (resettingTelemetryInstallID()) {
return;
}
if (
!confirm(
'Reset the rotating telemetry install ID now? This immediately replaces the local pseudonymous identifier used for outbound usage telemetry.',
)
) {
return;
}
setResettingTelemetryInstallID(true);
try {
const preview = await SettingsAPI.resetTelemetryInstallID();
setTelemetryPreview(preview);
notificationStore.success('Telemetry install ID reset', 3000);
} catch (error) {
logger.error('Failed to reset telemetry install ID', error);
notificationStore.error('Failed to reset telemetry install ID');
} finally {
setResettingTelemetryInstallID(false);
}
};
const handleTemperatureMonitoringChange = async (enabled: boolean): Promise<void> => {
if (temperatureMonitoringLocked() || savingTemperatureSetting()) {
return;
}
const previous = temperatureMonitoringEnabled();
setTemperatureMonitoringEnabled(enabled);
setSavingTemperatureSetting(true);
try {
await SettingsAPI.updateSystemSettings({ temperatureMonitoringEnabled: enabled });
if (enabled) {
notificationStore.success('Temperature monitoring enabled', 2000);
} else {
notificationStore.info('Temperature monitoring disabled', 2000);
}
} catch (error) {
logger.error('Failed to update temperature monitoring setting', error);
notificationStore.error(
getTemperatureMonitoringUpdateErrorMessage(
error instanceof Error ? error.message : undefined,
),
);
setTemperatureMonitoringEnabled(previous);
} finally {
setSavingTemperatureSetting(false);
}
};
const checkForUpdates = async () => {
setCheckingForUpdates(true);
try {
await updateStore.checkForUpdates(true);
if (updateStore.lastError()) return;
const info = updateStore.updateInfo();
setUpdateInfo(info);
if (info?.available && info.latestVersion) {
try {
const plan = await UpdatesAPI.getUpdatePlan(info.latestVersion);
setUpdatePlan(plan);
} catch (planError) {
logger.warn('Failed to fetch update plan', planError);
setUpdatePlan(null);
}
} else {
setUpdatePlan(null);
}
if (info?.available && updateStore.isDismissed()) {
updateStore.clearDismissed();
}
if (!info?.available) {
notificationStore.success('You are running the latest version');
}
} catch (error) {
notificationStore.error(getCheckForUpdatesErrorMessage());
logger.error('Update check error', error);
} finally {
setCheckingForUpdates(false);
}
};
const handleInstallUpdate = async () => {
setShowUpdateConfirmation(true);
};
const handleConfirmUpdate = async () => {
setIsInstallingUpdate(true);
try {
// The shared store action owns the POST and error toast.
const started = await updateStore.applyUpdate();
if (started) {
setShowUpdateConfirmation(false);
}
} finally {
setIsInstallingUpdate(false);
}
};
return {
hasUnsavedChanges,
setHasUnsavedChanges,
pvePollingInterval,
setPVEPollingInterval,
pvePollingSelection,
setPVEPollingSelection,
pvePollingCustomSeconds,
setPVEPollingCustomSeconds,
pvePollingEnvLocked,
allowedOrigins,
setAllowedOrigins,
allowEmbedding,
setAllowEmbedding,
allowedEmbedOrigins,
setAllowedEmbedOrigins,
webhookAllowedPrivateCIDRs,
setWebhookAllowedPrivateCIDRs,
publicURL,
setPublicURL,
envOverrides,
temperatureMonitoringEnabled,
setTemperatureMonitoringEnabled,
temperatureMonitoringLocked,
savingTemperatureSetting,
setSavingTemperatureSetting,
handleTemperatureMonitoringChange,
hideLocalLogin,
hideLocalLoginLocked,
savingHideLocalLogin,
handleHideLocalLoginChange,
disableDockerUpdateActions,
disableDockerUpdateActionsLocked,
savingDockerUpdateActions,
handleDisableDockerUpdateActionsChange,
enableProxmoxGuestDockerInventory,
guestDockerInventoryLocked,
savingGuestDockerInventory,
handleGuestDockerInventoryChange,
telemetryEnabled,
reportBrandDisplayName,
setReportBrandDisplayName,
reportBrandLogoBase64,
setReportBrandLogoBase64,
reportBrandLogoFormat,
setReportBrandLogoFormat,
telemetryEnabledLocked,
savingTelemetry,
handleTelemetryEnabledChange,
telemetryPreview,
telemetryPreviewEnabled,
telemetryPreviewPayload,
loadingTelemetryPreview,
resettingTelemetryInstallID,
handleLoadTelemetryPreview,
handleCopyTelemetryPreview,
handleResetTelemetryInstallID,
versionInfo,
updateInfo,
checkingForUpdates,
updateChannel,
setUpdateChannel,
autoUpdateEnabled,
setAutoUpdateEnabled,
updatePlan,
isInstallingUpdate,
showUpdateConfirmation,
setShowUpdateConfirmation,
backupPollingEnabled,
setBackupPollingEnabled,
backupPollingInterval,
setBackupPollingInterval,
backupPollingCustomMinutes,
setBackupPollingCustomMinutes,
backupPollingUseCustom,
setBackupPollingUseCustom,
backupPollingEnvLocked,
backupIntervalSelectValue,
backupIntervalSummary,
initializeSystemSettingsState,
saveSettings,
checkForUpdates,
handleInstallUpdate,
handleConfirmUpdate,
};
}