Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

22.8 KB
Raw Blame
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,
  };
}