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.

8.6 KB
Raw Blame
import { createMemo, createSignal, onCleanup, onMount } from 'solid-js';
import { hasFeature } from '@/stores/license';
import { getUpgradeActionDestination } from '@/stores/licenseCommercial';
import { presentationPolicyHidesUpgradePrompts } from '@/stores/sessionPresentationPolicy';
import { loadRuntimeCapabilities } from '@/stores/license';
import { showError, showSuccess } from '@/utils/toast';
import { RelayAPI, type RelayConfig, type RelayStatus } from '@/api/relay';
import {
  OnboardingAPI,
  OnboardingNotReadyError,
  type OnboardingQRResponse,
} from '@/api/onboarding';
import { SecurityAPI, type APITokenRecord } from '@/api/security';
import { logger } from '@/utils/logger';
import {
  getRelayConnectionPresentation,
  getRelayStatusErrorMessage,
} from '@/utils/relayPresentation';
import QRCode from 'qrcode';

export interface RelaySettingsPanelProps {
  canManage?: boolean;
}

export function useRelaySettingsPanelState(props: RelaySettingsPanelProps) {
  const [config, setConfig] = createSignal<RelayConfig | null>(null);
  const [status, setStatus] = createSignal<RelayStatus | null>(null);
  const [loading, setLoading] = createSignal(true);
  const [saving, setSaving] = createSignal(false);
  const [serverUrl, setServerUrl] = createSignal('');
  const [showPairing, setShowPairing] = createSignal(false);
  const [pairingLoading, setPairingLoading] = createSignal(false);
  const [pairingPayload, setPairingPayload] = createSignal<OnboardingQRResponse | null>(null);
  const [pairingQRCode, setPairingQRCode] = createSignal<string | null>(null);
  const [pairingTokenId, setPairingTokenId] = createSignal<string | null>(null);

  const canManage = () => props.canManage !== false;
  const showUpgradePrompts = () => !presentationPolicyHidesUpgradePrompts();
  const relayEnabled = () => hasFeature('relay');
  const upgradeDestination = () => getUpgradeActionDestination('relay');
  const connectionPresentation = createMemo(() =>
    getRelayConnectionPresentation(config(), status()),
  );
  const statusErrorMessage = createMemo(() => getRelayStatusErrorMessage(status()));
  const canShowPairing = createMemo(() => Boolean(config()?.enabled && status()?.connected));

  let statusInterval: ReturnType<typeof setInterval> | undefined;

  const resetPairingState = () => {
    setShowPairing(false);
    setPairingLoading(false);
    setPairingPayload(null);
    setPairingQRCode(null);
    setPairingTokenId(null);
  };

  const deletePairingToken = async (tokenID: string | null) => {
    if (!tokenID) return;
    try {
      await SecurityAPI.deleteToken(tokenID);
    } catch (error) {
      logger.warn('[RelaySettings] Failed to clean up relay pairing token', error);
    }
  };

  const getPairingTokenRecord = async (tokenID: string): Promise<APITokenRecord | null> => {
    try {
      return await SecurityAPI.getToken(tokenID);
    } catch (error) {
      const status = (error as { status?: number } | null)?.status;
      if (status === 404) {
        return null;
      }
      throw error;
    }
  };

  const deletePairingTokenIfUnused = async (tokenID: string | null) => {
    if (!tokenID) return;
    try {
      const record = await getPairingTokenRecord(tokenID);
      if (!record || record.lastUsedAt) {
        return;
      }
      await deletePairingToken(tokenID);
    } catch (error) {
      logger.warn('[RelaySettings] Failed to inspect relay pairing token lifecycle', error);
    }
  };

  const pairingGenerationErrorMessage = (error: unknown): string => {
    if (error instanceof OnboardingNotReadyError) {
      return (
        error.diagnostics.find((diagnostic) => diagnostic.severity === 'error')?.message ||
        error.message ||
        'Pulse Mobile pairing is not ready yet.'
      );
    }
    return 'Failed to generate pairing QR code';
  };

  const loadConfig = async () => {
    try {
      const nextConfig = await RelayAPI.getConfig();
      setConfig(nextConfig);
      setServerUrl(nextConfig.server_url);
      if (!nextConfig.enabled) {
        await deletePairingTokenIfUnused(pairingTokenId());
        resetPairingState();
      }
    } catch (error) {
      logger.error('[RelaySettings] Failed to load config', error);
    }
  };

  const loadStatus = async () => {
    try {
      const nextStatus = await RelayAPI.getStatus();
      setStatus(nextStatus);
    } catch (error) {
      logger.error('[RelaySettings] Failed to load status', error);
    }
  };

  const stopStatusPolling = () => {
    if (statusInterval !== undefined) {
      clearInterval(statusInterval);
      statusInterval = undefined;
    }
  };

  const startStatusPolling = () => {
    stopStatusPolling();
    void loadStatus();
    statusInterval = setInterval(() => void loadStatus(), 5000);
  };

  onMount(async () => {
    await loadRuntimeCapabilities();
    if (!relayEnabled()) {
      setLoading(false);
      return;
    }

    await loadConfig();
    if (config()?.enabled) {
      startStatusPolling();
    }
    setLoading(false);
  });

  onCleanup(() => {
    stopStatusPolling();
    void deletePairingTokenIfUnused(pairingTokenId());
  });

  const handleToggleEnabled = async (enabled: boolean) => {
    if (!canManage()) return;
    setSaving(true);
    try {
      await RelayAPI.updateConfig({ enabled });
      await loadConfig();
      if (enabled) {
        startStatusPolling();
        showSuccess('Pulse Mobile connections on');
      } else {
        stopStatusPolling();
        setStatus(null);
        await deletePairingTokenIfUnused(pairingTokenId());
        resetPairingState();
        showSuccess('Pulse Mobile connections off');
      }
    } catch (error) {
      showError('Failed to update relay configuration');
      logger.error('[RelaySettings] Failed to toggle', error);
    } finally {
      setSaving(false);
    }
  };

  const handleSaveServerUrl = async () => {
    if (!canManage()) return;
    const url = serverUrl().trim();
    if (!url) return;
    setSaving(true);
    try {
      await RelayAPI.updateConfig({ server_url: url });
      await loadConfig();
      showSuccess('Server URL updated');
    } catch (error) {
      showError('Failed to update server URL');
      logger.error('[RelaySettings] Failed to save server URL', error);
    } finally {
      setSaving(false);
    }
  };

  const handlePairNewDevice = async () => {
    if (!canManage()) return;
    const previousPayload = pairingPayload();
    const previousQRCode = pairingQRCode();
    const previousTokenId = pairingTokenId();
    setShowPairing(true);
    setPairingLoading(true);

    let createdTokenId: string | null = null;
    try {
      const createdToken = await SecurityAPI.createRelayMobileAccessToken();
      if (!createdToken.token) {
        throw new Error('Failed to generate relay device token');
      }
      createdTokenId = createdToken.record.id;

      const payload = await OnboardingAPI.getQRPayload(createdToken.token);
      if (!payload.auth_token) {
        throw new Error('Relay pairing payload is missing auth_token');
      }

      const qrCodeDataUrl = await QRCode.toDataURL(payload.deep_link, {
        width: 256,
        margin: 2,
      });
      setPairingPayload(payload);
      setPairingQRCode(qrCodeDataUrl);
      setPairingTokenId(createdTokenId);
      if (previousTokenId && previousTokenId !== createdTokenId) {
        await deletePairingTokenIfUnused(previousTokenId);
      }
    } catch (error) {
      await deletePairingToken(createdTokenId);
      setPairingPayload(previousPayload);
      setPairingQRCode(previousQRCode);
      setPairingTokenId(previousTokenId);
      showError(pairingGenerationErrorMessage(error));
      logger.error('[RelaySettings] Failed to generate onboarding QR', error);
    } finally {
      setPairingLoading(false);
    }
  };

  const handleHidePairing = async () => {
    await deletePairingTokenIfUnused(pairingTokenId());
    resetPairingState();
  };

  const handleCopyPairingPayload = async () => {
    const payload = pairingPayload();
    if (!payload) return;

    try {
      await navigator.clipboard.writeText(JSON.stringify(payload, null, 2));
      showSuccess('Pairing payload copied');
    } catch (error) {
      showError('Failed to copy pairing payload');
      logger.error('[RelaySettings] Failed to copy pairing payload', error);
    }
  };

  return {
    canManage,
    canShowPairing,
    config,
    connectionPresentation,
    handleCopyPairingPayload,
    handleHidePairing,
    handlePairNewDevice,
    handleSaveServerUrl,
    handleToggleEnabled,
    loading,
    pairingLoading,
    pairingPayload,
    pairingQRCode,
    relayEnabled,
    saving,
    serverUrl,
    setServerUrl,
    showUpgradePrompts,
    showPairing,
    status,
    statusErrorMessage,
    upgradeDestination,
  };
}