@plutonhq/core-frontend 0.1.13 → 0.1.15

package/src/services/plans.ts

@@ -392,3 +392,78 @@ export function useCheckActiveBackupsOrRestore() {
       // refetchOnMount: true,
    });
 }
+
+// Remove Replication Storage
+export async function deleteReplicationStorage({
+   planID,
+   storageID,
+   storagePath,
+   removeData,
+   replicationId,
+}: {
+   planID: string;
+   storageID: string;
+   storagePath: string;
+   removeData: boolean;
+   replicationId?: string;
+}) {
+   const header = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
+   const res = await fetch(`${API_URL}/plans/${planID}/action/delete-replication-storage`, {
+      method: 'POST',
+      credentials: 'include',
+      headers: header,
+      body: JSON.stringify({ storageID, storagePath, removeData, replicationId }),
+   });
+   const data = await res.json();
+   if (!data.success) {
+      throw new Error(data.error);
+   }
+   return data;
+}
+
+export function useDeleteReplicationStorage() {
+   const queryClient = useQueryClient();
+   return useMutation({
+      mutationFn: deleteReplicationStorage,
+      onError: (error: Error) => {
+         console.log('error :', error?.message);
+         toast.error(error.message || `Error removing replication storage.`);
+      },
+      onSuccess: (res, variables) => {
+         console.log('# Replication Storage Removed! :', res, variables);
+         queryClient.invalidateQueries({ queryKey: ['plan', variables.planID] });
+         queryClient.invalidateQueries({ queryKey: ['plans'] });
+         toast.success(res?.message || `Replication storage removed successfully!`, { autoClose: 5000 });
+      },
+   });
+}
+
+export async function checkPlanIntegrity({ planId }: { planId: string }) {
+   // const header = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
+   const res = await fetch(`${API_URL}/plans/${planId}/action/checkintegrity`, {
+      method: 'POST',
+      credentials: 'include',
+      // headers: header,
+   });
+   // Check if response is ok
+   const data = await res.json();
+   if (!data.success) {
+      throw new Error(data.error);
+   }
+   return data;
+}
+
+export function useCheckPlanIntegrity() {
+   const queryClient = useQueryClient();
+   return useMutation({
+      mutationFn: checkPlanIntegrity,
+      onSuccess: (res, payload) => {
+         queryClient.invalidateQueries({ queryKey: ['plan', payload.planId] });
+         console.log('res :', payload, res);
+      },
+      onError: (error, payload) => {
+         console.error('Error checking plan integrity for planId:', payload.planId, error);
+         toast.error(`Error checking plan integrity. ${error instanceof Error ? error.message : 'Unknown error'}`, { autoClose: false });
+      },
+   });
+}

package/src/services/restores.ts

@@ -89,6 +89,8 @@ export async function restoreBackup({
    includes,
    excludes,
    deleteOption,
+   storageId,
+   replicationId,
 }: {
    backupId: string;
    planId: string;
@@ -97,13 +99,15 @@ export async function restoreBackup({
    includes?: string[];
    excludes?: string[];
    deleteOption: boolean;
+   storageId?: string;
+   replicationId?: string;
 }) {
    const header = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
    const res = await fetch(`${API_URL}/restores/action/restore`, {
       method: 'POST',
       credentials: 'include',
       headers: header,
-      body: JSON.stringify({ backupId, planId, target, overwrite, includes, excludes, delete: deleteOption }),
+      body: JSON.stringify({ backupId, planId, target, overwrite, includes, excludes, delete: deleteOption, storageId, replicationId }),
    });
    const data = await res.json();
    if (!data.success) {
@@ -132,6 +136,8 @@ export async function getDryRestoreStats({
    includes,
    excludes,
    deleteOption,
+   storageId,
+   replicationId,
 }: {
    backupId: string;
    planId: string;
@@ -140,13 +146,15 @@ export async function getDryRestoreStats({
    includes?: string[];
    excludes?: string[];
    deleteOption?: boolean;
+   storageId?: string;
+   replicationId?: string;
 }) {
    const header = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
    const res = await fetch(`${API_URL}/restores/action/dryrestore`, {
       method: 'POST',
       credentials: 'include',
       headers: header,
-      body: JSON.stringify({ backupId, planId, target, overwrite, includes, excludes, delete: deleteOption }),
+      body: JSON.stringify({ backupId, planId, target, overwrite, includes, excludes, delete: deleteOption, storageId, replicationId }),
    });
    const data = await res.json();
    if (!data.success) {

package/src/services/settings.ts

@@ -1,5 +1,6 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { API_URL } from '../utils/constants';
+import { useNavigate } from 'react-router';
 
 // ============== Settings API ==============
 
@@ -211,3 +212,92 @@ export function useCompleteSetup() {
       mutationFn: completeSetup,
    });
 }
+
+// Two-Factor Authentication (2FA) Setup and Verification
+
+export async function setupTwoFactorAuth(id: number) {
+   const headers = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
+   const res = await fetch(`${API_URL}/settings/${id}/2fa/setup`, {
+      method: 'POST',
+      headers,
+      credentials: 'include',
+   });
+   // Check if response is ok
+   if (!res.ok) {
+      const data = await res.json();
+      throw new Error(data.error);
+   }
+   const data = await res.json();
+   return data;
+}
+
+export function useSetupTwoFactorAuth() {
+   return useMutation({
+      mutationFn: setupTwoFactorAuth,
+      onSuccess: (res) => {
+         console.log('# 2FA setup data fetched successfully! :', res);
+      },
+      onError: (res) => {
+         console.log('# 2FA setup data fetch failed! :', res);
+      },
+   });
+}
+export async function verifyTwoFactorAuth({ code, id }: { code: string; id: number }) {
+   const headers = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
+   const res = await fetch(`${API_URL}/settings/${id}/2fa/finalize`, {
+      method: 'POST',
+      headers,
+      credentials: 'include',
+      body: JSON.stringify({ code }),
+   });
+   // Check if response is ok
+   if (!res.ok) {
+      const data = await res.json();
+      throw new Error(data.error);
+   }
+   const data = await res.json();
+   return data;
+}
+
+export function useVerifyTwoFactorAuth() {
+   return useMutation({
+      mutationFn: verifyTwoFactorAuth,
+      onSuccess: (res) => {
+         console.log('# 2FA verification successful! :', res);
+      },
+      onError: (res) => {
+         console.log('# 2FA verification failed! :', res);
+      },
+   });
+}
+
+export async function verifyTwoFactorOTP({ code }: { code: string }) {
+   const headers = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
+   const res = await fetch(`${API_URL}/user/verify-otp`, {
+      method: 'POST',
+      headers,
+      credentials: 'include',
+      body: JSON.stringify({ code }),
+   });
+   // Check if response is ok
+   if (!res.ok) {
+      const data = await res.json();
+      throw new Error(data.error);
+   }
+   const data = await res.json();
+   return data;
+}
+
+export function useVerifyTwoFactorOTP() {
+   const navigate = useNavigate();
+   return useMutation({
+      mutationFn: verifyTwoFactorOTP,
+      onSuccess: (res) => {
+         console.log('# 2FA verification successful! :', res);
+         navigate('/');
+      },
+      onError: (res) => {
+         console.log('# 2FA verification failed! :', res);
+      },
+   });
+}

package/src/services/users.ts

@@ -1,5 +1,5 @@
 import { API_URL } from '../utils/constants';
-import { useQuery, useMutation } from '@tanstack/react-query';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
 import { useNavigate } from 'react-router';
 
 interface LoginCredentials {
@@ -12,22 +12,28 @@ export type InstallType = 'docker' | 'binary' | 'dev';
 //VALIDATE USER
 export async function validateAuth() {
    const res = await fetch(`${API_URL}/user/validate`, { method: 'GET', credentials: 'include' });
-   if (!res.ok) {
-      throw new Error('Invalid authentication');
-   }
+
+   // Read headers before checking status - middleware sets these on all responses
    const appVersion = res.headers.get('x-app-version');
    const serverOS = res.headers.get('x-server-os');
    const installType = (res.headers.get('x-install-type') || 'dev') as InstallType;
+   const setupPending = res.headers.get('x-setup-pending') === '1';
 
    (window as any).plutonVersion = appVersion || 'unknown';
    (window as any).plutonServerOS = serverOS || 'unknown';
    (window as any).plutonInstallType = installType;
+   (window as any).plutonSetupPending = setupPending;
+
+   if (!res.ok) {
+      throw new Error('Invalid authentication');
+   }
 
    const data = await res.json();
    return {
       ...data,
       appVersion,
       installType,
+      setupPending,
    };
 }
 
@@ -59,10 +65,11 @@ export async function loginUser(credentials: LoginCredentials) {
 // Add this new hook
 export function useLogin() {
    const navigate = useNavigate();
+   const queryClient = useQueryClient();
    return useMutation({
       mutationFn: loginUser,
       onSuccess: (res) => {
-         console.log('res :', res);
+         queryClient.removeQueries({ queryKey: ['auth'] });
          if (res.totpRequired) {
             navigate('/login/verify-otp');
          } else {
@@ -87,9 +94,11 @@ export async function logoutUser() {
 
 export function useLogout() {
    const navigate = useNavigate();
+   const queryClient = useQueryClient();
    return useMutation({
       mutationFn: logoutUser,
       onSuccess: () => {
+         queryClient.removeQueries({ queryKey: ['auth'] });
          navigate('/login');
       },
    });

package/src/utils/progressHelpers.ts

@@ -25,6 +25,7 @@ export function generateBackupProgressMessage(progressData: BackupProgressData |
       'pre-backup': 'Pre-Backup',
       backup: 'Backup',
       'post-backup': 'Post-Backup',
+      replicating: 'Replicating',
       finished: 'Complete',
    };
 
@@ -72,7 +73,7 @@ const handleScriptAction = (action: string): string | null => {
 };
 
 // Function to extract numbers from action strings and create meaningful messages
-export const getBackupEventActionMessage = (action: string): string => {
+export const getBackupEventActionMessage = (action: string, storageName?: string): string => {
    // Handle script actions first
    const scriptMessage = handleScriptAction(action);
    if (scriptMessage) {
@@ -93,6 +94,20 @@ export const getBackupEventActionMessage = (action: string): string => {
       return `Scheduling Retry (${parseInt(current)}/${total})...`;
    }
 
+   // Handle replication retry scheduling
+   const replicationRetryScheduledMatch = action.match(/REPLICATION_RETRY_(\d+)_OF_(\d+)_SCHEDULED/);
+   if (replicationRetryScheduledMatch) {
+      const [, current, total] = replicationRetryScheduledMatch;
+      return `Retrying (${current}/${total})...`;
+   }
+
+   // Handle replication retry start
+   const replicationRetryStartMatch = action.match(/REPLICATION_RETRY_(\d+)_OF_(\d+)_START/);
+   if (replicationRetryStartMatch) {
+      const [, current, total] = replicationRetryStartMatch;
+      return `Retrying (${current}/${total})...`;
+   }
+
    // Static action mappings
    const staticMessages: Record<string, string> = {
       INITIALIZE: 'Starting Backup...',
@@ -134,8 +149,53 @@ export const getBackupEventActionMessage = (action: string): string => {
       ISO_UPLOAD_COMPLETE: 'ISO Upload Complete',
       ISO_UPLOAD_FAILED: 'ISO Upload Failed',
       BACKUP_WARNING: 'Hiccup Detected During Backup',
+      // Replication actions
+      REPLICATION_START: 'Replicating Snapshots...',
+      REPLICATION_INIT_START: 'Initializing Replication Repository...',
+      REPLICATION_INIT_COMPLETE: 'Replication Repository Initialized',
+      REPLICATION_INIT_FAILED: 'Replication Repository Init Failed',
+      REPLICATION_UNLOCK_START: 'Unlocking Replication Repository...',
+      REPLICATION_UNLOCK_COMPLETE: 'Replication Repository Unlocked',
+      REPLICATION_COPY_START: 'Copying Snapshot to Replication...',
+      REPLICATION_COPY_COMPLETE: 'Snapshot Copied to Replication',
+      REPLICATION_COPY_FAILED: 'Replication Copy Failed',
+      REPLICATION_PRUNE_START: 'Pruning Replication Repository...',
+      REPLICATION_PRUNE_COMPLETE: 'Replication Prune Complete',
+      REPLICATION_PRUNE_FAILED: 'Replication Prune Failed',
+      REPLICATION_STATS_START: 'Updating Replication Stats...',
+      REPLICATION_STATS_COMPLETE: 'Replication Stats Updated',
+      REPLICATION_COMPLETE: 'Replication Complete',
+      REPLICATION_FAILED: 'Replication Failed',
+      REPLICATION_PARTIAL_FAILURE: 'Some Replications Failed',
+      REPLICATION_MANUAL_RETRY_START: 'Retrying Failed Replications...',
+      REPLICATION_MANUAL_RETRY_COMPLETE: 'Replication Retry Complete',
+      REPLICATION_MANUAL_RETRY_PARTIAL_FAILURE: 'Some Replication Retries Still Failed',
    };
 
+   // Storage-name-aware replication action mappings
+   const replicationMessagesWithStorage: Record<string, (name: string) => string> = {
+      REPLICATION_START: (name) => `Replicating Snapshot to ${name}...`,
+      REPLICATION_INIT_START: (name) => `Initializing Replication Repository in ${name}...`,
+      REPLICATION_INIT_COMPLETE: (name) => `Replication Repository Initialized in ${name}`,
+      REPLICATION_INIT_FAILED: (name) => `Replication Repository Init Failed in ${name}`,
+      REPLICATION_UNLOCK_START: (name) => `Unlocking Replication Repository in ${name}...`,
+      REPLICATION_UNLOCK_COMPLETE: (name) => `Replication Repository Unlocked in ${name}`,
+      REPLICATION_COPY_START: (name) => `Copying Snapshot to ${name}...`,
+      REPLICATION_COPY_COMPLETE: (name) => `Snapshot Copied to ${name}`,
+      REPLICATION_COPY_FAILED: (name) => `Replication Copy Failed for ${name}`,
+      REPLICATION_PRUNE_START: (name) => `Pruning Replication Repository in ${name}...`,
+      REPLICATION_PRUNE_COMPLETE: (name) => `Replication Prune Complete for ${name}`,
+      REPLICATION_PRUNE_FAILED: (name) => `Replication Prune Failed for ${name}`,
+      REPLICATION_STATS_START: (name) => `Updating Replication Stats for ${name}...`,
+      REPLICATION_STATS_COMPLETE: (name) => `Replication Stats Updated for ${name}`,
+      REPLICATION_COMPLETE: (name) => `Replication Complete for ${name}`,
+      REPLICATION_FAILED: (name) => `Replication Failed for ${name}`,
+   };
+
+   if (storageName && replicationMessagesWithStorage[action]) {
+      return replicationMessagesWithStorage[action](storageName);
+   }
+
    return staticMessages[action] || action;
 };
 
@@ -242,3 +302,27 @@ export function extractResticData(progressData: BackupProgressData | null) {
 
    return eventWithResticData?.resticData || null;
 }
+
+/**
+ * Generates a human-readable progress message for a specific replication mirror.
+ * Uses the mirror's latest event action and includes the storage name.
+ */
+export function generateMirrorProgressMessage(mirror: { storageName: string; events?: { action: string; completed: boolean }[] }): string {
+   if (!mirror.events?.length) {
+      return 'Pending...';
+   }
+
+   // Find the last incomplete event or the most recent event
+   const lastIncompleteEvent = mirror.events
+      .slice()
+      .reverse()
+      .find((event) => !event.completed);
+
+   const currentEvent = lastIncompleteEvent || mirror.events[mirror.events.length - 1];
+
+   if (!currentEvent) {
+      return 'Pending...';
+   }
+
+   return getBackupEventActionMessage(currentEvent.action, mirror.storageName);
+}