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.

10.0 KB
Raw Blame
import { Accessor, createSignal, onCleanup } from 'solid-js';
import { notificationStore } from '@/stores/notifications';
import {
  apiFetchJSON,
  getOrgID,
  getApiToken as getApiClientToken,
  setApiToken as setApiClientToken,
} from '@/utils/apiClient';
import type { SecurityStatus } from '@/types/config';

interface UseBackupTransferFlowParams {
  securityStatus: Accessor<SecurityStatus | null>;
}

const CHANGED_WORKSPACE =
  'Organisation changed. Close this dialog and reopen it in the intended workspace.';

// Allow room for the exported JSON envelope/formatting without reading an
// unbounded local file. The wire limit matches handleImportConfig's reader;
// include JSON escaping and UTF-8 password bytes, not just ciphertext length.
export const MAX_CONFIG_IMPORT_FILE_BYTES = 2 * 1024 * 1024;
export const MAX_CONFIG_IMPORT_REQUEST_BYTES = 1024 * 1024;

export function useBackupTransferFlow({ securityStatus }: UseBackupTransferFlowParams) {
  const [exportPassphrase, setExportPassphrase] = createSignal('');
  const [exportPassphraseConfirmation, setExportPassphraseConfirmation] = createSignal('');
  const [importPassphrase, setImportPassphrase] = createSignal('');
  const [importFile, setImportFile] = createSignal<File | null>(null);
  const [showExportDialog, showExport] = createSignal(false);
  const [showImportDialog, showImport] = createSignal(false);
  const [showApiTokenModal, setShowApiTokenModal] = createSignal(false);
  const [apiTokenInput, setApiTokenInput] = createSignal('');
  const [apiTokenError, setApiTokenError] = createSignal('');
  const [transferOrgID, setTransferOrgID] = createSignal('default');
  const [isTransferring, setIsTransferring] = createSignal(false);
  const [transferError, setTransferError] = createSignal('');
  const [transferNotice, setTransferNotice] = createSignal('');
  let active = true;
  let controller: AbortController | undefined;
  let reloadTimer: ReturnType<typeof setTimeout> | undefined;

  onCleanup(() => {
    active = false;
    controller?.abort();
    clearTimeout(reloadTimer);
  });

  const currentOrgID = () => getOrgID() || 'default';
  const fail = (message: string) => {
    setTransferNotice('');
    setTransferError(message);
  };
  const checkWorkspace = () => {
    if (currentOrgID() === transferOrgID()) return true;
    fail(CHANGED_WORKSPACE);
    return false;
  };

  const closeApiTokenModal = () => {
    setShowApiTokenModal(false);
    setApiTokenInput('');
    setApiTokenError('');
  };
  const closeExportDialog = () => {
    if (isTransferring()) return;
    showExport(false);
    setExportPassphrase('');
    setExportPassphraseConfirmation('');
    closeApiTokenModal();
  };
  const closeImportDialog = () => {
    if (isTransferring()) return;
    showImport(false);
    setImportPassphrase('');
    setImportFile(null);
    closeApiTokenModal();
  };
  const openDialog = (kind: 'export' | 'import') => {
    if (isTransferring()) return;
    clearTimeout(reloadTimer);
    closeExportDialog();
    closeImportDialog();
    setTransferError('');
    setTransferNotice('');
    setTransferOrgID(currentOrgID());
    if (kind === 'export') showExport(true);
    else showImport(true);
  };
  const setShowExportDialog = (open: boolean) =>
    open ? openDialog('export') : closeExportDialog();
  const setShowImportDialog = (open: boolean) =>
    open ? openDialog('import') : closeImportDialog();

  const needsApiToken = () => {
    if (
      !securityStatus()?.hasAuthentication &&
      securityStatus()?.apiTokenConfigured &&
      !getApiClientToken()
    ) {
      setShowApiTokenModal(true);
      return true;
    }
    return false;
  };

  const handleExport = async () => {
    if (!active || !showExportDialog() || isTransferring() || !checkWorkspace()) return;
    setTransferError('');
    setTransferNotice('');
    const passphrase = exportPassphrase();
    if (!passphrase) {
      fail('Please enter a backup passphrase');
      return;
    }
    if (passphrase.length < 12) {
      fail('Passphrase must be at least 12 characters long');
      return;
    }
    if (!exportPassphraseConfirmation()) {
      fail('Please confirm the backup passphrase. No export was sent.');
      return;
    }
    if (passphrase !== exportPassphraseConfirmation()) {
      fail('Passphrases do not match. No export was sent.');
      return;
    }
    if (needsApiToken()) return;

    const orgID = transferOrgID();
    controller = new AbortController();
    setIsTransferring(true);
    try {
      const data = await apiFetchJSON('/api/config/export', {
        method: 'POST',
        body: JSON.stringify({ passphrase }),
        expectedOrgID: orgID,
        retry: false,
        signal: controller.signal,
      });
      if (!active || !checkWorkspace()) return;

      const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
      const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      try {
        a.href = url;
        a.download = `pulse-config-${new Date().toISOString().split('T')[0]}.json`;
        document.body.appendChild(a);
        a.click();
      } finally {
        a.remove();
        URL.revokeObjectURL(url);
      }
      notificationStore.success('Configuration exported successfully');
      showExport(false);
      setExportPassphrase('');
      setExportPassphraseConfirmation('');
    } catch (error) {
      if (active) fail(error instanceof Error ? error.message : 'Failed to export configuration');
    } finally {
      if (active) setIsTransferring(false);
    }
  };

  const handleImport = async () => {
    if (!active || !showImportDialog() || isTransferring() || !checkWorkspace()) return;
    setTransferError('');
    setTransferNotice('');
    const passphrase = importPassphrase();
    const file = importFile();
    if (!passphrase) {
      fail('Please enter the backup passphrase');
      return;
    }
    if (!file) {
      fail('Please select a file to import');
      return;
    }
    if (file.size > MAX_CONFIG_IMPORT_FILE_BYTES) {
      fail(
        'Configuration file exceeds the 2 MiB browser import limit. No import was sent. See the migration guide for recovery options.',
      );
      return;
    }
    if (needsApiToken()) return;

    // Freeze the confirmed target and inputs before the asynchronous file read.
    const orgID = transferOrgID();
    controller = new AbortController();
    const signal = controller.signal;
    setIsTransferring(true);
    let submitted = false;
    try {
      const fileContent = await file.text();
      if (!active || !checkWorkspace()) return;

      // UI/legacy JSON envelopes, JSON strings and raw CLI base64 remain supported.
      let encryptedData: unknown;
      try {
        const parsed: unknown = JSON.parse(fileContent);
        encryptedData =
          typeof parsed === 'string'
            ? parsed
            : parsed && typeof parsed === 'object' && 'data' in parsed
              ? parsed.data
              : undefined;
      } catch {
        encryptedData = fileContent.trim();
      }
      if (typeof encryptedData !== 'string' || !encryptedData.trim()) {
        fail('Invalid backup file format. Expected encrypted data in "data" field.');
        return;
      }

      const body = JSON.stringify({ passphrase, data: encryptedData });
      if (new Blob([body]).size > MAX_CONFIG_IMPORT_REQUEST_BYTES) {
        fail(
          'Import exceeds the server’s 1 MiB request limit, including the password. No import was sent. See the migration guide for recovery options.',
        );
        return;
      }

      submitted = true;
      await apiFetchJSON('/api/config/import', {
        method: 'POST',
        body,
        expectedOrgID: orgID,
        retry: false,
        signal,
      });
      if (!active) return;
      if (currentOrgID() !== orgID) {
        fail(
          `Import completed for workspace ${orgID}. The selected workspace changed. No reload was performed.`,
        );
        // Keep the original destination and outcome readable in the dialog.
        setImportPassphrase('');
        setImportFile(null);
        return;
      }

      notificationStore.success('Configuration imported successfully. Reloading...');
      showImport(false);
      setImportPassphrase('');
      setImportFile(null);
      // Never reload a different workspace or an unmounted Settings view.
      reloadTimer = setTimeout(() => {
        if (active && currentOrgID() === orgID) window.location.reload();
      }, 2000);
    } catch (error) {
      if (!active) return;
      const errorText = error instanceof Error ? error.message : 'Failed to import configuration';
      fail(
        submitted
          ? `${errorText} Import was not confirmed and may have applied. Check the destination before trying again.`
          : errorText,
      );
      if (/api[_ -]?tokens?|x-api-token/i.test(errorText)) setShowApiTokenModal(true);
    } finally {
      if (active) setIsTransferring(false);
    }
  };

  const handleApiTokenAuthenticate = () => {
    if (!active || isTransferring() || !checkWorkspace()) {
      closeApiTokenModal();
      return;
    }
    if (!apiTokenInput().trim()) {
      setApiTokenError('Please enter the API token');
      return;
    }
    setApiClientToken(apiTokenInput());
    if (!getApiClientToken()) {
      setApiTokenError('Please enter a valid API token');
      return;
    }
    closeApiTokenModal();
    // Saving a credential is not consent to replay a possibly applied import.
    setTransferNotice('API token saved. Review the workspace and submit the transfer again.');
  };

  return {
    exportPassphrase,
    setExportPassphrase,
    exportPassphraseConfirmation,
    setExportPassphraseConfirmation,
    importPassphrase,
    setImportPassphrase,
    importFile,
    setImportFile,
    showExportDialog,
    setShowExportDialog,
    showImportDialog,
    setShowImportDialog,
    showApiTokenModal,
    apiTokenInput,
    apiTokenError,
    setApiTokenInput,
    transferOrgID,
    isTransferring,
    transferError,
    transferNotice,
    handleExport,
    handleImport,
    closeExportDialog,
    closeImportDialog,
    closeApiTokenModal,
    handleApiTokenAuthenticate,
  };
}