@futo-org/backups-orchestrator-ui 0.1.71

package/dist/providers.js

@@ -0,0 +1,35 @@
+import * as yuccaApiClient from '@futo-org/backups-api-client';
+import * as orchestrationApiClient from './fetch-client';
+export class BaseProvider {
+}
+/* eslint-disable @typescript-eslint/require-await */
+export const yuccaApiProvider = yuccaApiClient;
+export const orchestrationApiProvider = orchestrationApiClient;
+export class MockProvider extends BaseProvider {
+    async getRepositories() {
+        return {
+            repositories: [
+                {
+                    id: 'repo1',
+                    name: 'My Repository',
+                    worm: false,
+                    metrics: {
+                        sizeBytes: 1337,
+                    },
+                },
+            ],
+        };
+    }
+}
+/* eslint-enable @typescript-eslint/require-await */
+const KEY = '__yucca_provider__';
+export const setProvider = (provider) => {
+    globalThis[KEY] = provider;
+};
+export const getProvider = () => {
+    const provider = globalThis[KEY];
+    if (!provider) {
+        throw new Error('Provider not set — call setProvider() before getProvider()');
+    }
+    return provider;
+};

package/dist/query-client.d.ts

@@ -0,0 +1,2 @@
+import { QueryClient } from '@tanstack/svelte-query';
+export declare const queryClient: QueryClient;

package/dist/query-client.js

@@ -0,0 +1,2 @@
+import { QueryClient } from '@tanstack/svelte-query';
+export const queryClient = new QueryClient();

package/dist/services/backend.service.d.ts

@@ -0,0 +1,18 @@
+import { SocketEvent } from '../events';
+import { type BackendDto, type CreateLocalBackendRequestDto } from '../fetch-client';
+import { type ActionItem } from '@immich/ui';
+export declare const backendKeys: {
+    all: readonly ["backends"];
+};
+export declare const useBackends: () => import("@tanstack/svelte-query").CreateQueryResult<BackendDto[], Error>;
+export declare const useBackendEventHandler: () => {
+    onBackendCreate(event: SocketEvent<{
+        backend: BackendDto;
+    }>): void;
+};
+export declare const handleYuccaLogin: (onCreate?: (backendId: string) => void) => Promise<void>;
+export declare const handleSetupLocalStorage: (onCreate?: (backendId: string) => void) => void;
+export declare const useCreateLocalBackend: () => import("@tanstack/svelte-query").CreateMutationResult<import("../fetch-client").BackendResponseDto, Error, CreateLocalBackendRequestDto, unknown>;
+export declare const getBackendActions: (backend: BackendDto) => {
+    LoginAgain: ActionItem;
+};

package/dist/services/backend.service.js

@@ -0,0 +1,61 @@
+import CreateLocalBackend from '../components/backends/CreateLocalBackend.svelte';
+import OAuthDeviceFlow from '../components/backends/OAuthDeviceFlow.svelte';
+import { SocketEvent } from '../events';
+import { createLocalBackend, getBackends, oidcDeviceFlow, } from '../fetch-client';
+import { queryClient } from '../query-client';
+import { handleError } from '../utils/handle-error';
+import { modalManager } from '@immich/ui';
+import { mdiLogin } from '@mdi/js';
+import { createMutation, createQuery } from '@tanstack/svelte-query';
+export const backendKeys = {
+    all: ['backends'],
+};
+export const useBackends = () => createQuery(() => ({
+    queryKey: backendKeys.all,
+    queryFn: () => getBackends().then(({ backends }) => backends),
+}), () => queryClient);
+export const useBackendEventHandler = () => {
+    return {
+        onBackendCreate(event) {
+            queryClient.setQueryData(backendKeys.all, (data) => {
+                return data
+                    ? [
+                        ...data.filter((entry) => entry.id !== event.data.backend.id),
+                        event.data.backend,
+                    ]
+                    : void 0;
+            });
+        },
+    };
+};
+export const handleYuccaLogin = async (onCreate) => {
+    try {
+        const response = await oidcDeviceFlow();
+        void modalManager.show(OAuthDeviceFlow, {
+            ...response,
+            onCreate,
+        });
+        window.open(response.verificationUri, '_blank');
+    }
+    catch (error) {
+        handleError(error, 'Failed to start login');
+        throw error;
+    }
+};
+export const handleSetupLocalStorage = (onCreate) => {
+    void modalManager.show(CreateLocalBackend, { onCreate });
+};
+export const useCreateLocalBackend = () => createMutation(() => ({
+    mutationFn: (dto) => createLocalBackend(dto),
+    onSuccess: () => void queryClient.invalidateQueries({ queryKey: backendKeys.all }),
+    onError: (error) => handleError(error, 'Failed to create local backend'),
+}), () => queryClient);
+export const getBackendActions = (backend) => {
+    const LoginAgain = {
+        icon: mdiLogin,
+        title: 'Login again',
+        onAction: () => void handleYuccaLogin(),
+        $if: () => backend.type === 'yucca' && !backend.isOnline,
+    };
+    return { LoginAgain };
+};

package/dist/services/filesystem.service.d.ts

@@ -0,0 +1,2 @@
+import { sdk } from '..';
+export declare const handleGetFileListing: (path?: string) => Promise<sdk.FilesystemListingResponseDto>;

package/dist/services/filesystem.service.js

@@ -0,0 +1,11 @@
+import { sdk } from '..';
+import { handleError } from '../utils/handle-error';
+export const handleGetFileListing = async (path) => {
+    try {
+        return await sdk.getFileListing({ path });
+    }
+    catch (error) {
+        handleError(error, 'Failed to load directory listing');
+        throw error;
+    }
+};

package/dist/services/immich.integration.service.d.ts

@@ -0,0 +1,6 @@
+import { type ActionItem } from '@immich/ui';
+export declare const getBackupPageActions: (repositoryId?: string) => {
+    Configure: ActionItem;
+    ViewRecoveryKey: ActionItem;
+    BackUpNow: ActionItem;
+};

package/dist/services/immich.integration.service.js

@@ -0,0 +1,24 @@
+import ImmichConfigureBackup from '../components/integrations/immich/ImmichConfigureBackup.svelte';
+import BackupsRecoveryKeyModal from '../components/onboarding/dialogs/BackupsRecoveryKeyModal.svelte';
+import { modalManager } from '@immich/ui';
+import { mdiCloudUploadOutline, mdiCogOutline, mdiKeyOutline } from '@mdi/js';
+import { handleCreateBackup } from './repository.service';
+export const getBackupPageActions = (repositoryId) => {
+    const Configure = {
+        title: 'Configure',
+        icon: mdiCogOutline,
+        onAction: () => modalManager.show(ImmichConfigureBackup, {}),
+    };
+    const ViewRecoveryKey = {
+        title: 'View recovery key',
+        icon: mdiKeyOutline,
+        onAction: () => void modalManager.show(BackupsRecoveryKeyModal, {}),
+    };
+    const BackUpNow = {
+        title: 'Back up now',
+        icon: mdiCloudUploadOutline,
+        onAction: () => void handleCreateBackup(repositoryId),
+        $if: () => typeof repositoryId === 'string',
+    };
+    return { Configure, ViewRecoveryKey, BackUpNow };
+};

package/dist/services/integrations.service.d.ts

@@ -0,0 +1,13 @@
+import { SocketEvent } from '../events';
+import { type ConfigureImmichIntegrationRequestDto, type IntegrationsResponseDto } from '../fetch-client';
+export declare const integrationsKeys: {
+    all: readonly ["integrations"];
+};
+export declare const useIntegrations: () => import("@tanstack/svelte-query").CreateQueryResult<IntegrationsResponseDto, Error>;
+export declare const useIntegrationEventHandler: () => {
+    onIntegrationUpdate(event: SocketEvent<{
+        integrations: IntegrationsResponseDto;
+    }>): void;
+};
+export declare const useConfigureImmichIntegration: () => import("@tanstack/svelte-query").CreateMutationResult<never, Error, ConfigureImmichIntegrationRequestDto, unknown>;
+export declare const useConfigureImmichDefaults: () => import("@tanstack/svelte-query").CreateMutationResult<void, Error, void, unknown>;

package/dist/services/integrations.service.js

@@ -0,0 +1,42 @@
+import { SocketEvent } from '../events';
+import { configureImmichIntegration, getIntegrations, } from '../fetch-client';
+import { queryClient } from '../query-client';
+import { handleError } from '../utils/handle-error';
+import { createMutation, createQuery } from '@tanstack/svelte-query';
+export const integrationsKeys = {
+    all: ['integrations'],
+};
+export const useIntegrations = () => createQuery(() => ({
+    queryKey: integrationsKeys.all,
+    queryFn: () => getIntegrations(),
+}), () => queryClient);
+export const useIntegrationEventHandler = () => ({
+    onIntegrationUpdate(event) {
+        queryClient.setQueryData(integrationsKeys.all, event.data.integrations);
+    },
+});
+export const useConfigureImmichIntegration = () => createMutation(() => ({
+    mutationFn: (dto) => configureImmichIntegration(dto),
+    onSuccess: () => void queryClient.invalidateQueries({ queryKey: integrationsKeys.all }),
+    onError: (error) => handleError(error, 'Failed to save backup settings'),
+}), () => queryClient);
+export const useConfigureImmichDefaults = () => createMutation(() => ({
+    mutationFn: async () => {
+        const { immichState } = await getIntegrations();
+        if (!immichState) {
+            throw new Error('No Immich instance detected.');
+        }
+        await configureImmichIntegration({
+            name: 'Immich',
+            worm: false,
+            cron: '0 3 * * *',
+            dataFolders: immichState.dataFolders,
+            backupConfiguration: true,
+            libraries: 'all',
+        });
+    },
+    onSuccess: () => {
+        void queryClient.invalidateQueries({ queryKey: integrationsKeys.all });
+    },
+    onError: (error) => handleError(error, 'Failed to create backup'),
+}), () => queryClient);

package/dist/services/log.service.svelte.d.ts

@@ -0,0 +1,53 @@
+type SummaryEvent = {
+    message_type: 'summary';
+    files_new?: number;
+    files_changed?: number;
+    files_unmodified?: number;
+    data_added?: number;
+    total_files_processed?: number;
+    total_bytes_processed?: number;
+    total_duration?: number;
+    snapshot_id?: string;
+    files_restored?: number;
+    files_skipped?: number;
+    files_deleted?: number;
+    total_files?: number;
+    bytes_restored?: number;
+    bytes_skipped?: number;
+    total_bytes?: number;
+    seconds_elapsed?: number;
+};
+type LogEvent = SummaryEvent | {
+    message_type: 'error';
+    error?: string | {
+        message: string;
+    };
+    message?: string;
+    during?: string;
+    item?: string;
+} | {
+    message_type: 'exit_error';
+    code: number;
+    message: string;
+} | {
+    message_type: 'raw';
+    message: string;
+} | {
+    message_type: 'status';
+    percent_done: number;
+    seconds_remaining?: number;
+    current_files?: string[];
+};
+export type LogStatus = {
+    progress: number;
+    text: string;
+    currentFiles: string[];
+};
+export declare function createLogObserver(logId: string): {
+    readonly status: LogStatus;
+    readonly errors: string[];
+    readonly events: LogEvent[];
+    readonly summary: SummaryEvent | undefined;
+    destroy(): void;
+};
+export {};

package/dist/services/log.service.svelte.js

@@ -0,0 +1,93 @@
+import { defaults } from '../fetch-client';
+import debounce from 'lodash.debounce';
+const formatErrorEvent = (event) => {
+    const text = (typeof event.error === 'string' ? event.error : event.error?.message) ??
+        event.message ??
+        'Unknown error';
+    const context = [event.during, event.item].filter(Boolean).join(' ');
+    return context ? `${context}: ${text}` : text;
+};
+export function createLogObserver(logId) {
+    const state = $state({
+        status: {
+            progress: 0,
+            text: '',
+            currentFiles: [],
+        },
+        errors: [],
+        events: [],
+        summary: undefined,
+    });
+    const buffer = [];
+    const flush = debounce(() => {
+        state.status = { ...state.status };
+        state.errors = [...state.errors];
+        state.events = buffer.slice();
+    }, 50, { maxWait: 100 });
+    const onEvent = (event) => {
+        if (event.message_type !== 'status') {
+            buffer.unshift(event);
+            buffer.splice(50);
+        }
+        switch (event.message_type) {
+            case 'status': {
+                state.status = {
+                    progress: event.percent_done,
+                    text: event.seconds_remaining
+                        ? `${event.seconds_remaining} seconds remaining`
+                        : '',
+                    currentFiles: event.current_files ?? [],
+                };
+                flush();
+                break;
+            }
+            case 'summary': {
+                state.summary = event;
+                state.status = {
+                    progress: 1,
+                    text: '',
+                    currentFiles: [],
+                };
+                flush();
+                flush.flush();
+                break;
+            }
+            case 'error': {
+                state.errors.push(formatErrorEvent(event));
+                flush();
+                flush.flush();
+                break;
+            }
+            case 'exit_error': {
+                state.errors.push(`restic exited with code ${event.code}: ${event.message}`);
+                flush();
+                flush.flush();
+                break;
+            }
+            default: {
+                flush();
+                break;
+            }
+        }
+    };
+    const source = new EventSource(new URL(`/api/yucca/logs/${logId}/stream`, defaults.baseUrl));
+    source.addEventListener('message', ({ data }) => onEvent(JSON.parse(data)));
+    return {
+        get status() {
+            return state.status;
+        },
+        get errors() {
+            return state.errors;
+        },
+        get events() {
+            return state.events;
+        },
+        get summary() {
+            return state.summary;
+        },
+        destroy() {
+            flush.cancel();
+            source.close();
+        },
+    };
+}

package/dist/services/metricsHistory.service.d.ts

@@ -0,0 +1,4 @@
+export declare const metricsHistoryKeys: {
+    byRepository: (repositoryId: string) => readonly ["metricsHistory", string];
+};
+export declare const useMetricsHistory: (repositoryId: string) => import("@tanstack/svelte-query").CreateInfiniteQueryResult<import("@tanstack/svelte-query").InfiniteData<import("@futo-org/backups-api-client").RepositoryMetricsHistoryListResponseDto, unknown>, Error>;

package/dist/services/metricsHistory.service.js

@@ -0,0 +1,12 @@
+import { listMetricsHistory } from '@futo-org/backups-api-client';
+import { createInfiniteQuery } from '@tanstack/svelte-query';
+import { queryClient } from '../query-client';
+export const metricsHistoryKeys = {
+    byRepository: (repositoryId) => ['metricsHistory', repositoryId],
+};
+export const useMetricsHistory = (repositoryId) => createInfiniteQuery(() => ({
+    queryKey: metricsHistoryKeys.byRepository(repositoryId),
+    queryFn: ({ pageParam }) => listMetricsHistory(repositoryId, { cursor: pageParam }),
+    initialPageParam: undefined,
+    getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,
+}), () => queryClient);

package/dist/services/onboarding.service.d.ts

@@ -0,0 +1,11 @@
+import { sdk } from '..';
+import type { ImportRecoveryKeyRequest } from '../fetch-client';
+export declare const recoveryKeyKeys: {
+    all: readonly ["recovery-key"];
+};
+export declare const useRecoveryKey: () => import("@tanstack/svelte-query").CreateQueryResult<sdk.CurrentRecoveryKeyResponse, Error>;
+export declare const handleOnboardingStatus: () => Promise<sdk.OnboardingStatusResponseDto>;
+export declare const handleCurrentRecoveryKey: () => Promise<sdk.CurrentRecoveryKeyResponse>;
+export declare const handleConfirmRecoveryKey: () => Promise<void>;
+export declare const handleImportRecoveryKey: (dto: ImportRecoveryKeyRequest) => Promise<void>;
+export declare const handleSkipOnboardingExtraConfig: () => Promise<void>;

package/dist/services/onboarding.service.js

@@ -0,0 +1,56 @@
+import { sdk } from '..';
+import { queryClient } from '../query-client';
+import { handleError } from '../utils/handle-error';
+import { createQuery } from '@tanstack/svelte-query';
+export const recoveryKeyKeys = {
+    all: ['recovery-key'],
+};
+export const useRecoveryKey = () => createQuery(() => ({
+    queryKey: recoveryKeyKeys.all,
+    queryFn: () => sdk.currentRecoveryKey(),
+}), () => queryClient);
+export const handleOnboardingStatus = async () => {
+    try {
+        return await sdk.onboardingStatus();
+    }
+    catch (error) {
+        handleError(error, 'Failed to load onboarding status');
+        throw error;
+    }
+};
+export const handleCurrentRecoveryKey = async () => {
+    try {
+        return await sdk.currentRecoveryKey();
+    }
+    catch (error) {
+        handleError(error, 'Failed to load recovery key');
+        throw error;
+    }
+};
+export const handleConfirmRecoveryKey = async () => {
+    try {
+        await sdk.confirmRecoveryKey();
+    }
+    catch (error) {
+        handleError(error, 'Failed to confirm recovery key');
+        throw error;
+    }
+};
+export const handleImportRecoveryKey = async (dto) => {
+    try {
+        await sdk.importRecoveryKey(dto);
+    }
+    catch (error) {
+        handleError(error, 'Failed to import recovery key');
+        throw error;
+    }
+};
+export const handleSkipOnboardingExtraConfig = async () => {
+    try {
+        await sdk.skipOnboardingExtraConfig();
+    }
+    catch (error) {
+        handleError(error, 'Failed to save preferences');
+        throw error;
+    }
+};

package/dist/services/repository.service.d.ts

@@ -0,0 +1,45 @@
+import { sdk } from '..';
+import { SocketEvent } from '../events';
+import { type InspectedLocalRepositoryDto, type LocalRepositoryDto, type RepositoryUpdateRequestDto } from '../fetch-client';
+import { type ActionItem } from '@immich/ui';
+export declare const repositoryKeys: {
+    all: readonly ["repositories"];
+    inspectAll: readonly ["repositories", "inspect"];
+};
+export declare const useRepositories: (initialData?: LocalRepositoryDto[]) => import("@tanstack/svelte-query").CreateQueryResult<sdk.LocalRepositoryDto[], Error>;
+export declare const useInspectRepositories: (initialData?: InspectedLocalRepositoryDto[]) => import("@tanstack/svelte-query").CreateQueryResult<sdk.InspectedLocalRepositoryDto[], Error>;
+export declare const useRepositoryEventHandler: () => {
+    onRepositoryCreate(event: SocketEvent<{
+        repository: LocalRepositoryDto;
+    }>): void;
+    onRepositoryUpdate(event: SocketEvent<{
+        repositoryId: string;
+        repository: Partial<LocalRepositoryDto>;
+    }>): void;
+    onRepositoryDelete(): void;
+};
+export declare const handleCheckImportRepository: (id: string, backendId: string) => Promise<sdk.RepositoryCheckImportResponseDto>;
+export declare const useCreateRepository: () => import("@tanstack/svelte-query").CreateMutationResult<sdk.RepositoryCreateResponseDto, Error, sdk.RepositoryCreateRequestDto, unknown>;
+export declare const useImportRepository: () => import("@tanstack/svelte-query").CreateMutationResult<sdk.RepositoryCreateResponseDto, Error, {
+    id: string;
+    backendId: string;
+}, unknown>;
+export declare const useUpdateRepository: () => import("@tanstack/svelte-query").CreateMutationResult<sdk.RepositoryUpdateResponseDto, Error, {
+    id: string;
+    dto: RepositoryUpdateRequestDto;
+    local?: boolean;
+}, unknown>;
+export declare const useRemoveRepository: () => import("@tanstack/svelte-query").CreateMutationResult<never, Error, {
+    id: string;
+    local?: boolean;
+}, unknown>;
+export declare const handleCreateBackup: (id: string) => Promise<sdk.LogResponseDto>;
+export declare const handlePruneRepository: (id: string) => Promise<sdk.LogResponseDto>;
+export declare const getRepositoryActions: (repository: LocalRepositoryDto) => {
+    BackupNow: ActionItem;
+    Snapshots: ActionItem;
+    History: ActionItem;
+    Configure: ActionItem;
+    Import: ActionItem;
+    MetricsHistory: ActionItem;
+};

package/dist/services/repository.service.js

@@ -0,0 +1,157 @@
+import { sdk } from '..';
+import ConfigureRepositoryModal from '../components/backups/dialogs/ConfigureRepositoryModal.svelte';
+import ImportRepositoryModal from '../components/backups/dialogs/ImportRepositoryModal.svelte';
+import ViewLogModal from '../components/backups/dialogs/ViewLogModal.svelte';
+import MetricsHistoryModal from '../components/backups/metrics-history/MetricsHistoryModal.svelte';
+import RunHistoryModal from '../components/backups/run-history/RunHistoryModal.svelte';
+import SnapshotsListModal from '../components/backups/snapshots-list/SnapshotsListModal.svelte';
+import { SocketEvent } from '../events';
+import { deleteRepository, inspectRepositories, updateRepository, } from '../fetch-client';
+import { getProvider } from '../providers';
+import { queryClient } from '../query-client';
+import { handleError } from '../utils/handle-error';
+import { modalManager, toastManager } from '@immich/ui';
+import { mdiCog, mdiFormatListBulletedType, mdiHistory, mdiImport, mdiListStatus, mdiPlay, } from '@mdi/js';
+import { createMutation, createQuery } from '@tanstack/svelte-query';
+export const repositoryKeys = {
+    all: ['repositories'],
+    inspectAll: ['repositories', 'inspect'],
+};
+export const useRepositories = (initialData) => createQuery(() => ({
+    queryKey: repositoryKeys.all,
+    queryFn: () => getProvider()
+        .getRepositories()
+        .then(({ repositories }) => repositories),
+    initialData,
+}), () => queryClient);
+export const useInspectRepositories = (initialData) => createQuery(() => ({
+    queryKey: repositoryKeys.inspectAll,
+    queryFn: () => inspectRepositories().then(({ repositories }) => repositories),
+    initialData,
+}), () => queryClient);
+export const useRepositoryEventHandler = () => {
+    return {
+        onRepositoryCreate(event) {
+            queryClient.setQueryData(repositoryKeys.all, (data) => {
+                return data
+                    ? [
+                        ...data.filter((entry) => entry.id !== event.data.repository.id),
+                        event.data.repository,
+                    ]
+                    : void 0;
+            });
+        },
+        onRepositoryUpdate(event) {
+            queryClient.setQueryData(repositoryKeys.all, (data) => {
+                return data
+                    ? data.map((entry) => entry.id === event.data.repositoryId
+                        ? { ...entry, ...event.data.repository }
+                        : entry)
+                    : void 0;
+            });
+        },
+        onRepositoryDelete() {
+            queryClient
+                .invalidateQueries({
+                queryKey: repositoryKeys.all,
+            })
+                .catch(() => void 0);
+        },
+    };
+};
+export const handleCheckImportRepository = async (id, backendId) => {
+    try {
+        return await sdk.checkImportRepository(id, backendId);
+    }
+    catch (error) {
+        handleError(error, 'Failed to check repository');
+        throw error;
+    }
+};
+export const useCreateRepository = () => createMutation(() => ({
+    mutationFn: (dto) => sdk.createRepository(dto),
+    onSuccess: () => void queryClient.invalidateQueries({ queryKey: repositoryKeys.all }),
+    onError: (error) => handleError(error, 'Failed to create repository'),
+}), () => queryClient);
+export const useImportRepository = () => createMutation(() => ({
+    mutationFn: ({ id, backendId }) => sdk.importRepository(id, backendId),
+    onSuccess: () => void queryClient.invalidateQueries({ queryKey: repositoryKeys.all }),
+    onError: (error) => handleError(error, 'Failed to import repository'),
+}), () => queryClient);
+export const useUpdateRepository = () => createMutation(() => ({
+    mutationFn: ({ id, dto, local = false, }) => (local ? sdk.updateRepository(id, dto) : updateRepository(id, dto)),
+    onSuccess: () => void queryClient.invalidateQueries({ queryKey: repositoryKeys.all }),
+    onError: (error) => handleError(error, 'Failed to update repository'),
+}), () => queryClient);
+export const useRemoveRepository = () => createMutation(() => ({
+    mutationFn: ({ id, local = false }) => local ? sdk.deleteRepository(id) : deleteRepository(id),
+    onSuccess: () => void queryClient.invalidateQueries({ queryKey: repositoryKeys.all }),
+    onError: (error) => handleError(error, 'Failed to delete repository'),
+}), () => queryClient);
+export const handleCreateBackup = async (id) => {
+    try {
+        toastManager.info('Started backup');
+        const response = await sdk.createBackup(id);
+        void modalManager.open(ViewLogModal, { logId: response.logId });
+        return response;
+    }
+    catch (error) {
+        handleError(error, 'Failed to start backup');
+        throw error;
+    }
+};
+export const handlePruneRepository = async (id) => {
+    try {
+        toastManager.info('Cleaning up old backups');
+        const response = await sdk.pruneRepository(id);
+        void modalManager.open(ViewLogModal, { logId: response.logId });
+        return response;
+    }
+    catch (error) {
+        handleError(error, 'Failed to start cleanup');
+        throw error;
+    }
+};
+export const getRepositoryActions = (repository) => {
+    const online = Boolean(repository.configuration && repository.backends?.primary.online);
+    const configured = Boolean(repository.configuration);
+    const BackupNow = {
+        title: 'Back up now',
+        icon: mdiPlay,
+        onAction: () => void handleCreateBackup(repository.id),
+        $if: () => online,
+    };
+    const Snapshots = {
+        title: 'Snapshots',
+        icon: mdiFormatListBulletedType,
+        onAction: () => void modalManager.open(SnapshotsListModal, { repository }),
+        $if: () => online,
+    };
+    const History = {
+        title: 'Logs',
+        icon: mdiListStatus,
+        onAction: () => void modalManager.open(RunHistoryModal, { repository }),
+        $if: () => configured,
+    };
+    const Configure = {
+        title: 'Configure',
+        icon: mdiCog,
+        onAction: () => void modalManager.open(ConfigureRepositoryModal, {
+            repository: { ...repository, configuration: repository.configuration },
+        }),
+        $if: () => configured,
+    };
+    const Import = {
+        title: 'Import',
+        icon: mdiImport,
+        onAction: () => void modalManager.open(ImportRepositoryModal, { repository }),
+        $if: () => Boolean(repository.backends && !repository.configuration),
+    };
+    const MetricsHistory = {
+        title: 'Metrics history',
+        icon: mdiHistory,
+        onAction: () => void modalManager.open(MetricsHistoryModal, { repository }),
+        $if: () => !repository.backends,
+    };
+    return { BackupNow, Snapshots, History, Configure, Import, MetricsHistory };
+};