Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
feat: volume browsing and backups (#1591)
Kyle Mendell4f0ea4a6868d
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.goindex 200fdd4b4..f1626e3f0 100644--- a/backend/internal/bootstrap/bootstrap.go+++ b/backend/internal/bootstrap/bootstrap.go@@ -56,6 +56,14 @@ func Bootstrap(ctx context.Context) error {if err != nil {return fmt.Errorf("failed to initialize services: %w", err)}+ defer func(ctx context.Context) {+ baseCtx := context.WithoutCancel(ctx)+ shutdownCtx, shutdownCancel := context.WithTimeout(baseCtx, 10*time.Second)+ defer shutdownCancel()+ if appServices.Volume != nil {+ appServices.Volume.CleanupHelperContainers(shutdownCtx)+ }+ }(appCtx)utils.LoadAgentToken(appCtx, cfg, appServices.Settings.GetStringSetting)utils.EnsureEncryptionKey(appCtx, cfg, appServices.Settings.EnsureEncryptionKey)diff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.goindex 821cbe65b..8cb7c6b15 100644--- a/backend/internal/bootstrap/services_bootstrap.go+++ b/backend/internal/bootstrap/services_bootstrap.go@@ -67,7 +67,7 @@ func initializeServices(ctx context.Context, db *database.DB, cfg *config.Configsvcs.Project = services.NewProjectService(db, svcs.Settings, svcs.Event, svcs.Image, svcs.Docker)svcs.Environment = services.NewEnvironmentService(db, httpClient, svcs.Docker, svcs.Event, svcs.Settings)svcs.Container = services.NewContainerService(db, svcs.Event, svcs.Docker, svcs.Image, svcs.Settings)- svcs.Volume = services.NewVolumeService(db, svcs.Docker, svcs.Event, svcs.Settings)+ svcs.Volume = services.NewVolumeService(db, svcs.Docker, svcs.Event, svcs.Settings, svcs.Container, svcs.Image, cfg.BackupVolumeName)svcs.Network = services.NewNetworkService(db, svcs.Docker, svcs.Event)svcs.Template = services.NewTemplateService(ctx, db, httpClient, svcs.Settings)svcs.Auth = services.NewAuthService(svcs.User, svcs.Settings, svcs.Event, cfg.JWTSecret, cfg)diff --git a/backend/internal/config/config.go b/backend/internal/config/config.goindex b66c3f7fd..86b321cec 100644--- a/backend/internal/config/config.go+++ b/backend/internal/config/config.go@@ -62,12 +62,13 @@ type Config struct {DirPerm os.FileMode `env:"DIR_PERM" default:"0755"`GitWorkDir string `env:"GIT_WORK_DIR" default:"data/git"`- DockerAPITimeout int `env:"DOCKER_API_TIMEOUT" default:"0"`- DockerImagePullTimeout int `env:"DOCKER_IMAGE_PULL_TIMEOUT" default:"0"`- GitOperationTimeout int `env:"GIT_OPERATION_TIMEOUT" default:"0"`- HTTPClientTimeout int `env:"HTTP_CLIENT_TIMEOUT" default:"0"`- RegistryTimeout int `env:"REGISTRY_TIMEOUT" default:"0"`- ProxyRequestTimeout int `env:"PROXY_REQUEST_TIMEOUT" default:"0"`+ DockerAPITimeout int `env:"DOCKER_API_TIMEOUT" default:"0"`+ DockerImagePullTimeout int `env:"DOCKER_IMAGE_PULL_TIMEOUT" default:"0"`+ GitOperationTimeout int `env:"GIT_OPERATION_TIMEOUT" default:"0"`+ HTTPClientTimeout int `env:"HTTP_CLIENT_TIMEOUT" default:"0"`+ RegistryTimeout int `env:"REGISTRY_TIMEOUT" default:"0"`+ ProxyRequestTimeout int `env:"PROXY_REQUEST_TIMEOUT" default:"0"`+ BackupVolumeName string `env:"ARCANE_BACKUP_VOLUME_NAME" default:"arcane-backups"`}func Load() *Config {diff --git a/backend/internal/huma/handlers/containers.go b/backend/internal/huma/handlers/containers.goindex b932080fa..7139290ca 100644--- a/backend/internal/huma/handlers/containers.go+++ b/backend/internal/huma/handlers/containers.go@@ -13,6 +13,7 @@ import (humamw "github.com/getarcaneapp/arcane/backend/internal/huma/middleware""github.com/getarcaneapp/arcane/backend/internal/services""github.com/getarcaneapp/arcane/backend/internal/utils/pagination"+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane""github.com/getarcaneapp/arcane/types/base"containertypes "github.com/getarcaneapp/arcane/types/container")@@ -31,12 +32,13 @@ type ContainerPaginatedResponse struct {}type ListContainersInput struct {- EnvironmentID string `path:"id" doc:"Environment ID"`- Search string `query:"search" doc:"Search query"`- Sort string `query:"sort" doc:"Column to sort by"`- Order string `query:"order" default:"asc" doc:"Sort direction"`- Start int `query:"start" default:"0" doc:"Start index"`- Limit int `query:"limit" default:"20" doc:"Limit"`+ EnvironmentID string `path:"id" doc:"Environment ID"`+ Search string `query:"search" doc:"Search query"`+ Sort string `query:"sort" doc:"Column to sort by"`+ Order string `query:"order" default:"asc" doc:"Sort direction"`+ Start int `query:"start" default:"0" doc:"Start index"`+ Limit int `query:"limit" default:"20" doc:"Limit"`+ IncludeInternal bool `query:"includeInternal" default:"false" doc:"Include internal containers"`}type ListContainersOutput struct {@@ -44,7 +46,8 @@ type ListContainersOutput struct {}type GetContainerStatusCountsInput struct {- EnvironmentID string `path:"id" doc:"Environment ID"`+ EnvironmentID string `path:"id" doc:"Environment ID"`+ IncludeInternal bool `query:"includeInternal" default:"false" doc:"Include internal containers"`}// ContainerStatusCountsResponse is a dedicated response type to avoid schema name collision@@ -211,7 +214,7 @@ func (h *ContainerHandler) ListContainers(ctx context.Context, input *ListContai},}- containers, paginationResp, counts, err := h.containerService.ListContainersPaginated(ctx, params, true)+ containers, paginationResp, counts, err := h.containerService.ListContainersPaginated(ctx, params, true, input.IncludeInternal)if err != nil {return nil, huma.Error500InternalServerError((&common.ContainerListError{Err: err}).Error())}@@ -237,11 +240,32 @@ func (h *ContainerHandler) GetContainerStatusCounts(ctx context.Context, input *return nil, huma.Error500InternalServerError("docker service not available")}- _, running, stopped, total, err := h.dockerService.GetAllContainers(ctx)+ containers, _, _, _, err := h.dockerService.GetAllContainers(ctx)if err != nil {return nil, huma.Error500InternalServerError((&common.ContainerStatusCountsError{Err: err}).Error())}+ if !input.IncludeInternal {+ filtered := make([]dockercontainer.Summary, 0, len(containers))+ for _, c := range containers {+ if libarcane.IsInternalContainer(c.Labels) {+ continue+ }+ filtered = append(filtered, c)+ }+ containers = filtered+ }++ running, stopped := 0, 0+ for _, c := range containers {+ if c.State == "running" {+ running+++ } else {+ stopped+++ }+ }+ total := len(containers)+return &GetContainerStatusCountsOutput{Body: ContainerStatusCountsResponse{Success: true,diff --git a/backend/internal/huma/handlers/settings.go b/backend/internal/huma/handlers/settings.goindex 1cf99a368..0f26051a1 100644--- a/backend/internal/huma/handlers/settings.go+++ b/backend/internal/huma/handlers/settings.go@@ -208,6 +208,15 @@ func (h *SettingsHandler) GetPublicSettings(ctx context.Context, input *GetPubliValue: strconv.FormatBool(uiConfigDisabled),Type: "boolean",})+ backupVolumeName := "arcane-backups"+ if h.cfg != nil && strings.TrimSpace(h.cfg.BackupVolumeName) != "" {+ backupVolumeName = h.cfg.BackupVolumeName+ }+ settingsDto = append(settingsDto, settings.PublicSetting{+ Key: "backupVolumeName",+ Value: backupVolumeName,+ Type: "string",+ })return &GetPublicSettingsOutput{Body: settingsDto}, nil}@@ -256,6 +265,15 @@ func (h *SettingsHandler) GetSettings(ctx context.Context, input *GetSettingsInpValue: strconv.FormatBool(uiConfigDisabled),Type: "boolean",})+ backupVolumeName := "arcane-backups"+ if h.cfg != nil && strings.TrimSpace(h.cfg.BackupVolumeName) != "" {+ backupVolumeName = h.cfg.BackupVolumeName+ }+ settingsDto = append(settingsDto, settings.PublicSetting{+ Key: "backupVolumeName",+ Value: backupVolumeName,+ Type: "string",+ })return &GetSettingsOutput{Body: settingsDto}, nil}diff --git a/backend/internal/huma/handlers/volumes.go b/backend/internal/huma/handlers/volumes.goindex a80f1a3fb..3eac3dbfc 100644--- a/backend/internal/huma/handlers/volumes.go+++ b/backend/internal/huma/handlers/volumes.go@@ -2,12 +2,15 @@ package handlersimport ("context"+ "io""net/http"+ "path""github.com/danielgtaylor/huma/v2""github.com/docker/docker/api/types/volume""github.com/getarcaneapp/arcane/backend/internal/common"humamw "github.com/getarcaneapp/arcane/backend/internal/huma/middleware"+ "github.com/getarcaneapp/arcane/backend/internal/models""github.com/getarcaneapp/arcane/backend/internal/services""github.com/getarcaneapp/arcane/backend/internal/utils/pagination""github.com/getarcaneapp/arcane/types/base"@@ -133,6 +136,173 @@ type GetVolumeSizesOutput struct {Body base.ApiResponse[[]VolumeSizeInfo]}+// --- Volume Browser & Backup ---++type BrowseDirectoryInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ Path string `query:"path" default:"/" doc:"Directory path to browse"`+}++type BrowseDirectoryOutput struct {+ Body base.ApiResponse[[]volumetypes.FileEntry]+}++type GetFileContentInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ Path string `query:"path" doc:"File path"`+ MaxBytes int64 `query:"maxBytes" default:"1048576" doc:"Maximum bytes to read (default 1MB)"`+}++type FileContentResponse struct {+ Content []byte `json:"content"`+ MimeType string `json:"mimeType"`+}++type GetFileContentOutput struct {+ Body base.ApiResponse[FileContentResponse]+}++type DownloadFileInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ Path string `query:"path" doc:"File path"`+}++type DownloadFileOutput struct {+ ContentType string `header:"Content-Type"`+ ContentDisposition string `header:"Content-Disposition"`+ ContentLength int64 `header:"Content-Length"`+ Body io.ReadCloser+}++type UploadFileInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ Path string `query:"path" default:"/" doc:"Destination path"`+ File huma.FormFile `form:"file" doc:"File to upload"`+}++type CreateDirectoryInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ Path string `query:"path" doc:"Directory path to create"`+}++type DeleteFileInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ Path string `query:"path" doc:"File or directory path to delete"`+}++type ListBackupsInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ Search string `query:"search" doc:"Search query"`+ Sort string `query:"sort" doc:"Column to sort by"`+ Order string `query:"order" default:"asc" doc:"Sort direction"`+ Start int `query:"start" default:"0" doc:"Start index"`+ Limit int `query:"limit" default:"20" doc:"Limit"`+}++type VolumeBackupPaginatedResponse struct {+ Success bool `json:"success"`+ Data []models.VolumeBackup `json:"data"`+ Pagination base.PaginationResponse `json:"pagination"`+ Warnings []string `json:"warnings,omitempty"`+}++type ListBackupsOutput struct {+ Body VolumeBackupPaginatedResponse+}++type CreateBackupInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+}++type CreateBackupOutput struct {+ Body base.ApiResponse[*models.VolumeBackup]+}++type RestoreBackupInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ BackupID string `path:"backupId" doc:"Backup ID"`+}++type RestoreBackupOutput struct {+ Body base.ApiResponse[base.MessageResponse]+}++type RestoreBackupFilesInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ BackupID string `path:"backupId" doc:"Backup ID"`+ Body struct {+ Paths []string `json:"paths" doc:"Paths to restore from backup"`+ }+}++type RestoreBackupFilesOutput struct {+ Body base.ApiResponse[base.MessageResponse]+}++type BackupHasPathInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ BackupID string `path:"backupId" doc:"Backup ID"`+ Path string `query:"path" doc:"Path to check"`+}++type BackupHasPathResponse struct {+ Exists bool `json:"exists"`+}++type BackupHasPathOutput struct {+ Body base.ApiResponse[BackupHasPathResponse]+}++type ListBackupFilesInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ BackupID string `path:"backupId" doc:"Backup ID"`+}++type ListBackupFilesOutput struct {+ Body base.ApiResponse[[]string]+}++type DeleteBackupInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ BackupID string `path:"backupId" doc:"Backup ID"`+}++type DeleteBackupOutput struct {+ Body base.ApiResponse[base.MessageResponse]+}++type DownloadBackupInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ BackupID string `path:"backupId" doc:"Backup ID"`+}++type DownloadBackupOutput struct {+ ContentType string `header:"Content-Type"`+ ContentDisposition string `header:"Content-Disposition"`+ ContentLength int64 `header:"Content-Length"`+ Body io.ReadCloser+}++type UploadAndRestoreInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ VolumeName string `path:"volumeName" doc:"Volume name"`+ File huma.FormFile `form:"file" doc:"Backup archive (tar.gz)"`+}++type UploadAndRestoreOutput struct {+ Body base.ApiResponse[base.MessageResponse]+}+// RegisterVolumes registers volume management routes using Huma.func RegisterVolumes(api huma.API, dockerService *services.DockerClientService, volumeService *services.VolumeService) {h := &VolumeHandler{@@ -243,6 +413,190 @@ func RegisterVolumes(api huma.API, dockerService *services.DockerClientService,{"ApiKeyAuth": {}},},}, h.GetVolumeSizes)++ // --- Volume Browsing Endpoints ---++ huma.Register(api, huma.Operation{+ OperationID: "browse-volume-directory",+ Method: http.MethodGet,+ Path: "/environments/{id}/volumes/{volumeName}/browse",+ Summary: "List volume directory",+ Tags: []string{"Volume Browser"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.BrowseDirectory)++ huma.Register(api, huma.Operation{+ OperationID: "get-volume-file-content",+ Method: http.MethodGet,+ Path: "/environments/{id}/volumes/{volumeName}/browse/content",+ Summary: "Get file content preview",+ Tags: []string{"Volume Browser"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.GetFileContent)++ huma.Register(api, huma.Operation{+ OperationID: "download-volume-file",+ Method: http.MethodGet,+ Path: "/environments/{id}/volumes/{volumeName}/browse/download",+ Summary: "Download file from volume",+ Tags: []string{"Volume Browser"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.DownloadFile)++ huma.Register(api, huma.Operation{+ OperationID: "upload-volume-file",+ Method: http.MethodPost,+ Path: "/environments/{id}/volumes/{volumeName}/browse/upload",+ Summary: "Upload file to volume",+ Tags: []string{"Volume Browser"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.UploadFile)++ huma.Register(api, huma.Operation{+ OperationID: "create-volume-directory",+ Method: http.MethodPost,+ Path: "/environments/{id}/volumes/{volumeName}/browse/mkdir",+ Summary: "Create directory in volume",+ Tags: []string{"Volume Browser"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.CreateDirectory)++ huma.Register(api, huma.Operation{+ OperationID: "delete-volume-file",+ Method: http.MethodDelete,+ Path: "/environments/{id}/volumes/{volumeName}/browse",+ Summary: "Delete file or directory in volume",+ Tags: []string{"Volume Browser"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.DeleteFile)++ // --- Volume Backup Endpoints ---++ huma.Register(api, huma.Operation{+ OperationID: "list-volume-backups",+ Method: http.MethodGet,+ Path: "/environments/{id}/volumes/{volumeName}/backups",+ Summary: "List volume backups",+ Tags: []string{"Volume Backup"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.ListBackups)++ huma.Register(api, huma.Operation{+ OperationID: "create-volume-backup",+ Method: http.MethodPost,+ Path: "/environments/{id}/volumes/{volumeName}/backups",+ Summary: "Create volume backup",+ Tags: []string{"Volume Backup"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.CreateBackup)++ huma.Register(api, huma.Operation{+ OperationID: "restore-volume-backup",+ Method: http.MethodPost,+ Path: "/environments/{id}/volumes/{volumeName}/backups/{backupId}/restore",+ Summary: "Restore volume backup",+ Tags: []string{"Volume Backup"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.RestoreBackup)++ huma.Register(api, huma.Operation{+ OperationID: "restore-volume-backup-files",+ Method: http.MethodPost,+ Path: "/environments/{id}/volumes/{volumeName}/backups/{backupId}/restore-files",+ Summary: "Restore specific files from a volume backup",+ Tags: []string{"Volume Backup"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.RestoreBackupFiles)++ huma.Register(api, huma.Operation{+ OperationID: "delete-volume-backup",+ Method: http.MethodDelete,+ Path: "/environments/{id}/volumes/backups/{backupId}",+ Summary: "Delete volume backup",+ Tags: []string{"Volume Backup"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.DeleteBackup)++ huma.Register(api, huma.Operation{+ OperationID: "download-volume-backup",+ Method: http.MethodGet,+ Path: "/environments/{id}/volumes/backups/{backupId}/download",+ Summary: "Download volume backup",+ Tags: []string{"Volume Backup"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.DownloadBackup)++ huma.Register(api, huma.Operation{+ OperationID: "backup-has-path",+ Method: http.MethodGet,+ Path: "/environments/{id}/volumes/backups/{backupId}/has-path",+ Summary: "Check if backup contains path",+ Tags: []string{"Volume Backup"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.BackupHasPath)++ huma.Register(api, huma.Operation{+ OperationID: "list-backup-files",+ Method: http.MethodGet,+ Path: "/environments/{id}/volumes/backups/{backupId}/files",+ Summary: "List files in a volume backup",+ Tags: []string{"Volume Backup"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.ListBackupFiles)++ huma.Register(api, huma.Operation{+ OperationID: "upload-volume-backup",+ Method: http.MethodPost,+ Path: "/environments/{id}/volumes/{volumeName}/backups/upload",+ Summary: "Upload and restore volume backup",+ Tags: []string{"Volume Backup"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ }, h.UploadAndRestore)}// ListVolumes returns a paginated list of volumes.@@ -474,3 +828,317 @@ func (h *VolumeHandler) GetVolumeSizes(ctx context.Context, input *GetVolumeSize},}, nil}++// --- Volume Browser Handler Methods ---++func (h *VolumeHandler) BrowseDirectory(ctx context.Context, input *BrowseDirectoryInput) (*BrowseDirectoryOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ entries, err := h.volumeService.ListDirectory(ctx, input.VolumeName, input.Path)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &BrowseDirectoryOutput{+ Body: base.ApiResponse[[]volumetypes.FileEntry]{+ Success: true,+ Data: entries,+ },+ }, nil+}++func (h *VolumeHandler) GetFileContent(ctx context.Context, input *GetFileContentInput) (*GetFileContentOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ content, mimeType, err := h.volumeService.GetFileContent(ctx, input.VolumeName, input.Path, input.MaxBytes)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &GetFileContentOutput{+ Body: base.ApiResponse[FileContentResponse]{+ Success: true,+ Data: FileContentResponse{+ Content: content,+ MimeType: mimeType,+ },+ },+ }, nil+}++func (h *VolumeHandler) DownloadFile(ctx context.Context, input *DownloadFileInput) (*DownloadFileOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ reader, size, err := h.volumeService.DownloadFile(ctx, input.VolumeName, input.Path)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &DownloadFileOutput{+ ContentType: "application/octet-stream",+ ContentDisposition: "attachment; filename=" + path.Base(input.Path),+ ContentLength: size,+ Body: reader,+ }, nil+}++func (h *VolumeHandler) UploadFile(ctx context.Context, input *UploadFileInput) (*base.ApiResponse[base.MessageResponse], error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, _ := humamw.GetCurrentUserFromContext(ctx)+ err := h.volumeService.UploadFile(ctx, input.VolumeName, input.Path, input.File, input.File.Filename, user)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &base.ApiResponse[base.MessageResponse]{+ Success: true,+ Data: base.MessageResponse{Message: "File uploaded successfully"},+ }, nil+}++func (h *VolumeHandler) CreateDirectory(ctx context.Context, input *CreateDirectoryInput) (*base.ApiResponse[base.MessageResponse], error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, _ := humamw.GetCurrentUserFromContext(ctx)+ err := h.volumeService.CreateDirectory(ctx, input.VolumeName, input.Path, user)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &base.ApiResponse[base.MessageResponse]{+ Success: true,+ Data: base.MessageResponse{Message: "Directory created successfully"},+ }, nil+}++func (h *VolumeHandler) DeleteFile(ctx context.Context, input *DeleteFileInput) (*base.ApiResponse[base.MessageResponse], error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, _ := humamw.GetCurrentUserFromContext(ctx)+ err := h.volumeService.DeleteFile(ctx, input.VolumeName, input.Path, user)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &base.ApiResponse[base.MessageResponse]{+ Success: true,+ Data: base.MessageResponse{Message: "Deleted successfully"},+ }, nil+}++// --- Volume Backup Handler Methods ---++func (h *VolumeHandler) ListBackups(ctx context.Context, input *ListBackupsInput) (*ListBackupsOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }++ params := pagination.QueryParams{+ SearchQuery: pagination.SearchQuery{+ Search: input.Search,+ },+ SortParams: pagination.SortParams{+ Sort: input.Sort,+ Order: pagination.SortOrder(input.Order),+ },+ PaginationParams: pagination.PaginationParams{+ Start: input.Start,+ Limit: input.Limit,+ },+ }++ if params.Limit == 0 {+ params.Limit = 20+ }++ backups, paginationResp, err := h.volumeService.ListBackupsPaginated(ctx, input.VolumeName, params)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }++ warning := h.volumeService.BackupMountWarning(ctx)++ return &ListBackupsOutput{+ Body: VolumeBackupPaginatedResponse{+ Success: true,+ Data: backups,+ Pagination: base.PaginationResponse{+ TotalPages: paginationResp.TotalPages,+ TotalItems: paginationResp.TotalItems,+ CurrentPage: paginationResp.CurrentPage,+ ItemsPerPage: paginationResp.ItemsPerPage,+ GrandTotalItems: paginationResp.GrandTotalItems,+ },+ Warnings: func() []string {+ if warning == "" {+ return nil+ }+ return []string{warning}+ }(),+ },+ }, nil+}++func (h *VolumeHandler) CreateBackup(ctx context.Context, input *CreateBackupInput) (*CreateBackupOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, exists := humamw.GetCurrentUserFromContext(ctx)+ if !exists {+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())+ }++ backup, err := h.volumeService.CreateBackup(ctx, input.VolumeName, *user)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &CreateBackupOutput{+ Body: base.ApiResponse[*models.VolumeBackup]{+ Success: true,+ Data: backup,+ },+ }, nil+}++func (h *VolumeHandler) RestoreBackup(ctx context.Context, input *RestoreBackupInput) (*RestoreBackupOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, exists := humamw.GetCurrentUserFromContext(ctx)+ if !exists {+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())+ }++ err := h.volumeService.RestoreBackup(ctx, input.VolumeName, input.BackupID, *user)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &RestoreBackupOutput{+ Body: base.ApiResponse[base.MessageResponse]{+ Success: true,+ Data: base.MessageResponse{Message: "Restore initiated successfully"},+ },+ }, nil+}++func (h *VolumeHandler) RestoreBackupFiles(ctx context.Context, input *RestoreBackupFilesInput) (*RestoreBackupFilesOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }++ user, exists := humamw.GetCurrentUserFromContext(ctx)+ if !exists {+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())+ }++ if len(input.Body.Paths) == 0 {+ return nil, huma.Error400BadRequest("paths are required")+ }++ if err := h.volumeService.RestoreBackupFiles(ctx, input.VolumeName, input.BackupID, input.Body.Paths, *user); err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }++ return &RestoreBackupFilesOutput{+ Body: base.ApiResponse[base.MessageResponse]{+ Success: true,+ Data: base.MessageResponse{Message: "Restore initiated successfully"},+ },+ }, nil+}++func (h *VolumeHandler) BackupHasPath(ctx context.Context, input *BackupHasPathInput) (*BackupHasPathOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }++ if input.Path == "" {+ return nil, huma.Error400BadRequest("path is required")+ }++ exists, err := h.volumeService.BackupHasPath(ctx, input.BackupID, input.Path)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }++ return &BackupHasPathOutput{+ Body: base.ApiResponse[BackupHasPathResponse]{+ Success: true,+ Data: BackupHasPathResponse{Exists: exists},+ },+ }, nil+}++func (h *VolumeHandler) ListBackupFiles(ctx context.Context, input *ListBackupFilesInput) (*ListBackupFilesOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }++ files, err := h.volumeService.ListBackupFiles(ctx, input.BackupID)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }++ return &ListBackupFilesOutput{+ Body: base.ApiResponse[[]string]{+ Success: true,+ Data: files,+ },+ }, nil+}++func (h *VolumeHandler) DeleteBackup(ctx context.Context, input *DeleteBackupInput) (*DeleteBackupOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, _ := humamw.GetCurrentUserFromContext(ctx)+ err := h.volumeService.DeleteBackup(ctx, input.BackupID, user)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &DeleteBackupOutput{+ Body: base.ApiResponse[base.MessageResponse]{+ Success: true,+ Data: base.MessageResponse{Message: "Backup deleted successfully"},+ },+ }, nil+}++func (h *VolumeHandler) DownloadBackup(ctx context.Context, input *DownloadBackupInput) (*DownloadBackupOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, _ := humamw.GetCurrentUserFromContext(ctx)+ reader, size, err := h.volumeService.DownloadBackup(ctx, input.BackupID, user)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &DownloadBackupOutput{+ ContentType: "application/x-gzip",+ ContentDisposition: "attachment; filename=" + input.BackupID + ".tar.gz",+ ContentLength: size,+ Body: reader,+ }, nil+}++func (h *VolumeHandler) UploadAndRestore(ctx context.Context, input *UploadAndRestoreInput) (*UploadAndRestoreOutput, error) {+ if h.volumeService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, exists := humamw.GetCurrentUserFromContext(ctx)+ if !exists {+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())+ }++ err := h.volumeService.UploadAndRestore(ctx, input.VolumeName, input.File, input.File.Filename, *user)+ if err != nil {+ return nil, huma.Error500InternalServerError(err.Error())+ }+ return &UploadAndRestoreOutput{+ Body: base.ApiResponse[base.MessageResponse]{+ Success: true,+ Data: base.MessageResponse{Message: "Backup uploaded and restored successfully"},+ },+ }, nil+}diff --git a/backend/internal/models/event.go b/backend/internal/models/event.goindex d2addbae2..a57574757 100644--- a/backend/internal/models/event.go+++ b/backend/internal/models/event.go@@ -48,6 +48,16 @@ const (EventTypeVolumeDelete EventType = "volume.delete"EventTypeVolumeError EventType = "volume.error"+ EventTypeVolumeFileCreate EventType = "volume.file.create"+ EventTypeVolumeFileDelete EventType = "volume.file.delete"+ EventTypeVolumeFileUpload EventType = "volume.file.upload"++ EventTypeVolumeBackupCreate EventType = "volume.backup.create"+ EventTypeVolumeBackupDelete EventType = "volume.backup.delete"+ EventTypeVolumeBackupRestore EventType = "volume.backup.restore"+ EventTypeVolumeBackupRestoreFiles EventType = "volume.backup.restore_files"+ EventTypeVolumeBackupDownload EventType = "volume.backup.download"+EventTypeNetworkCreate EventType = "network.create"EventTypeNetworkDelete EventType = "network.delete"EventTypeNetworkError EventType = "network.error"diff --git a/backend/internal/models/volume_backup.go b/backend/internal/models/volume_backup.gonew file mode 100644index 000000000..a4df4768a--- /dev/null+++ b/backend/internal/models/volume_backup.go@@ -0,0 +1,27 @@+package models++import (+ "time"++ "github.com/getarcaneapp/arcane/types/volume"+)++type VolumeBackup struct {+ BaseModel+ VolumeName string `json:"volumeName" gorm:"column:volume_name;index"`+ Size int64 `json:"size" gorm:"column:size"`+ CreatedAt time.Time `json:"createdAt" gorm:"column:created_at"`+}++func (*VolumeBackup) TableName() string {+ return "volume_backups"+}++func (b *VolumeBackup) ToDTO() volume.BackupEntry {+ return volume.BackupEntry{+ ID: b.ID,+ VolumeName: b.VolumeName,+ Size: b.Size,+ CreatedAt: b.CreatedAt.Format(time.RFC3339),+ }+}diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.goindex 67ced79b1..2d9332c1a 100644--- a/backend/internal/services/container_service.go+++ b/backend/internal/services/container_service.go@@ -18,6 +18,7 @@ import ("github.com/getarcaneapp/arcane/backend/internal/models""github.com/getarcaneapp/arcane/backend/internal/utils/pagination""github.com/getarcaneapp/arcane/backend/internal/utils/timeouts"+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"containertypes "github.com/getarcaneapp/arcane/types/container""github.com/getarcaneapp/arcane/types/containerregistry"imagetypes "github.com/getarcaneapp/arcane/types/image"@@ -424,7 +425,7 @@ func (s *ContainerService) readAllLogs(logs io.ReadCloser, logsChan chan<- strinreturn nil}-func (s *ContainerService) ListContainersPaginated(ctx context.Context, params pagination.QueryParams, includeAll bool) ([]containertypes.Summary, pagination.Response, containertypes.StatusCounts, error) {+func (s *ContainerService) ListContainersPaginated(ctx context.Context, params pagination.QueryParams, includeAll bool, includeInternal bool) ([]containertypes.Summary, pagination.Response, containertypes.StatusCounts, error) {dockerClient, err := s.dockerService.GetClient()if err != nil {return nil, pagination.Response{}, containertypes.StatusCounts{}, fmt.Errorf("failed to connect to Docker: %w", err)@@ -435,42 +436,77 @@ func (s *ContainerService) ListContainersPaginated(ctx context.Context, params preturn nil, pagination.Response{}, containertypes.StatusCounts{}, fmt.Errorf("failed to list Docker containers: %w", err)}- // Collect unique image IDs for update info lookup- imageIDSet := make(map[string]struct{}, len(dockerContainers))- for _, dc := range dockerContainers {+ dockerContainers = filterInternalContainers(dockerContainers, includeInternal)+ imageIDs := collectImageIDs(dockerContainers)+ updateInfoMap := s.getUpdateInfoMap(ctx, imageIDs)+ items := buildContainerSummaries(dockerContainers, updateInfoMap)++ result := pagination.SearchOrderAndPaginate(items, params, containerPaginationConfig())+ counts := computeContainerCounts(items)+ paginationResp := buildPaginationResponse(result, params)++ return result.Items, paginationResp, counts, nil+}++func filterInternalContainers(containers []container.Summary, includeInternal bool) []container.Summary {+ if includeInternal {+ return containers+ }++ filtered := make([]container.Summary, 0, len(containers))+ for _, dc := range containers {+ if libarcane.IsInternalContainer(dc.Labels) {+ continue+ }+ filtered = append(filtered, dc)+ }+ return filtered+}++func collectImageIDs(containers []container.Summary) []string {+ imageIDSet := make(map[string]struct{}, len(containers))+ for _, dc := range containers {if dc.ImageID != "" {imageIDSet[dc.ImageID] = struct{}{}}}+imageIDs := make([]string, 0, len(imageIDSet))for id := range imageIDSet {imageIDs = append(imageIDs, id)}+ return imageIDs+}- // Fetch update info for all images used by containers- var updateInfoMap map[string]*imagetypes.UpdateInfo- if s.imageService != nil && len(imageIDs) > 0 {- updateInfoMap, err = s.imageService.GetUpdateInfoByImageIDs(ctx, imageIDs)- if err != nil {- // Log error but continue - update info is optional- slog.WarnContext(ctx, "Failed to fetch image update info for containers", "error", err)- updateInfoMap = make(map[string]*imagetypes.UpdateInfo)- }- } else {- updateInfoMap = make(map[string]*imagetypes.UpdateInfo)+func (s *ContainerService) getUpdateInfoMap(ctx context.Context, imageIDs []string) map[string]*imagetypes.UpdateInfo {+ if s.imageService == nil || len(imageIDs) == 0 {+ return make(map[string]*imagetypes.UpdateInfo)+ }++ updateInfoMap, err := s.imageService.GetUpdateInfoByImageIDs(ctx, imageIDs)+ if err != nil {+ // Log error but continue - update info is optional+ slog.WarnContext(ctx, "Failed to fetch image update info for containers", "error", err)+ return make(map[string]*imagetypes.UpdateInfo)}- items := make([]containertypes.Summary, 0, len(dockerContainers))- for _, dc := range dockerContainers {+ return updateInfoMap+}++func buildContainerSummaries(containers []container.Summary, updateInfoMap map[string]*imagetypes.UpdateInfo) []containertypes.Summary {+ items := make([]containertypes.Summary, 0, len(containers))+ for _, dc := range containers {summary := containertypes.NewSummary(dc)- // Attach update info if availableif info, exists := updateInfoMap[dc.ImageID]; exists {summary.UpdateInfo = info}items = append(items, summary)}+ return items+}- config := pagination.Config[containertypes.Summary]{+func containerPaginationConfig() pagination.Config[containertypes.Summary] {+ return pagination.Config[containertypes.Summary]{SearchAccessors: []pagination.SearchAccessor[containertypes.Summary]{func(c containertypes.Summary) (string, error) {if len(c.Names) > 0 {@@ -529,10 +565,9 @@ func (s *ContainerService) ListContainersPaginated(ctx context.Context, params p},},}+}- result := pagination.SearchOrderAndPaginate(items, params, config)-- // Calculate status counts from items (before pagination)+func computeContainerCounts(items []containertypes.Summary) containertypes.StatusCounts {counts := containertypes.StatusCounts{TotalContainers: len(items),}@@ -543,10 +578,13 @@ func (s *ContainerService) ListContainersPaginated(ctx context.Context, params pcounts.StoppedContainers++}}+ return counts+}+func buildPaginationResponse(result pagination.FilterResult[containertypes.Summary], params pagination.QueryParams) pagination.Response {totalPages := int64(0)if params.Limit > 0 {- totalPages = (int64(result.TotalCount) + int64(params.Limit) - 1) / int64(params.Limit)+ totalPages = (result.TotalCount + int64(params.Limit) - 1) / int64(params.Limit)}page := 1@@ -554,15 +592,13 @@ func (s *ContainerService) ListContainersPaginated(ctx context.Context, params ppage = (params.Start / params.Limit) + 1}- paginationResp := pagination.Response{+ return pagination.Response{TotalPages: totalPages,- TotalItems: int64(result.TotalCount),+ TotalItems: result.TotalCount,CurrentPage: page,ItemsPerPage: params.Limit,- GrandTotalItems: int64(result.TotalAvailable),+ GrandTotalItems: result.TotalAvailable,}-- return result.Items, paginationResp, counts, nil}// CreateExec creates an exec instance in the containerdiff --git a/backend/internal/services/event_service.go b/backend/internal/services/event_service.goindex 22a7cbd6b..be2c680b6 100644--- a/backend/internal/services/event_service.go+++ b/backend/internal/services/event_service.go@@ -395,9 +395,17 @@ var eventDefinitions = map[models.EventType]struct {models.EventTypeProjectUpdate: {"Project updated: %s", "Project '%s' has been updated", models.EventSeverityInfo},models.EventTypeProjectError: {"Project error: %s", "An error occurred with project '%s'", models.EventSeverityError},- models.EventTypeVolumeCreate: {"Volume created: %s", "Volume '%s' has been created", models.EventSeveritySuccess},- models.EventTypeVolumeDelete: {"Volume deleted: %s", "Volume '%s' has been deleted", models.EventSeverityWarning},- models.EventTypeVolumeError: {"Volume error: %s", "An error occurred with volume '%s'", models.EventSeverityError},+ models.EventTypeVolumeCreate: {"Volume created: %s", "Volume '%s' has been created", models.EventSeveritySuccess},+ models.EventTypeVolumeDelete: {"Volume deleted: %s", "Volume '%s' has been deleted", models.EventSeverityWarning},+ models.EventTypeVolumeError: {"Volume error: %s", "An error occurred with volume '%s'", models.EventSeverityError},+ models.EventTypeVolumeFileCreate: {"Volume file created: %s", "A file or directory was created in volume '%s'", models.EventSeveritySuccess},+ models.EventTypeVolumeFileDelete: {"Volume file deleted: %s", "A file or directory was deleted in volume '%s'", models.EventSeverityWarning},+ models.EventTypeVolumeFileUpload: {"Volume file uploaded: %s", "A file was uploaded to volume '%s'", models.EventSeveritySuccess},+ models.EventTypeVolumeBackupCreate: {"Volume backup created: %s", "A backup was created for volume '%s'", models.EventSeveritySuccess},+ models.EventTypeVolumeBackupDelete: {"Volume backup deleted: %s", "A backup was deleted for volume '%s'", models.EventSeverityWarning},+ models.EventTypeVolumeBackupRestore: {"Volume backup restored: %s", "A backup was restored for volume '%s'", models.EventSeverityWarning},+ models.EventTypeVolumeBackupRestoreFiles: {"Volume backup files restored: %s", "Selected files were restored for volume '%s'", models.EventSeverityWarning},+ models.EventTypeVolumeBackupDownload: {"Volume backup downloaded: %s", "A backup was downloaded for volume '%s'", models.EventSeverityInfo},models.EventTypeNetworkCreate: {"Network created: %s", "Network '%s' has been created", models.EventSeveritySuccess},models.EventTypeNetworkDelete: {"Network deleted: %s", "Network '%s' has been deleted", models.EventSeverityWarning},diff --git a/backend/internal/services/job_service.go b/backend/internal/services/job_service.goindex 9bd155cfc..dc3e93feb 100644--- a/backend/internal/services/job_service.go+++ b/backend/internal/services/job_service.go@@ -68,37 +68,29 @@ func (s *JobService) UpdateJobSchedules(ctx context.Context, updates jobschedulecurrent := s.GetJobSchedules(ctx)+ fields := []struct {+ key string+ current string+ update *string+ }{+ {key: "environmentHealthInterval", current: current.EnvironmentHealthInterval, update: updates.EnvironmentHealthInterval},+ {key: "eventCleanupInterval", current: current.EventCleanupInterval, update: updates.EventCleanupInterval},+ {key: "analyticsHeartbeatInterval", current: current.AnalyticsHeartbeatInterval, update: updates.AnalyticsHeartbeatInterval},+ {key: "autoUpdateInterval", current: current.AutoUpdateInterval, update: updates.AutoUpdateInterval},+ {key: "pollingInterval", current: current.PollingInterval, update: updates.PollingInterval},+ {key: "scheduledPruneInterval", current: current.ScheduledPruneInterval, update: updates.ScheduledPruneInterval},+ {key: "gitopsSyncInterval", current: current.GitopsSyncInterval, update: updates.GitopsSyncInterval},+ }+// Validate inputs (cron expressions)- validate := func(name string, v *string) error {- if v == nil || *v == "" {- return nil+ parser := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow)+ for _, field := range fields {+ if field.update == nil || *field.update == "" {+ continue}- if _, err := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow).Parse(*v); err != nil {- return fmt.Errorf("invalid cron expression for %s: %w", name, err)+ if _, err := parser.Parse(*field.update); err != nil {+ return jobschedule.Config{}, fmt.Errorf("invalid cron expression for %s: %w", field.key, err)}- return nil- }-- if err := validate("environmentHealthInterval", updates.EnvironmentHealthInterval); err != nil {- return jobschedule.Config{}, err- }- if err := validate("eventCleanupInterval", updates.EventCleanupInterval); err != nil {- return jobschedule.Config{}, err- }- if err := validate("analyticsHeartbeatInterval", updates.AnalyticsHeartbeatInterval); err != nil {- return jobschedule.Config{}, err- }- if err := validate("autoUpdateInterval", updates.AutoUpdateInterval); err != nil {- return jobschedule.Config{}, err- }- if err := validate("pollingInterval", updates.PollingInterval); err != nil {- return jobschedule.Config{}, err- }- if err := validate("scheduledPruneInterval", updates.ScheduledPruneInterval); err != nil {- return jobschedule.Config{}, err- }- if err := validate("gitopsSyncInterval", updates.GitopsSyncInterval); err != nil {- return jobschedule.Config{}, err}changed := false@@ -116,26 +108,10 @@ func (s *JobService) UpdateJobSchedules(ctx context.Context, updates jobschedule}err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {- if err := upsert(tx, "environmentHealthInterval", updates.EnvironmentHealthInterval, current.EnvironmentHealthInterval); err != nil {- return err- }- if err := upsert(tx, "eventCleanupInterval", updates.EventCleanupInterval, current.EventCleanupInterval); err != nil {- return err- }- if err := upsert(tx, "analyticsHeartbeatInterval", updates.AnalyticsHeartbeatInterval, current.AnalyticsHeartbeatInterval); err != nil {- return err- }- if err := upsert(tx, "autoUpdateInterval", updates.AutoUpdateInterval, current.AutoUpdateInterval); err != nil {- return err- }- if err := upsert(tx, "pollingInterval", updates.PollingInterval, current.PollingInterval); err != nil {- return err- }- if err := upsert(tx, "scheduledPruneInterval", updates.ScheduledPruneInterval, current.ScheduledPruneInterval); err != nil {- return err- }- if err := upsert(tx, "gitopsSyncInterval", updates.GitopsSyncInterval, current.GitopsSyncInterval); err != nil {- return err+ for _, field := range fields {+ if err := upsert(tx, field.key, field.update, field.current); err != nil {+ return err+ }}return nil})diff --git a/backend/internal/services/volume_service.go b/backend/internal/services/volume_service.goindex 085b0f084..e9b33a12e 100644--- a/backend/internal/services/volume_service.go+++ b/backend/internal/services/volume_service.go@@ -1,183 +1,1470 @@package servicesimport (+ "archive/tar"+ "bytes"+ "compress/gzip""context""fmt"+ "io""log/slog"+ "net/http"+ "os"+ "path"+ "strconv""strings"+ "sync"+ "time""github.com/docker/docker/api/types/container""github.com/docker/docker/api/types/filters""github.com/docker/docker/api/types/mount""github.com/docker/docker/api/types/volume""github.com/docker/docker/client"+ "github.com/docker/docker/pkg/stdcopy""github.com/getarcaneapp/arcane/backend/internal/database""github.com/getarcaneapp/arcane/backend/internal/models""github.com/getarcaneapp/arcane/backend/internal/utils/docker""github.com/getarcaneapp/arcane/backend/internal/utils/pagination""github.com/getarcaneapp/arcane/backend/internal/utils/timeouts"+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"volumetypes "github.com/getarcaneapp/arcane/types/volume"+ "github.com/google/uuid")type VolumeService struct {- db *database.DB- dockerService *DockerClientService- eventService *EventService- settingsService *SettingsService+ db *database.DB+ dockerService *DockerClientService+ eventService *EventService+ settingsService *SettingsService+ containerService *ContainerService+ imageService *ImageService+ backupVolumeName string+ helperMu sync.Mutex+ helperByVolume map[string]string}-func NewVolumeService(db *database.DB, dockerService *DockerClientService, eventService *EventService, settingsService *SettingsService) *VolumeService {+func NewVolumeService(db *database.DB, dockerService *DockerClientService, eventService *EventService, settingsService *SettingsService, containerService *ContainerService, imageService *ImageService, backupVolumeName string) *VolumeService {+ slog.Debug("volume service: new")+ if strings.TrimSpace(backupVolumeName) == "" {+ backupVolumeName = "arcane-backups"+ }return &VolumeService{- db: db,- dockerService: dockerService,- eventService: eventService,- settingsService: settingsService,+ db: db,+ dockerService: dockerService,+ eventService: eventService,+ settingsService: settingsService,+ containerService: containerService,+ imageService: imageService,+ backupVolumeName: backupVolumeName,+ helperByVolume: make(map[string]string),+ }+}++func (s *VolumeService) GetVolumeByName(ctx context.Context, name string) (*volumetypes.Volume, error) {+ slog.DebugContext(ctx, "volume service: get volume", "volume", name)+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ }++ vol, err := dockerClient.VolumeInspect(ctx, name)+ if err != nil {+ return nil, fmt.Errorf("volume not found: %w", err)+ }++ if usageVolumes, duErr := docker.GetVolumeUsageData(ctx, dockerClient); duErr == nil {+ for _, uv := range usageVolumes {+ if uv.Name == vol.Name && uv.UsageData != nil {+ vol.UsageData = uv.UsageData+ slog.DebugContext(ctx, "attached volume usage data", "volume", vol.Name, "size_bytes", uv.UsageData.Size, "ref_count", uv.UsageData.RefCount)+ break+ }+ }+ } else {+ slog.WarnContext(ctx, "failed to load volume usage data", "volume", vol.Name, "error", duErr.Error())+ }++ v := volumetypes.NewSummary(vol)++ containerIDs, err := docker.GetContainersUsingVolume(ctx, dockerClient, name)+ if err != nil {+ slog.WarnContext(ctx, "failed to get containers using volume", "volume", name, "error", err.Error())+ } else {+ v.Containers = containerIDs+ if len(containerIDs) > 0 {+ v.InUse = true+ }+ }++ return &v, nil+}++func (s *VolumeService) CreateVolume(ctx context.Context, options volume.CreateOptions, user models.User) (*volumetypes.Volume, error) {+ slog.DebugContext(ctx, "volume service: create volume", "volume", options.Name, "driver", options.Driver, "user", user.ID)+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ }++ created, err := dockerClient.VolumeCreate(ctx, options)+ if err != nil {+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})+ return nil, fmt.Errorf("failed to create volume: %w", err)+ }++ vol, err := dockerClient.VolumeInspect(ctx, created.Name)+ if err != nil {+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", created.Name, created.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver, "step": "inspect"})+ return nil, fmt.Errorf("failed to inspect created volume: %w", err)+ }++ metadata := models.JSON{+ "action": "create",+ "driver": vol.Driver,+ "name": vol.Name,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeCreate, vol.Name, vol.Name, user.ID, user.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume creation action", "volume", vol.Name, "error", logErr.Error())+ }++ docker.InvalidateVolumeUsageCache()++ dtoVol := volumetypes.NewSummary(vol)+ return &dtoVol, nil+}++func (s *VolumeService) DeleteVolume(ctx context.Context, name string, force bool, user models.User) error {+ slog.DebugContext(ctx, "volume service: delete volume", "volume", name, "force", force, "user", user.ID)+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})+ return fmt.Errorf("failed to connect to Docker: %w", err)+ }++ if err := dockerClient.VolumeRemove(ctx, name, force); err != nil {+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})+ return fmt.Errorf("failed to remove volume: %w", err)+ }++ metadata := models.JSON{+ "action": "delete",+ "name": name,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, name, name, user.ID, user.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume deletion action", "volume", name, "error", logErr.Error())+ }++ s.removeHelperEntry(name)+ return nil+}++func (s *VolumeService) PruneVolumes(ctx context.Context) (*volumetypes.PruneReport, error) {+ slog.DebugContext(ctx, "volume service: prune volumes")+ return s.PruneVolumesWithOptions(ctx, false)+}++func (s *VolumeService) PruneVolumesWithOptions(ctx context.Context, all bool) (*volumetypes.PruneReport, error) {+ slog.DebugContext(ctx, "volume service: prune volumes with options", "all", all)+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ }++ // Docker's VolumesPrune behavior (API v1.42+):+ // - Without 'all' flag: Only removes anonymous (unnamed) volumes that are not in use+ // - With 'all=true' flag: Removes ALL unused volumes (both named and anonymous)+ // Note: Volumes are considered "in use" if referenced by any container (running or stopped)+ filterArgs := filters.NewArgs()+ if all {+ // The 'all' filter was added in Docker API v1.42+ // This tells Docker to prune ALL unused volumes, not just anonymous ones+ filterArgs.Add("all", "true")+ }+ // Other valid filters for volume prune:+ // - label=<key> or label=<key>=<value>+ // - label!=<key> or label!=<key>=<value>++ report, err := dockerClient.VolumesPrune(ctx, filterArgs)+ if err != nil {+ return nil, fmt.Errorf("failed to prune volumes: %w", err)+ }++ metadata := models.JSON{+ "action": "prune",+ "all": all,+ "volumesDeleted": len(report.VolumesDeleted),+ "spaceReclaimed": report.SpaceReclaimed,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, "", "bulk_prune", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume prune action", "error", logErr.Error())+ }++ for _, volumeName := range report.VolumesDeleted {+ s.removeHelperEntry(volumeName)+ }++ docker.InvalidateVolumeUsageCache()++ return &volumetypes.PruneReport{+ VolumesDeleted: report.VolumesDeleted,+ SpaceReclaimed: report.SpaceReclaimed,+ }, nil+}++// --- Volume Browsing & Backup ---++func (s *VolumeService) ListDirectory(ctx context.Context, volumeName, dirPath string) ([]volumetypes.FileEntry, error) {+ slog.DebugContext(ctx, "volume service: list directory", "volume", volumeName, "path", dirPath)++ sanitizedPath, err := s.sanitizeBrowsePathInternal(dirPath)+ if err != nil {+ return nil, fmt.Errorf("invalid path: %w", err)+ }++ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, true)+ if err != nil {+ return nil, err+ }+ defer cleanup()++ targetPath := path.Join("/volume", sanitizedPath)+ quotedPath := strconv.Quote(targetPath)+ cmd := []string{"sh", "-c", fmt.Sprintf("find %s -mindepth 1 -maxdepth 1 -exec sh -c 'for f; do out=$(stat -c \"%%s %%Y %%f %%A\" -- \"$f\" 2>/dev/null) || continue; printf \"%%s\\0%%s\\0\" \"$f\" \"$out\"; done' sh {} + || true", quotedPath)}+ stdout, _, err := s.execInContainerInternal(ctx, containerID, cmd)+ if err != nil {+ return nil, fmt.Errorf("failed to list directory: %w", err)+ }++ lines := strings.Split(stdout, "\x00")+ entries := make([]volumetypes.FileEntry, 0)+ for i := 0; i+1 < len(lines); i += 2 {+ fullPath := lines[i]+ meta := strings.Fields(strings.TrimSpace(lines[i+1]))+ if fullPath == "" || len(meta) < 4 {+ continue+ }+ name := path.Base(fullPath)+ size, _ := strconv.ParseInt(meta[0], 10, 64)+ modTimeSec, _ := strconv.ParseInt(meta[1], 10, 64)+ mode := meta[3]++ isDir := strings.HasPrefix(mode, "d")+ isSymlink := strings.HasPrefix(mode, "l")++ relPath := strings.TrimPrefix(fullPath, "/volume")+ if relPath == "" {+ relPath = "/"+ }++ entry := volumetypes.FileEntry{+ Name: name,+ Path: relPath,+ IsDirectory: isDir,+ Size: size,+ ModTime: time.Unix(modTimeSec, 0),+ Mode: mode,+ IsSymlink: isSymlink,+ }++ if isSymlink {+ // Use readlink without -f to get the raw symlink target (not resolved)+ // This prevents exposing paths outside the volume+ target, _, _ := s.execInContainerInternal(ctx, containerID, []string{"readlink", fullPath})+ target = strings.TrimSpace(target)+ if target != "" {+ // If target is relative, it's safe to show+ // If target is absolute and within /volume, strip the /volume prefix+ // If target points outside /volume, indicate it's external+ switch {+ case strings.HasPrefix(target, "/volume/"):+ entry.LinkTarget = strings.TrimPrefix(target, "/volume")+ case strings.HasPrefix(target, "/volume"):+ entry.LinkTarget = "/"+ case !strings.HasPrefix(target, "/"):+ // Relative path - safe to show as-is+ entry.LinkTarget = target+ default:+ // Absolute path outside /volume - indicate it's external+ entry.LinkTarget = "(external)"+ }+ }+ }++ entries = append(entries, entry)+ }++ return entries, nil+}++func (s *VolumeService) GetFileContent(ctx context.Context, volumeName, filePath string, maxBytes int64) ([]byte, string, error) {+ slog.DebugContext(ctx, "volume service: get file content", "volume", volumeName, "path", filePath, "max_bytes", maxBytes)++ sanitizedPath, err := s.sanitizeBrowsePathInternal(filePath)+ if err != nil {+ return nil, "", fmt.Errorf("invalid path: %w", err)+ }++ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, true)+ if err != nil {+ return nil, "", err+ }+ defer cleanup()++ targetPath := path.Join("/volume", sanitizedPath)+ cmd := []string{"head", "-c", strconv.FormatInt(maxBytes, 10), targetPath}+ stdout, _, err := s.execInContainerInternal(ctx, containerID, cmd)+ if err != nil {+ return nil, "", fmt.Errorf("failed to read file: %w", err)+ }++ content := []byte(stdout)+ mimeType := http.DetectContentType(content)++ return content, mimeType, nil+}++func (s *VolumeService) DownloadFile(ctx context.Context, volumeName, filePath string) (io.ReadCloser, int64, error) {+ slog.DebugContext(ctx, "volume service: download file", "volume", volumeName, "path", filePath)++ sanitizedPath, err := s.sanitizeBrowsePathInternal(filePath)+ if err != nil {+ return nil, 0, fmt.Errorf("invalid path: %w", err)+ }++ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return nil, 0, err+ }++ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, true)+ if err != nil {+ return nil, 0, err+ }++ targetPath := path.Join("/volume", sanitizedPath)+ reader, _, err := dockerClient.CopyFromContainer(ctx, containerID, targetPath)+ if err != nil {+ cleanup()+ return nil, 0, fmt.Errorf("failed to download: %w", err)+ }++ tr := tar.NewReader(reader)+ hdr, err := tr.Next()+ if err != nil {+ reader.Close()+ cleanup()+ return nil, 0, fmt.Errorf("failed to read tar stream: %w", err)+ }+ if hdr.FileInfo().IsDir() {+ reader.Close()+ cleanup()+ return nil, 0, fmt.Errorf("path is a directory")+ }+ size := hdr.Size++ return &cleanupReadCloser{+ Reader: tr,+ Closer: reader,+ cleanup: cleanup,+ }, size, nil+}++func (s *VolumeService) getHelperImageInternal(ctx context.Context) (string, error) {+ slog.DebugContext(ctx, "volume service: resolve helper image")+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return "", fmt.Errorf("failed to get docker client: %w", err)+ }++ // 1. Try to find Arcane container's image (the most prune-proof)+ // Check hostname first (ID of container if in Docker)+ hostname, _ := os.Hostname()+ if hostname != "" {+ if inspect, err := dockerClient.ContainerInspect(ctx, hostname); err == nil {+ return inspect.Config.Image, nil+ }+ }++ // 2. Search for any container with Arcane label+ filter := filters.NewArgs()+ filter.Add("label", "com.getarcaneapp.arcane=true")+ if containers, err := dockerClient.ContainerList(ctx, container.ListOptions{Filters: filter, All: true}); err == nil && len(containers) > 0 {+ return containers[0].Image, nil+ }++ // 3. Try busybox:stable-musl+ const helperImage = "busybox:stable-musl"+ if _, err := dockerClient.ImageInspect(ctx, helperImage); err == nil {+ return helperImage, nil+ }++ // 4. Default to pulling busybox+ slog.InfoContext(ctx, "no suitable internal image found, pulling busybox:stable-musl")+ if s.imageService == nil {+ return "", fmt.Errorf("helper image %s missing and image service unavailable", helperImage)+ }+ if err := s.imageService.PullImage(ctx, helperImage, io.Discard, systemUser, nil); err != nil {+ return "", fmt.Errorf("failed to pull helper image %s: %w", helperImage, err)+ }++ return helperImage, nil+}++func (s *VolumeService) BackupMountWarning(ctx context.Context) string {+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return ""+ }++ containerID := s.getArcaneContainerIDInternal(ctx, dockerClient)+ if containerID == "" {+ return ""+ }++ inspect, err := dockerClient.ContainerInspect(ctx, containerID)+ if err != nil {+ return ""+ }++ hasBackups := false+ hasRestores := false+ for _, mount := range inspect.Mounts {+ if mount.Destination == "/backups" {+ hasBackups = true+ }+ if mount.Destination == "/restores" {+ hasRestores = true+ }+ }++ if hasBackups || hasRestores {+ return ""+ }++ return "No volume is mounted at /backups or /restores in the Arcane container. Backups/restores will only live inside Docker unless you mount a host path."+}++func (s *VolumeService) getArcaneContainerIDInternal(ctx context.Context, dockerClient *client.Client) string {+ hostname, _ := os.Hostname()+ if hostname != "" {+ if inspect, err := dockerClient.ContainerInspect(ctx, hostname); err == nil {+ return inspect.ID+ }+ }++ filter := filters.NewArgs()+ filter.Add("label", "com.getarcaneapp.arcane=true")+ containers, err := dockerClient.ContainerList(ctx, container.ListOptions{Filters: filter, All: true})+ if err != nil || len(containers) == 0 {+ return ""+ }++ for _, c := range containers {+ if strings.EqualFold(strings.TrimSpace(c.State), "running") {+ return c.ID+ }+ }++ return containers[0].ID+}++type cleanupReadCloser struct {+ io.Reader+ io.Closer+ cleanup func()+}++func (c *cleanupReadCloser) Close() error {+ err := c.Closer.Close()+ c.cleanup()+ return err+}++func (s *VolumeService) createTempContainerInternal(ctx context.Context, volumeName string, readOnly bool) (string, func(), error) {+ slog.DebugContext(ctx, "volume service: create temp container", "volume", volumeName, "read_only", readOnly)+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return "", nil, err+ }++ if readOnly {+ if containerID, ok := s.getReusableReadOnlyContainerInternal(ctx, dockerClient, volumeName); ok {+ return containerID, func() {}, nil+ }+ }++ helperImage, err := s.getHelperImageInternal(ctx)+ if err != nil {+ return "", nil, err+ }++ config := &container.Config{+ Image: helperImage,+ Cmd: []string{"sleep", "infinity"},+ NetworkDisabled: true,+ Labels: map[string]string{+ libarcane.InternalContainerLabel: "true",+ },+ }++ hostConfig := &container.HostConfig{+ Binds: []string{+ fmt.Sprintf("%s:/volume%s", volumeName, func() string {+ if readOnly {+ return ":ro"+ }+ return ""+ }()),+ },+ AutoRemove: true,+ }++ resp, err := dockerClient.ContainerCreate(ctx, config, hostConfig, nil, nil, "")+ if err != nil {+ return "", nil, fmt.Errorf("failed to create temp container: %w", err)+ }++ if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})+ return "", nil, fmt.Errorf("failed to start temp container: %w", err)+ }++ cleanup := func() {+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})+ }++ if readOnly {+ s.helperMu.Lock()+ s.helperByVolume[volumeName] = resp.ID+ s.helperMu.Unlock()+ return resp.ID, func() {}, nil+ }++ return resp.ID, cleanup, nil+}++func (s *VolumeService) getReusableReadOnlyContainerInternal(ctx context.Context, dockerClient *client.Client, volumeName string) (string, bool) {+ s.helperMu.Lock()+ containerID := s.helperByVolume[volumeName]+ s.helperMu.Unlock()+ if containerID == "" {+ return "", false+ }++ inspect, err := dockerClient.ContainerInspect(ctx, containerID)+ if err != nil || inspect.State == nil || !inspect.State.Running {+ s.helperMu.Lock()+ delete(s.helperByVolume, volumeName)+ s.helperMu.Unlock()+ return "", false+ }++ return containerID, true+}++func (s *VolumeService) CleanupHelperContainers(ctx context.Context) {+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ slog.WarnContext(ctx, "failed to get docker client for helper cleanup", "error", err)+ return+ }++ s.helperMu.Lock()+ helperIDs := make([]string, 0, len(s.helperByVolume))+ for _, containerID := range s.helperByVolume {+ if containerID != "" {+ helperIDs = append(helperIDs, containerID)+ }+ }+ s.helperByVolume = make(map[string]string)+ s.helperMu.Unlock()++ for _, containerID := range helperIDs {+ if err := dockerClient.ContainerRemove(ctx, containerID, container.RemoveOptions{Force: true}); err != nil {+ slog.WarnContext(ctx, "failed to remove helper container", "container_id", containerID, "error", err.Error())+ }+ }+}++func (s *VolumeService) removeHelperEntry(volumeName string) {+ if strings.TrimSpace(volumeName) == "" {+ return+ }+ s.helperMu.Lock()+ delete(s.helperByVolume, volumeName)+ s.helperMu.Unlock()+}++func (s *VolumeService) execInContainerInternal(ctx context.Context, containerID string, cmd []string) (string, string, error) {+ slog.DebugContext(ctx, "volume service: exec in container", "container_id", containerID, "cmd", cmd)+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return "", "", err+ }++ execConfig := container.ExecOptions{+ AttachStdout: true,+ AttachStderr: true,+ Cmd: cmd,+ }++ execResp, err := dockerClient.ContainerExecCreate(ctx, containerID, execConfig)+ if err != nil {+ return "", "", err+ }++ resp, err := dockerClient.ContainerExecAttach(ctx, execResp.ID, container.ExecAttachOptions{})+ if err != nil {+ return "", "", err+ }+ defer resp.Close()++ var stdout, stderr bytes.Buffer+ _, err = stdcopy.StdCopy(&stdout, &stderr, resp.Reader)+ if err != nil {+ return "", "", err+ }++ return stdout.String(), stderr.String(), nil+}++func (s *VolumeService) DeleteFile(ctx context.Context, volumeName, filePath string, user *models.User) error {+ slog.DebugContext(ctx, "volume service: delete file", "volume", volumeName, "path", filePath)++ sanitizedPath, err := s.sanitizeBrowsePathInternal(filePath)+ if err != nil {+ return fmt.Errorf("invalid path: %w", err)+ }+ // Prevent deleting root+ if sanitizedPath == "/" {+ return fmt.Errorf("cannot delete root directory")+ }++ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, false)+ if err != nil {+ return err+ }+ defer cleanup()++ targetPath := path.Join("/volume", sanitizedPath)+ _, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"rm", "-rf", targetPath})+ if err != nil {+ return err+ }+ if stderr != "" {+ return fmt.Errorf("delete failed: %s", stderr)+ }++ actingUser := user+ if actingUser == nil {+ actingUser = &systemUser+ }+ metadata := models.JSON{+ "action": "file_delete",+ "path": filePath,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeFileDelete, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume file delete event", "volume", volumeName, "error", logErr.Error())+ }+ return nil+}++func (s *VolumeService) CreateDirectory(ctx context.Context, volumeName, dirPath string, user *models.User) error {+ slog.DebugContext(ctx, "volume service: create directory", "volume", volumeName, "path", dirPath)++ sanitizedPath, err := s.sanitizeBrowsePathInternal(dirPath)+ if err != nil {+ return fmt.Errorf("invalid path: %w", err)+ }++ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, false)+ if err != nil {+ return err+ }+ defer cleanup()++ targetPath := path.Join("/volume", sanitizedPath)+ _, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"mkdir", "-p", targetPath})+ if err != nil {+ return err+ }+ if stderr != "" {+ return fmt.Errorf("mkdir failed: %s", stderr)+ }++ actingUser := user+ if actingUser == nil {+ actingUser = &systemUser+ }+ metadata := models.JSON{+ "action": "file_create",+ "path": dirPath,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeFileCreate, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume file create event", "volume", volumeName, "error", logErr.Error())+ }+ return nil+}++func (s *VolumeService) UploadFile(ctx context.Context, volumeName, destPath string, content io.Reader, filename string, user *models.User) error {+ slog.DebugContext(ctx, "volume service: upload file", "volume", volumeName, "dest_path", destPath, "filename", filename)++ sanitizedPath, err := s.sanitizeBrowsePathInternal(destPath)+ if err != nil {+ return fmt.Errorf("invalid path: %w", err)+ }++ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return err+ }++ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, false)+ if err != nil {+ return err+ }+ defer cleanup()++ var buf bytes.Buffer+ tw := tar.NewWriter(&buf)++ contentBytes, err := io.ReadAll(content)+ if err != nil {+ return err+ }++ hdr := &tar.Header{+ Name: filename,+ Mode: 0644,+ Size: int64(len(contentBytes)),+ }+ if err := tw.WriteHeader(hdr); err != nil {+ return err+ }+ if _, err := tw.Write(contentBytes); err != nil {+ tw.Close()+ return err+ }+ tw.Close()++ targetDir := path.Join("/volume", sanitizedPath)+ err = dockerClient.CopyToContainer(ctx, containerID, targetDir, &buf, container.CopyToContainerOptions{})+ if err != nil {+ return fmt.Errorf("failed to upload: %w", err)+ }++ actingUser := user+ if actingUser == nil {+ actingUser = &systemUser+ }+ metadata := models.JSON{+ "action": "file_upload",+ "path": destPath,+ "filename": filename,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeFileUpload, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume file upload event", "volume", volumeName, "error", logErr.Error())+ }++ return nil+}++func (s *VolumeService) ensureBackupVolumeInternal(ctx context.Context) error {+ slog.DebugContext(ctx, "volume service: ensure backup volume", "backup_volume", s.backupVolumeName)+ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return err+ }++ _, err = dockerClient.VolumeInspect(ctx, s.backupVolumeName)+ if err != nil {+ _, err = dockerClient.VolumeCreate(ctx, volume.CreateOptions{+ Name: s.backupVolumeName,+ })+ if err != nil {+ return fmt.Errorf("failed to create backup volume: %w", err)+ }+ }+ return nil+}++func (s *VolumeService) CreateBackup(ctx context.Context, volumeName string, user models.User) (*models.VolumeBackup, error) {+ slog.DebugContext(ctx, "volume service: create backup", "volume", volumeName, "user", user.ID)+ if err := s.ensureBackupVolumeInternal(ctx); err != nil {+ return nil, err+ }++ dockerClient, err := s.dockerService.GetClient()+ if err != nil {+ return nil, err+ }++ backupID := fmt.Sprintf("%s-%d-%s", volumeName, time.Now().UnixNano(), uuid.NewString()[:8])+ filename := fmt.Sprintf("%s.tar.gz", backupID)++ helperImage, err := s.getHelperImageInternal(ctx)+ if err != nil {+ return nil, err+ }++ config := &container.Config{+ Image: helperImage,+ Cmd: []string{"sh", "-c", fmt.Sprintf("tar -czf /backups/%s -C /volume .", filename)},+ Labels: map[string]string{+ libarcane.InternalContainerLabel: "true",+ },+ }++ hostConfig := &container.HostConfig{+ Binds: []string{+ fmt.Sprintf("%s:/volume:ro", volumeName),+ fmt.Sprintf("%s:/backups", s.backupVolumeName),+ },+ AutoRemove: true,+ }++ resp, err := dockerClient.ContainerCreate(ctx, config, hostConfig, nil, nil, "")+ if err != nil {+ return nil, fmt.Errorf("failed to create backup container: %w", err)+ }++ if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {+ return nil, fmt.Errorf("failed to start backup container: %w", err)+ }++ statusCh, errCh := dockerClient.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)+ select {+ case err := <-errCh:+ if err != nil {+ return nil, err+ }+ case status := <-statusCh:+ if status.StatusCode != 0 {+ return nil, fmt.Errorf("backup container exited with status %d", status.StatusCode)+ }+ }++ tempContainerID, cleanup, err := s.createTempContainerInternal(ctx, s.backupVolumeName, true)+ if err != nil {+ return nil, err+ }+ defer cleanup()++ sizeStr, _, err := s.execInContainerInternal(ctx, tempContainerID, []string{"stat", "-c", "%s", path.Join("/volume", filename)})+ if err != nil {+ return nil, err+ }+ size, err := strconv.ParseInt(strings.TrimSpace(sizeStr), 10, 64)+ if err != nil {+ return nil, err+ }++ backup := &models.VolumeBackup{+ VolumeName: volumeName,+ Size: size,+ CreatedAt: time.Now(),+ }+ backup.ID = backupID++ if err := s.db.WithContext(ctx).Create(backup).Error; err != nil {+ return nil, err+ }++ metadata := models.JSON{+ "action": "backup_create",+ "backup_id": backup.ID,+ "filename": filename,+ "size": size,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupCreate, volumeName, volumeName, user.ID, user.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume backup create event", "volume", volumeName, "error", logErr.Error())+ }++ return backup, nil+}++func (s *VolumeService) ListBackupsPaginated(ctx context.Context, volumeName string, params pagination.QueryParams) ([]models.VolumeBackup, pagination.Response, error) {+ slog.DebugContext(ctx, "volume service: list backups paginated", "volume", volumeName, "search", params.Search, "sort", params.Sort, "order", params.Order, "start", params.Start, "limit", params.Limit)+ var backups []models.VolumeBackup+ query := s.db.WithContext(ctx).Model(&models.VolumeBackup{}).Where("volume_name = ?", volumeName)++ if params.Search != "" {+ query = query.Where("id LIKE ?", "%"+params.Search+"%")+ }++ var totalItems int64+ if err := query.Count(&totalItems).Error; err != nil {+ return nil, pagination.Response{}, err+ }++ sortCol := "created_at"+ sortOrder := "DESC"+ if params.Sort != "" {+ switch params.Sort {+ case "createdAt", "created_at":+ sortCol = "created_at"+ case "id":+ sortCol = "id"+ case "size":+ sortCol = "size"+ default:+ sortCol = "created_at"+ }++ if params.Order == pagination.SortDesc {+ sortOrder = "DESC"+ } else {+ sortOrder = "ASC"+ }+ }+ query = query.Order(fmt.Sprintf("%s %s", sortCol, sortOrder))++ if params.Limit > 0 {+ query = query.Offset(params.Start).Limit(params.Limit)+ }++ if err := query.Find(&backups).Error; err != nil {+ return nil, pagination.Response{}, err+ }++ paginationResp := s.buildPaginationResponseFromCountsInternal(totalItems, totalItems, params)+ return backups, paginationResp, nil+}++func (s *VolumeService) buildPaginationResponseFromCountsInternal(totalCount int64, totalAvailable int64, params pagination.QueryParams) pagination.Response {+ slog.Debug("volume service: build pagination response", "total_count", totalCount, "total_available", totalAvailable, "start", params.Start, "limit", params.Limit)+ totalPages := int64(0)+ if params.Limit > 0 {+ totalPages = (totalCount + int64(params.Limit) - 1) / int64(params.Limit)+ }++ page := 1+ if params.Limit > 0 {+ page = (params.Start / params.Limit) + 1+ }++ return pagination.Response{+ TotalPages: totalPages,+ TotalItems: totalCount,+ CurrentPage: page,+ ItemsPerPage: params.Limit,+ GrandTotalItems: totalAvailable,+ }+}++func (s *VolumeService) ListBackups(ctx context.Context, volumeName string) ([]models.VolumeBackup, error) {+ slog.DebugContext(ctx, "volume service: list backups", "volume", volumeName)+ var backups []models.VolumeBackup+ err := s.db.WithContext(ctx).Where("volume_name = ?", volumeName).Order("created_at DESC").Find(&backups).Error+ return backups, err+}++func (s *VolumeService) DeleteBackup(ctx context.Context, backupID string, user *models.User) error {+ slog.DebugContext(ctx, "volume service: delete backup", "backup_id", backupID)+ var backup models.VolumeBackup+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {+ return err+ }++ // Delete from DB first - if this fails, no changes are made.+ // If file deletion fails afterward, we just have an orphan file (easier to clean up)+ // rather than an orphan DB record pointing to a non-existent file.+ volumeName := backup.VolumeName // Save before deletion+ if err := s.db.WithContext(ctx).Delete(&backup).Error; err != nil {+ return err+ }++ // Now delete the actual file - best effort since DB record is already gone+ containerID, cleanup, err := s.createTempContainerInternal(ctx, s.backupVolumeName, false)+ if err != nil {+ slog.WarnContext(ctx, "failed to create container for backup file cleanup", "backup_id", backupID, "error", err.Error())+ } else {+ defer cleanup()+ filename := fmt.Sprintf("%s.tar.gz", backupID)+ if _, _, err = s.execInContainerInternal(ctx, containerID, []string{"rm", "-f", path.Join("/volume", filename)}); err != nil {+ slog.WarnContext(ctx, "failed to delete backup file (orphan file may remain)", "backup_id", backupID, "error", err.Error())+ }+ }++ actingUser := user+ if actingUser == nil {+ actingUser = &systemUser}+ metadata := models.JSON{+ "action": "backup_delete",+ "backup_id": backupID,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupDelete, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume backup delete event", "volume", volumeName, "error", logErr.Error())+ }++ return nil}-func (s *VolumeService) GetVolumeByName(ctx context.Context, name string) (*volumetypes.Volume, error) {+func (s *VolumeService) RestoreBackup(ctx context.Context, volumeName, backupID string, user models.User) error {+ slog.DebugContext(ctx, "volume service: restore backup", "volume", volumeName, "backup_id", backupID, "user", user.ID)+ var backup models.VolumeBackup+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {+ return err+ }++ // Validate backup belongs to volume+ if backup.VolumeName != volumeName {+ return fmt.Errorf("backup does not belong to volume %s", volumeName)+ }++ // Check if volume is in use by running containers+ inUse, containerIDs, err := s.GetVolumeUsage(ctx, volumeName)+ if err != nil {+ slog.WarnContext(ctx, "could not check volume usage", "volume", volumeName, "error", err.Error())+ } else if inUse {+ return fmt.Errorf("volume is in use by %d container(s): restoring while containers are running may cause data corruption. Stop the containers first or use selective file restore", len(containerIDs))+ }++ preBackup, err := s.CreateBackup(ctx, volumeName, user)+ if err != nil {+ return fmt.Errorf("failed to create pre-restore backup: %w", err)+ }+dockerClient, err := s.dockerService.GetClient()if err != nil {- return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ return err}- vol, err := dockerClient.VolumeInspect(ctx, name)+ filename := fmt.Sprintf("%s.tar.gz", backupID)++ helperImage, err := s.getHelperImageInternal(ctx)if err != nil {- return nil, fmt.Errorf("volume not found: %w", err)+ return err}- if usageVolumes, duErr := docker.GetVolumeUsageData(ctx, dockerClient); duErr == nil {- for _, uv := range usageVolumes {- if uv.Name == vol.Name && uv.UsageData != nil {- vol.UsageData = uv.UsageData- slog.DebugContext(ctx, "attached volume usage data", "volume", vol.Name, "size_bytes", uv.UsageData.Size, "ref_count", uv.UsageData.RefCount)- break- }- }- } else {- slog.WarnContext(ctx, "failed to load volume usage data", "volume", vol.Name, "error", duErr.Error())+ config := &container.Config{+ Image: helperImage,+ Cmd: []string{+ "sh",+ "-c",+ fmt.Sprintf("set -e; tmp=$(mktemp -d /volume/.restore_tmp.XXXXXX); tar -tzf /backups/%s >/dev/null; tar -xzf /backups/%s -C \"$tmp\"; find /volume -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +; find \"$tmp\" -mindepth 1 -maxdepth 1 -exec mv -- {} /volume/ \\;; rmdir \"$tmp\"", filename, filename),+ },+ Labels: map[string]string{+ libarcane.InternalContainerLabel: "true",+ },}- v := volumetypes.NewSummary(vol)+ hostConfig := &container.HostConfig{+ Binds: []string{+ fmt.Sprintf("%s:/volume", volumeName),+ fmt.Sprintf("%s:/backups:ro", s.backupVolumeName),+ },+ AutoRemove: true,+ }- containerIDs, err := docker.GetContainersUsingVolume(ctx, dockerClient, name)+ resp, err := dockerClient.ContainerCreate(ctx, config, hostConfig, nil, nil, "")if err != nil {- slog.WarnContext(ctx, "failed to get containers using volume", "volume", name, "error", err.Error())- } else {- v.Containers = containerIDs- if len(containerIDs) > 0 {- v.InUse = true+ return fmt.Errorf("failed to create restore container: %w", err)+ }++ if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {+ return fmt.Errorf("failed to start restore container: %w", err)+ }++ statusCh, errCh := dockerClient.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)+ var waitBody container.WaitResponse+ select {+ case err := <-errCh:+ if err != nil {+ return err}+ case waitBody = <-statusCh:}- return &v, nil+ if waitBody.StatusCode != 0 {+ return fmt.Errorf("restore container exited with code %d (volume may be partially wiped)", waitBody.StatusCode)+ }++ metadata := models.JSON{+ "action": "backup_restore",+ "backup_id": backupID,+ "pre_restore_backupId": preBackup.ID,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupRestore, volumeName, volumeName, user.ID, user.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume backup restore event", "volume", volumeName, "error", logErr.Error())+ }++ return nil}-func (s *VolumeService) CreateVolume(ctx context.Context, options volume.CreateOptions, user models.User) (*volumetypes.Volume, error) {- dockerClient, err := s.dockerService.GetClient()+func (s *VolumeService) sanitizeBackupPathInternal(input string) (string, error) {+ trimmed := strings.TrimSpace(input)+ if trimmed == "" {+ return "", fmt.Errorf("invalid path: empty")+ }+ cleaned := path.Clean(trimmed)+ if cleaned == "." || cleaned == "/" {+ return "", fmt.Errorf("invalid path: %s", input)+ }+ if path.IsAbs(cleaned) {+ cleaned = strings.TrimPrefix(cleaned, "/")+ }+ if cleaned == "" || cleaned == "." || cleaned == "/" || strings.HasPrefix(cleaned, "..") || strings.Contains(cleaned, "/../") {+ return "", fmt.Errorf("invalid path: %s", input)+ }+ return cleaned, nil+}++// sanitizeBrowsePath validates and cleans a path for file browser operations.+// It ensures the path stays within the volume boundary.+func (s *VolumeService) sanitizeBrowsePathInternal(input string) (string, error) {+ trimmed := strings.TrimSpace(input)+ if trimmed == "" || trimmed == "/" {+ return "/", nil // Root is valid for browse+ }+ cleaned := path.Clean(trimmed)+ // Ensure path starts with /+ if !path.IsAbs(cleaned) {+ cleaned = "/" + cleaned+ }+ // Check for path traversal attempts+ if strings.Contains(cleaned, "/../") || strings.HasSuffix(cleaned, "/..") || cleaned == "/.." {+ return "", fmt.Errorf("invalid path: path traversal not allowed")+ }+ // After cleaning, the path should not escape root+ if !strings.HasPrefix(cleaned, "/") {+ return "", fmt.Errorf("invalid path: must be absolute")+ }+ return cleaned, nil+}++func (s *VolumeService) BackupHasPath(ctx context.Context, backupID string, filePath string) (bool, error) {+ slog.DebugContext(ctx, "volume service: backup has path", "backup_id", backupID, "path", filePath)+ if err := s.ensureBackupVolumeInternal(ctx); err != nil {+ return false, err+ }++ cleaned, err := s.sanitizeBackupPathInternal(filePath)if err != nil {- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})- return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ return false, err}- created, err := dockerClient.VolumeCreate(ctx, options)+ var backup models.VolumeBackup+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {+ return false, err+ }++ containerID, cleanup, err := s.createTempContainerInternal(ctx, s.backupVolumeName, true)if err != nil {- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})- return nil, fmt.Errorf("failed to create volume: %w", err)+ return false, err}+ defer cleanup()- vol, err := dockerClient.VolumeInspect(ctx, created.Name)+ archivePath := path.Join("/volume", fmt.Sprintf("%s.tar.gz", backupID))+ cmd := []string{"tar", "-tzf", archivePath}+ stdout, stderr, err := s.execInContainerInternal(ctx, containerID, cmd)if err != nil {- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", created.Name, created.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver, "step": "inspect"})- return nil, fmt.Errorf("failed to inspect created volume: %w", err)+ return false, err+ }+ if strings.TrimSpace(stderr) != "" {+ return false, fmt.Errorf("failed to list backup contents: %s", strings.TrimSpace(stderr))}- metadata := models.JSON{- "action": "create",- "driver": vol.Driver,- "name": vol.Name,+ for _, line := range strings.Split(stdout, "\n") {+ entry := strings.TrimSpace(line)+ if entry == "" {+ continue+ }+ entry = strings.TrimPrefix(entry, "./")+ if entry == cleaned || strings.TrimSuffix(entry, "/") == cleaned {+ return true, nil+ }}- if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeCreate, vol.Name, vol.Name, user.ID, user.Username, "0", metadata); logErr != nil {- slog.WarnContext(ctx, "could not log volume creation action", "volume", vol.Name, "error", logErr.Error())++ return false, nil+}++func (s *VolumeService) ListBackupFiles(ctx context.Context, backupID string) ([]string, error) {+ slog.DebugContext(ctx, "volume service: list backup files", "backup_id", backupID)+ if err := s.ensureBackupVolumeInternal(ctx); err != nil {+ return nil, err}- docker.InvalidateVolumeUsageCache()+ var backup models.VolumeBackup+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {+ return nil, err+ }- dtoVol := volumetypes.NewSummary(vol)- return &dtoVol, nil+ containerID, cleanup, err := s.createTempContainerInternal(ctx, s.backupVolumeName, true)+ if err != nil {+ return nil, err+ }+ defer cleanup()++ archivePath := path.Join("/volume", fmt.Sprintf("%s.tar.gz", backupID))+ cmd := []string{"tar", "-tzf", archivePath}+ stdout, _, err := s.execInContainerInternal(ctx, containerID, cmd)+ if err != nil {+ return nil, err+ }++ lines := strings.Split(strings.TrimSpace(stdout), "\n")+ files := make([]string, 0, len(lines))+ seen := make(map[string]struct{})+ for _, line := range lines {+ clean := strings.TrimSpace(line)+ if clean == "" {+ continue+ }+ clean = strings.TrimPrefix(clean, "./")+ if strings.HasSuffix(clean, "/") {+ continue+ }+ if _, ok := seen[clean]; ok {+ continue+ }+ seen[clean] = struct{}{}+ files = append(files, clean)+ }++ return files, nil}-func (s *VolumeService) DeleteVolume(ctx context.Context, name string, force bool, user models.User) error {+func (s *VolumeService) RestoreBackupFiles(ctx context.Context, volumeName, backupID string, paths []string, user models.User) error {+ slog.DebugContext(ctx, "volume service: restore backup files", "volume", volumeName, "backup_id", backupID, "paths_count", len(paths), "user", user.ID)+ if len(paths) == 0 {+ return fmt.Errorf("no paths provided")+ }++ var backup models.VolumeBackup+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {+ return err+ }+ if backup.VolumeName != volumeName {+ return fmt.Errorf("backup does not belong to volume")+ }++ // Create pre-restore backup for safety (consistent with RestoreBackup behavior)+ preBackup, err := s.CreateBackup(ctx, volumeName, user)+ if err != nil {+ return fmt.Errorf("failed to create pre-restore backup: %w", err)+ }+ slog.DebugContext(ctx, "created pre-restore backup", "volume", volumeName, "pre_backup_id", preBackup.ID)++ cleanedPaths := make([]string, 0, len(paths))+ for _, p := range paths {+ cleaned, err := s.sanitizeBackupPathInternal(p)+ if err != nil {+ return err+ }+ cleanedPaths = append(cleanedPaths, cleaned)+ }+ if len(cleanedPaths) == 0 {+ return fmt.Errorf("no valid paths provided")+ }++ tarPaths := make([]string, 0, len(cleanedPaths))+ for _, p := range cleanedPaths {+ tarPaths = append(tarPaths, "./"+p)+ }+dockerClient, err := s.dockerService.GetClient()if err != nil {- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})- return fmt.Errorf("failed to connect to Docker: %w", err)+ return err}- if err := dockerClient.VolumeRemove(ctx, name, force); err != nil {- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})- return fmt.Errorf("failed to remove volume: %w", err)+ helperImage, err := s.getHelperImageInternal(ctx)+ if err != nil {+ return err+ }++ config := &container.Config{+ Image: helperImage,+ Cmd: []string{"sleep", "infinity"},+ NetworkDisabled: true,+ Labels: map[string]string{+ libarcane.InternalContainerLabel: "true",+ },+ }++ hostConfig := &container.HostConfig{+ Binds: []string{+ fmt.Sprintf("%s:/volume", volumeName),+ fmt.Sprintf("%s:/backups:ro", s.backupVolumeName),+ },+ AutoRemove: true,+ }++ resp, err := dockerClient.ContainerCreate(ctx, config, hostConfig, nil, nil, "")+ if err != nil {+ return fmt.Errorf("failed to create restore container: %w", err)+ }++ if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})+ return fmt.Errorf("failed to start restore container: %w", err)+ }++ cleanup := func() {+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})+ }+ defer cleanup()++ filename := fmt.Sprintf("%s.tar.gz", backupID)+ cmd := append([]string{"tar", "-xzf", path.Join("/backups", filename), "-C", "/volume", "--"}, tarPaths...)+ _, stderr, err := s.execInContainerInternal(ctx, resp.ID, cmd)+ if err != nil {+ return fmt.Errorf("failed to restore files: %w", err)+ }+ if strings.TrimSpace(stderr) != "" {+ slog.DebugContext(ctx, "volume service: restore files stderr", "backup_id", backupID, "stderr", strings.TrimSpace(stderr))}metadata := models.JSON{- "action": "delete",- "name": name,+ "action": "backup_restore_files",+ "backup_id": backupID,+ "pre_restore_backupId": preBackup.ID,+ "paths_count": len(cleanedPaths),}- if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, name, name, user.ID, user.Username, "0", metadata); logErr != nil {- slog.WarnContext(ctx, "could not log volume deletion action", "volume", name, "error", logErr.Error())+ if len(cleanedPaths) > 0 {+ limit := min(len(cleanedPaths), 5)+ metadata["paths_sample"] = cleanedPaths[:limit]+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupRestoreFiles, volumeName, volumeName, user.ID, user.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume backup restore files event", "volume", volumeName, "error", logErr.Error())}return nil}-func (s *VolumeService) PruneVolumes(ctx context.Context) (*volumetypes.PruneReport, error) {- return s.PruneVolumesWithOptions(ctx, false)+func (s *VolumeService) DownloadBackup(ctx context.Context, backupID string, user *models.User) (io.ReadCloser, int64, error) {+ slog.DebugContext(ctx, "volume service: download backup", "backup_id", backupID)+ filename := fmt.Sprintf("%s.tar.gz", backupID)+ reader, size, err := s.DownloadFile(ctx, s.backupVolumeName, filename)+ if err != nil {+ return nil, 0, err+ }++ actingUser := user+ if actingUser == nil {+ actingUser = &systemUser+ }+ volumeName := ""+ var backup models.VolumeBackup+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err == nil {+ volumeName = backup.VolumeName+ }+ if volumeName != "" {+ metadata := models.JSON{+ "action": "backup_download",+ "backup_id": backupID,+ "size": size,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupDownload, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume backup download event", "volume", volumeName, "error", logErr.Error())+ }+ }++ return reader, size, nil}-func (s *VolumeService) PruneVolumesWithOptions(ctx context.Context, all bool) (*volumetypes.PruneReport, error) {+func (s *VolumeService) UploadAndRestore(ctx context.Context, volumeName string, archive io.Reader, filename string, user models.User) error {+ slog.DebugContext(ctx, "volume service: upload and restore", "volume", volumeName, "filename", filename, "user", user.ID)++ tmpFile, err := os.CreateTemp("", "arcane-restore-*.tar.gz")+ if err != nil {+ return fmt.Errorf("failed to buffer upload: %w", err)+ }+ defer func() {+ _ = tmpFile.Close()+ _ = os.Remove(tmpFile.Name())+ }()+ if _, err := io.Copy(tmpFile, archive); err != nil {+ return fmt.Errorf("failed to buffer upload: %w", err)+ }+ if _, err := tmpFile.Seek(0, io.SeekStart); err != nil {+ return fmt.Errorf("failed to read buffered upload: %w", err)+ }+ gzr, err := gzip.NewReader(tmpFile)+ if err != nil {+ return fmt.Errorf("invalid archive: %w", err)+ }+ if _, err := tar.NewReader(gzr).Next(); err != nil {+ _ = gzr.Close()+ return fmt.Errorf("invalid archive: %w", err)+ }+ _ = gzr.Close()++ preBackup, err := s.CreateBackup(ctx, volumeName, user)+ if err != nil {+ return fmt.Errorf("failed to create pre-restore backup: %w", err)+ }+dockerClient, err := s.dockerService.GetClient()if err != nil {- return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ return err}- // Docker's VolumesPrune behavior (API v1.42+):- // - Without 'all' flag: Only removes anonymous (unnamed) volumes that are not in use- // - With 'all=true' flag: Removes ALL unused volumes (both named and anonymous)- // Note: Volumes are considered "in use" if referenced by any container (running or stopped)- filterArgs := filters.NewArgs()- if all {- // The 'all' filter was added in Docker API v1.42- // This tells Docker to prune ALL unused volumes, not just anonymous ones- filterArgs.Add("all", "true")+ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, false)+ if err != nil {+ return err}- // Other valid filters for volume prune:- // - label=<key> or label=<key>=<value>- // - label!=<key> or label!=<key>=<value>+ defer cleanup()- report, err := dockerClient.VolumesPrune(ctx, filterArgs)+ tmpDir := fmt.Sprintf("/volume/.restore_tmp_%d", time.Now().UnixNano())+ _, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"mkdir", "-p", tmpDir})if err != nil {- return nil, fmt.Errorf("failed to prune volumes: %w", err)+ return fmt.Errorf("failed to create temp restore dir: %w", err)+ }+ if strings.TrimSpace(stderr) != "" {+ slog.DebugContext(ctx, "volume service: restore temp dir stderr", "volume", volumeName, "stderr", strings.TrimSpace(stderr))}- metadata := models.JSON{- "action": "prune",- "all": all,- "volumesDeleted": len(report.VolumesDeleted),- "spaceReclaimed": report.SpaceReclaimed,+ if _, err := tmpFile.Seek(0, io.SeekStart); err != nil {+ return fmt.Errorf("failed to read buffered upload: %w", err)}- if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, "", "bulk_prune", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {- slog.WarnContext(ctx, "could not log volume prune action", "error", logErr.Error())+ err = dockerClient.CopyToContainer(ctx, containerID, tmpDir, tmpFile, container.CopyToContainerOptions{})+ if err != nil {+ return fmt.Errorf("failed to restore from uploaded archive: %w", err)}- docker.InvalidateVolumeUsageCache()+ _, stderr, err = s.execInContainerInternal(ctx, containerID, []string{"sh", "-c", fmt.Sprintf("test -n \"$(find %s -mindepth 1 -maxdepth 1 -print -quit)\"", tmpDir)})+ if err != nil {+ return fmt.Errorf("uploaded archive appears empty or invalid: %w", err)+ }+ if strings.TrimSpace(stderr) != "" {+ slog.DebugContext(ctx, "volume service: restore validate stderr", "volume", volumeName, "stderr", strings.TrimSpace(stderr))+ }- return &volumetypes.PruneReport{- VolumesDeleted: report.VolumesDeleted,- SpaceReclaimed: report.SpaceReclaimed,- }, nil+ _, stderr, err = s.execInContainerInternal(ctx, containerID, []string{"sh", "-c", "rm -rf /volume/* /volume/.[!.]* /volume/..?* 2>/dev/null || true"})+ if err != nil {+ return fmt.Errorf("failed to clear volume before restore: %w", err)+ }+ if strings.TrimSpace(stderr) != "" {+ slog.DebugContext(ctx, "volume service: restore clear stderr", "volume", volumeName, "stderr", strings.TrimSpace(stderr))+ }++ moveCmd := fmt.Sprintf("find %s -mindepth 1 -maxdepth 1 -exec mv -- {} /volume/ \\; && rmdir %s", tmpDir, tmpDir)+ _, stderr, err = s.execInContainerInternal(ctx, containerID, []string{"sh", "-c", moveCmd})+ if err != nil {+ return fmt.Errorf("failed to move restored files into place: %w", err)+ }+ if strings.TrimSpace(stderr) != "" {+ slog.DebugContext(ctx, "volume service: restore move stderr", "volume", volumeName, "stderr", strings.TrimSpace(stderr))+ }++ metadata := models.JSON{+ "action": "backup_upload_restore",+ "filename": filename,+ "pre_restore_backupId": preBackup.ID,+ }+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupRestore, volumeName, volumeName, user.ID, user.Username, "0", metadata); logErr != nil {+ slog.WarnContext(ctx, "could not log volume backup upload restore event", "volume", volumeName, "error", logErr.Error())+ }++ return nil}func (s *VolumeService) GetVolumeUsage(ctx context.Context, name string) (bool, []string, error) {+ slog.DebugContext(ctx, "volume service: get volume usage", "volume", name)dockerClient, err := s.dockerService.GetClient()if err != nil {return false, nil, fmt.Errorf("failed to connect to Docker: %w", err)@@ -206,6 +1493,7 @@ type VolumeSizeData struct {// GetVolumeSizes returns disk usage data for all volumes.// This is a slow operation as it calls Docker's DiskUsage API.func (s *VolumeService) GetVolumeSizes(ctx context.Context) (map[string]VolumeSizeData, error) {+ slog.DebugContext(ctx, "volume service: get volume sizes")dockerClient, err := s.dockerService.GetClient()if err != nil {return nil, fmt.Errorf("failed to connect to Docker: %w", err)@@ -229,7 +1517,8 @@ func (s *VolumeService) GetVolumeSizes(ctx context.Context) (map[string]VolumeSireturn result, nil}-func (s *VolumeService) enrichVolumesWithUsageData(volumes []*volume.Volume, usageVolumes []volume.Volume) []volume.Volume {+func (s *VolumeService) enrichVolumesWithUsageDataInternal(volumes []*volume.Volume, usageVolumes []volume.Volume) []volume.Volume {+ slog.Debug("volume service: enrich volumes with usage data", "volumes", len(volumes), "usage_volumes", len(usageVolumes))result := make([]volume.Volume, 0, len(volumes))for _, v := range volumes {if v != nil {@@ -246,7 +1535,8 @@ func (s *VolumeService) enrichVolumesWithUsageData(volumes []*volume.Volume, usareturn result}-func (s *VolumeService) buildVolumeContainerMap(ctx context.Context, dockerClient *client.Client) (map[string][]string, error) {+func (s *VolumeService) buildVolumeContainerMapInternal(ctx context.Context, dockerClient *client.Client) (map[string][]string, error) {+ slog.DebugContext(ctx, "volume service: build volume container map")containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})if err != nil {return nil, fmt.Errorf("failed to list containers: %w", err)@@ -264,7 +1554,8 @@ func (s *VolumeService) buildVolumeContainerMap(ctx context.Context, dockerClienreturn volumeContainerMap, nil}-func (s *VolumeService) buildVolumePaginationConfig() pagination.Config[volumetypes.Volume] {+func (s *VolumeService) buildVolumePaginationConfigInternal() pagination.Config[volumetypes.Volume] {+ slog.Debug("volume service: build volume pagination config")return pagination.Config[volumetypes.Volume]{SearchAccessors: []pagination.SearchAccessor[volumetypes.Volume]{func(v volumetypes.Volume) (string, error) { return v.Name, nil },@@ -272,13 +1563,14 @@ func (s *VolumeService) buildVolumePaginationConfig() pagination.Config[volumetyfunc(v volumetypes.Volume) (string, error) { return v.Mountpoint, nil },func(v volumetypes.Volume) (string, error) { return v.Scope, nil },},- SortBindings: s.buildVolumeSortBindings(),- FilterAccessors: s.buildVolumeFilterAccessors(),+ SortBindings: s.buildVolumeSortBindingsInternal(),+ FilterAccessors: s.buildVolumeFilterAccessorsInternal(),}}-func (s *VolumeService) buildVolumeSortBindings() []pagination.SortBinding[volumetypes.Volume] {- createdSortFn := func(a, b volumetypes.Volume) int { return strings.Compare(a.CreatedAt, b.CreatedAt) }+func (s *VolumeService) buildVolumeSortBindingsInternal() []pagination.SortBinding[volumetypes.Volume] {+ slog.Debug("volume service: build volume sort bindings")+ createdSortFn := s.compareVolumeCreatedInternalreturn []pagination.SortBinding[volumetypes.Volume]{{@@ -319,12 +1611,13 @@ func (s *VolumeService) buildVolumeSortBindings() []pagination.SortBinding[volum},{Key: "size",- Fn: s.compareVolumeSizes,+ Fn: s.compareVolumeSizesInternal,},}}-func (s *VolumeService) compareVolumeSizes(a, b volumetypes.Volume) int {+func (s *VolumeService) compareVolumeSizesInternal(a, b volumetypes.Volume) int {+ slog.Debug("volume service: compare volume sizes")aSize := a.SizebSize := b.Size@@ -344,7 +1637,37 @@ func (s *VolumeService) compareVolumeSizes(a, b volumetypes.Volume) int {return 1}-func (s *VolumeService) buildVolumeFilterAccessors() []pagination.FilterAccessor[volumetypes.Volume] {+func (s *VolumeService) compareVolumeCreatedInternal(a, b volumetypes.Volume) int {+ slog.Debug("volume service: compare volume created time")+ aTime, aOk := s.parseVolumeCreatedAtInternal(a.CreatedAt)+ bTime, bOk := s.parseVolumeCreatedAtInternal(b.CreatedAt)+ if aOk && bOk {+ if aTime.Before(bTime) {+ return -1+ }+ if aTime.After(bTime) {+ return 1+ }+ return 0+ }+ return strings.Compare(a.CreatedAt, b.CreatedAt)+}++func (s *VolumeService) parseVolumeCreatedAtInternal(createdAt string) (time.Time, bool) {+ if createdAt == "" {+ return time.Time{}, false+ }+ if parsed, err := time.Parse(time.RFC3339Nano, createdAt); err == nil {+ return parsed, true+ }+ if parsed, err := time.Parse(time.RFC3339, createdAt); err == nil {+ return parsed, true+ }+ return time.Time{}, false+}++func (s *VolumeService) buildVolumeFilterAccessorsInternal() []pagination.FilterAccessor[volumetypes.Volume] {+ slog.Debug("volume service: build volume filter accessors")return []pagination.FilterAccessor[volumetypes.Volume]{{Key: "inUse",@@ -361,7 +1684,8 @@ func (s *VolumeService) buildVolumeFilterAccessors() []pagination.FilterAccessor}}-func (s *VolumeService) calculateVolumeUsageCounts(items []volumetypes.Volume) volumetypes.UsageCounts {+func (s *VolumeService) calculateVolumeUsageCountsInternal(items []volumetypes.Volume) volumetypes.UsageCounts {+ slog.Debug("volume service: calculate volume usage counts", "items", len(items))counts := volumetypes.UsageCounts{Total: len(items),}@@ -375,27 +1699,12 @@ func (s *VolumeService) calculateVolumeUsageCounts(items []volumetypes.Volume) vreturn counts}-func (s *VolumeService) buildPaginationResponse(result pagination.FilterResult[volumetypes.Volume], params pagination.QueryParams) pagination.Response {- totalPages := int64(0)- if params.Limit > 0 {- totalPages = (int64(result.TotalCount) + int64(params.Limit) - 1) / int64(params.Limit)- }-- page := 1- if params.Limit > 0 {- page = (params.Start / params.Limit) + 1- }-- return pagination.Response{- TotalPages: totalPages,- TotalItems: int64(result.TotalCount),- CurrentPage: page,- ItemsPerPage: params.Limit,- GrandTotalItems: int64(result.TotalAvailable),- }+func (s *VolumeService) buildPaginationResponseInternal(result pagination.FilterResult[volumetypes.Volume], params pagination.QueryParams) pagination.Response {+ return s.buildPaginationResponseFromCountsInternal(result.TotalCount, result.TotalAvailable, params)}func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params pagination.QueryParams) ([]volumetypes.Volume, pagination.Response, volumetypes.UsageCounts, error) {+ slog.DebugContext(ctx, "volume service: list volumes paginated", "search", params.Search, "sort", params.Sort, "order", params.Order, "start", params.Start, "limit", params.Limit)dockerClient, err := s.dockerService.GetClient()if err != nil {return nil, pagination.Response{}, volumetypes.UsageCounts{}, fmt.Errorf("failed to connect to Docker: %w", err)@@ -424,7 +1733,7 @@ func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params paginat}(apiCtx)go func(ctx context.Context) {- containerMap, err := s.buildVolumeContainerMap(ctx, dockerClient)+ containerMap, err := s.buildVolumeContainerMapInternal(ctx, dockerClient)containerChan <- containerMapResult{containerMap: containerMap, err: err}}(apiCtx)@@ -451,7 +1760,7 @@ func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params paginat}}- volumes := s.enrichVolumesWithUsageData(volResult.volumes, usageVolumes)+ volumes := s.enrichVolumesWithUsageDataInternal(volResult.volumes, usageVolumes)items := make([]volumetypes.Volume, 0, len(volumes))for _, v := range volumes {@@ -465,10 +1774,10 @@ func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params paginatitems = append(items, volDto)}- config := s.buildVolumePaginationConfig()+ config := s.buildVolumePaginationConfigInternal()result := pagination.SearchOrderAndPaginate(items, params, config)- counts := s.calculateVolumeUsageCounts(items)- paginationResp := s.buildPaginationResponse(result, params)+ counts := s.calculateVolumeUsageCountsInternal(items)+ paginationResp := s.buildPaginationResponseInternal(result, params)return result.Items, paginationResp, counts, nil}diff --git a/backend/pkg/libarcane/internal_container.go b/backend/pkg/libarcane/internal_container.gonew file mode 100644index 000000000..673200fa3--- /dev/null+++ b/backend/pkg/libarcane/internal_container.go@@ -0,0 +1,21 @@+package libarcane++import "strings"++// Internal containers indicate containers used for arcanes utilties, ie: temp containers used for viewing files for volumes etc+const InternalContainerLabel = "com.getarcaneapp.internal.container"++func IsInternalContainer(labels map[string]string) bool {+ if labels == nil {+ return false+ }+ for k, v := range labels {+ if strings.EqualFold(k, InternalContainerLabel) {+ switch strings.TrimSpace(strings.ToLower(v)) {+ case "true", "1", "yes", "on":+ return true+ }+ }+ }+ return false+}diff --git a/backend/resources/migrations/postgres/032_add_volume_backups.down.sql b/backend/resources/migrations/postgres/032_add_volume_backups.down.sqlnew file mode 100644index 000000000..dc16e31ec--- /dev/null+++ b/backend/resources/migrations/postgres/032_add_volume_backups.down.sql@@ -0,0 +1 @@+DROP TABLE volume_backups;diff --git a/backend/resources/migrations/postgres/032_add_volume_backups.up.sql b/backend/resources/migrations/postgres/032_add_volume_backups.up.sqlnew file mode 100644index 000000000..b9c095beb--- /dev/null+++ b/backend/resources/migrations/postgres/032_add_volume_backups.up.sql@@ -0,0 +1,8 @@+CREATE TABLE volume_backups (+ id TEXT PRIMARY KEY,+ volume_name TEXT NOT NULL,+ size BIGINT NOT NULL,+ created_at TIMESTAMP WITH TIME ZONE NOT NULL,+ updated_at TIMESTAMP WITH TIME ZONE+);+CREATE INDEX idx_volume_backups_volume_name ON volume_backups(volume_name);diff --git a/backend/resources/migrations/sqlite/032_add_volume_backups.down.sql b/backend/resources/migrations/sqlite/032_add_volume_backups.down.sqlnew file mode 100644index 000000000..dc16e31ec--- /dev/null+++ b/backend/resources/migrations/sqlite/032_add_volume_backups.down.sql@@ -0,0 +1 @@+DROP TABLE volume_backups;diff --git a/backend/resources/migrations/sqlite/032_add_volume_backups.up.sql b/backend/resources/migrations/sqlite/032_add_volume_backups.up.sqlnew file mode 100644index 000000000..9645bf005--- /dev/null+++ b/backend/resources/migrations/sqlite/032_add_volume_backups.up.sql@@ -0,0 +1,8 @@+CREATE TABLE volume_backups (+ id TEXT PRIMARY KEY,+ volume_name TEXT NOT NULL,+ size INTEGER NOT NULL,+ created_at TIMESTAMP NOT NULL,+ updated_at TIMESTAMP+);+CREATE INDEX idx_volume_backups_volume_name ON volume_backups(volume_name);diff --git a/docker/Dockerfile b/docker/Dockerfileindex 0ceb02de9..0e6ef93c8 100644--- a/docker/Dockerfile+++ b/docker/Dockerfile@@ -61,7 +61,7 @@ ARG VERSION="dev"ARG REVISION="unknown"RUN apt-get update && apt-get upgrade -y \- && apt-get install -y --no-install-recommends ca-certificates curl tzdata \+ && apt-get install -y --no-install-recommends ca-certificates curl tzdata tar gzip \vainfo clinfo libdrm2 libsystemd0 \&& if [ "$TARGETARCH" = "amd64" ]; then \apt-get install -y --no-install-recommends intel-gpu-tools; \diff --git a/docker/Dockerfile-agent b/docker/Dockerfile-agentindex 83612e9a9..392abdd70 100644--- a/docker/Dockerfile-agent+++ b/docker/Dockerfile-agent@@ -35,7 +35,7 @@ RUN --mount=type=cache,target=/root/.cache/go-build \FROM debian:trixie-slim AS agentARG TARGETARCHRUN apt-get update && apt-get upgrade -y \- && apt-get install -y --no-install-recommends ca-certificates curl tzdata \+ && apt-get install -y --no-install-recommends ca-certificates curl tzdata tar gzip \vainfo clinfo libdrm2 libsystemd0 \&& if [ "$TARGETARCH" = "amd64" ]; then \apt-get install -y --no-install-recommends intel-gpu-tools; \diff --git a/frontend/messages/en.json b/frontend/messages/en.jsonindex e398eb9c2..2d3632f2d 100644--- a/frontend/messages/en.json+++ b/frontend/messages/en.json@@ -595,6 +595,13 @@"volumes_subtitle": "Manage your Docker volumes","volumes_stat_total": "Total Volumes","volumes_stat_unused": "Unused Volumes",+ "volumes_nav_browser": "Browser",+ "volumes_nav_backups": "Backups",+ "volumes_browser_title": "Volume Browser",+ "volumes_browser_description": "Browse and manage files inside the volume",+ "volumes_backups_title": "Volume Backups",+ "volumes_backups_description": "Create and manage backups of this volume",+ "volumes_backups_restore": "Restore","volumes_remove_in_use_warning": "Warning: This volume is currently in use by containers. Forcing removal may cause data loss or container issues.","volumes_containers_using_title": "Containers Using This Volume","volumes_containers_using_description": "List of containers currently referencing this volume",@@ -608,6 +615,23 @@"volumes_remove_selected_message": "Are you sure you want to remove the selected volume(s)? This action cannot be undone.","volumes_remove_failed": "Failed to remove volume {name}","volumes_remove_success": "Volume {name} removed successfully",+ "volumes_browser_new_folder": "New Folder",+ "volumes_browser_upload_files": "Upload Files",+ "volumes_browser_delete_confirm": "Are you sure you want to delete {name}?",+ "volumes_backup_create": "Create Backup",+ "volumes_backup_restore_confirm": "Are you sure you want to restore this backup? This will overwrite the current volume contents!",+ "volumes_backup_delete_confirm": "Are you sure you want to delete this backup?",+ "volumes_backup_restore_title": "Restore Volume",+ "volumes_backup_restore_message": "This will replace ALL data in the volume \"{volumeName}\" with the contents of this backup.\n\nA safety backup will be created automatically before restoring, so you can undo this operation if needed.",+ "volumes_backup_restore_in_use_warning": "\n\n⚠️ Warning: This volume is currently in use by {count} container(s). Restoring while containers are running may cause data corruption. Stop the containers first or use \"Restore files\" to restore specific files.",+ "volumes_backup_restore_success": "Volume restored successfully. A safety backup was created before restoring.",+ "volumes_backup_restore_files_success": "{count} file(s) restored successfully. A safety backup was created before restoring.",+ "volumes_backup_safety_info": "A safety backup will be created automatically before restoring, so you can undo this operation if needed.",+ "volumes_backup_overwrite_warning": "Selected files will overwrite existing files at those paths.",+ "volumes_backup_file_restore_success": "File restored successfully. A safety backup was created before restoring.",+ "volumes_symlink_external_tooltip": "This symlink points to a location outside the volume",+ "volumes_symlink_target_tooltip": "Symlink → {target}",+ "volumes_symlink_tooltip": "Symbolic link","_comment_networks": "=== NETWORKS ===","networks_title": "Networks","networks_subtitle": "Manage your Docker networks",diff --git a/frontend/src/lib/components/arcane-table/arcane-table-toolbar.svelte b/frontend/src/lib/components/arcane-table/arcane-table-toolbar.svelteindex 7dd98f3f4..1f2524f58 100644--- a/frontend/src/lib/components/arcane-table/arcane-table-toolbar.svelte+++ b/frontend/src/lib/components/arcane-table/arcane-table-toolbar.svelte@@ -19,6 +19,7 @@mobileFields = [],onToggleMobileField,customViewOptions,+ customToolbarActions,class: className}: {table: Table<TData>;@@ -28,6 +29,7 @@mobileFields?: { id: string; label: string; visible: boolean }[];onToggleMobileField?: (fieldId: string) => void;customViewOptions?: Snippet;+ customToolbarActions?: Snippet;class?: string;} = $props();@@ -129,6 +131,10 @@{/if}{/if}+ {#if customToolbarActions}+ {@render customToolbarActions()}+ {/if}+<!-- View options - desktop only, always on the right --><div class="hidden md:block"><DataTableViewOptions {table} {customViewOptions} />diff --git a/frontend/src/lib/components/arcane-table/arcane-table.svelte b/frontend/src/lib/components/arcane-table/arcane-table.svelteindex 4044d4d0e..061e3da61 100644--- a/frontend/src/lib/components/arcane-table/arcane-table.svelte+++ b/frontend/src/lib/components/arcane-table/arcane-table.svelte@@ -56,6 +56,7 @@bulkActions = [],persistKey,customViewOptions,+ customToolbarActions,customTableView,customSettings = $bindable<Record<string, unknown>>({}),columnVisibility = $bindable<VisibilityState>({})@@ -76,6 +77,7 @@bulkActions?: BulkAction[];persistKey?: string;customViewOptions?: Snippet;+ customToolbarActions?: Snippet;customTableView?: Snippet<[{@@ -527,6 +529,7 @@mobileFields={mobileFieldsForOptions}{onToggleMobileField}{customViewOptions}+ {customToolbarActions}/></div>{/if}@@ -561,6 +564,7 @@mobileFields={mobileFieldsForOptions}{onToggleMobileField}{customViewOptions}+ {customToolbarActions}/></Card.Header>{/if}diff --git a/frontend/src/lib/components/file-browser/CreateFolderDialog.svelte b/frontend/src/lib/components/file-browser/CreateFolderDialog.sveltenew file mode 100644index 000000000..6f8b14906--- /dev/null+++ b/frontend/src/lib/components/file-browser/CreateFolderDialog.svelte@@ -0,0 +1,61 @@+<script lang="ts">+ import * as Dialog from '$lib/components/ui/dialog';+ import { Button } from '$lib/components/ui/button';+ import { Input } from '$lib/components/ui/input';+ import { Label } from '$lib/components/ui/label';+ import { toast } from 'svelte-sonner';+ import * as m from '$lib/paraglide/messages.js';++ let {+ open = $bindable(false),+ currentPath,+ onCreate+ }: {+ open: boolean;+ currentPath: string;+ onCreate: (folderName: string) => Promise<void>;+ } = $props();++ let folderName = $state('');+ let loading = $state(false);++ async function handleSubmit(e: SubmitEvent) {+ e.preventDefault();+ if (!folderName) return;++ loading = true;+ try {+ await onCreate(folderName);+ toast.success(m.common_create_success({ resource: folderName }));+ open = false;+ folderName = '';+ } catch (e: any) {+ toast.error(e.message || m.common_create_failed({ resource: folderName }));+ } finally {+ loading = false;+ }+ }+</script>++<Dialog.Root bind:open>+ <Dialog.Content class="sm:max-w-[425px]">+ <Dialog.Header>+ <Dialog.Title>{m.volumes_browser_new_folder()}</Dialog.Title>+ <Dialog.Description>+ Enter a name for the new folder in {currentPath}+ </Dialog.Description>+ </Dialog.Header>+ <form onsubmit={handleSubmit} class="grid gap-4 py-4">+ <div class="grid grid-cols-4 items-center gap-4">+ <Label for="name" class="text-right">{m.common_name()}</Label>+ <Input id="name" bind:value={folderName} class="col-span-3" autofocus />+ </div>+ <Dialog.Footer>+ <Button type="button" variant="outline" onclick={() => (open = false)}>{m.common_cancel()}</Button>+ <Button type="submit" disabled={loading || !folderName}>+ {loading ? m.common_action_creating() : m.common_create()}+ </Button>+ </Dialog.Footer>+ </form>+ </Dialog.Content>+</Dialog.Root>diff --git a/frontend/src/lib/components/file-browser/FileBreadcrumb.svelte b/frontend/src/lib/components/file-browser/FileBreadcrumb.sveltenew file mode 100644index 000000000..5cfa6e736--- /dev/null+++ b/frontend/src/lib/components/file-browser/FileBreadcrumb.svelte@@ -0,0 +1,62 @@+<script lang="ts">+ import * as Breadcrumb from '$lib/components/ui/breadcrumb';+ import { ArrowRightIcon, DashboardIcon } from '$lib/icons';++ let {+ path,+ rootLabel,+ onNavigate+ }: {+ path: string;+ rootLabel?: string;+ onNavigate: (path: string) => void;+ } = $props();++ let segments = $derived.by(() => {+ const parts = path.split('/').filter((p) => p);+ return parts.map((name, index) => ({+ name,+ path: '/' + parts.slice(0, index + 1).join('/')+ }));+ });+</script>++<Breadcrumb.Root>+ <Breadcrumb.List>+ <Breadcrumb.Item>+ <Breadcrumb.Link onclick={() => onNavigate('/')} class="cursor-pointer">+ <DashboardIcon class="h-4 w-4" />+ </Breadcrumb.Link>+ </Breadcrumb.Item>++ {#if rootLabel}+ <Breadcrumb.Separator>+ <ArrowRightIcon class="h-4 w-4" />+ </Breadcrumb.Separator>+ <Breadcrumb.Item>+ {#if segments.length === 0}+ <Breadcrumb.Page>{rootLabel}</Breadcrumb.Page>+ {:else}+ <Breadcrumb.Link onclick={() => onNavigate('/')} class="cursor-pointer">+ {rootLabel}+ </Breadcrumb.Link>+ {/if}+ </Breadcrumb.Item>+ {/if}++ {#each segments as segment, i}+ <Breadcrumb.Separator>+ <ArrowRightIcon class="h-4 w-4" />+ </Breadcrumb.Separator>+ <Breadcrumb.Item>+ {#if i === segments.length - 1}+ <Breadcrumb.Page>{segment.name}</Breadcrumb.Page>+ {:else}+ <Breadcrumb.Link onclick={() => onNavigate(segment.path)} class="cursor-pointer">+ {segment.name}+ </Breadcrumb.Link>+ {/if}+ </Breadcrumb.Item>+ {/each}+ </Breadcrumb.List>+</Breadcrumb.Root>diff --git a/frontend/src/lib/components/file-browser/FileList.svelte b/frontend/src/lib/components/file-browser/FileList.sveltenew file mode 100644index 000000000..1c5770657--- /dev/null+++ b/frontend/src/lib/components/file-browser/FileList.svelte@@ -0,0 +1,290 @@+<script lang="ts">+ import type { FileEntry } from '$lib/types/file-browser.type';+ import {+ FolderOpenIcon,+ FileTextIcon,+ DownloadIcon,+ TrashIcon,+ EllipsisIcon,+ EyeOnIcon,+ ClockIcon,+ RestartIcon,+ ExternalLinkIcon+ } from '$lib/icons';+ import { toast } from 'svelte-sonner';+ import * as m from '$lib/paraglide/messages.js';+ import ArcaneTable from '$lib/components/arcane-table/arcane-table.svelte';+ import type { Paginated, SearchPaginationSortRequest } from '$lib/types/pagination.type';+ import { UniversalMobileCard, type ColumnSpec, type MobileFieldVisibility } from '$lib/components/arcane-table';+ import * as DropdownMenu from '$lib/components/ui/dropdown-menu';+ import * as Tooltip from '$lib/components/ui/tooltip';+ import { openConfirmDialog } from '$lib/components/confirm-dialog';+ import { ArcaneButton } from '$lib/components/arcane-button';+ import bytes from 'bytes';+ import { format } from 'date-fns';++ let {+ files,+ currentPath,+ persistKey = 'arcane-file-browser-table',+ onNavigate,+ onRefresh,+ onDelete,+ onDownload,+ onPreview,+ onRestoreFromBackup+ }: {+ files: FileEntry[];+ currentPath: string;+ persistKey?: string;+ onNavigate: (path: string) => void;+ onRefresh: () => void;+ onDelete: (file: FileEntry) => Promise<void>;+ onDownload: (file: FileEntry) => Promise<void>;+ onPreview: (file: FileEntry) => void;+ onRestoreFromBackup?: (file: FileEntry) => void;+ } = $props();++ let requestOptions = $state<SearchPaginationSortRequest>({+ pagination: { page: 1, limit: 100 },+ sort: { column: 'name', direction: 'asc' }+ });++ let mobileFieldVisibility = $state<Record<string, boolean>>({});++ function compareByColumn(a: FileEntry, b: FileEntry, column: string): number {+ switch (column) {+ case 'size':+ return Number(a.size) - Number(b.size);+ case 'modTime':+ return new Date(a.modTime).getTime() - new Date(b.modTime).getTime();+ case 'name':+ default:+ return a.name.localeCompare(b.name);+ }+ }++ const sortedFiles = $derived.by(() => {+ const sortColumn = requestOptions?.sort?.column ?? 'name';+ const direction = requestOptions?.sort?.direction === 'desc' ? -1 : 1;+ const items = files.slice();+ return items.sort((a, b) => {+ if (a.isDirectory !== b.isDirectory) {+ return a.isDirectory ? -1 : 1;+ }+ const diff = compareByColumn(a, b, sortColumn);+ if (diff !== 0) return diff * direction;+ return a.name.localeCompare(b.name);+ });+ });++ const itemsPaginated = $derived<Paginated<FileEntry & { id: string }>>({+ data: sortedFiles.map((f) => ({ ...f, id: f.path })),+ pagination: {+ currentPage: 1,+ totalPages: 1,+ totalItems: sortedFiles.length,+ itemsPerPage: sortedFiles.length+ }+ });++ function formatBytes(value: number) {+ return bytes.format(value, { unitSeparator: ' ' }) ?? '-';+ }++ async function handleDelete(file: FileEntry) {+ openConfirmDialog({+ title: m.common_remove_title({ resource: file.name }),+ message: m.volumes_browser_delete_confirm({ name: file.name }),+ confirm: {+ label: m.common_delete(),+ destructive: true,+ action: async () => {+ try {+ await onDelete(file);+ toast.success(m.common_delete_success({ resource: file.name }));+ onRefresh();+ } catch (e: any) {+ toast.error(e.message || m.common_delete_failed({ resource: file.name }));+ }+ }+ }+ });+ }++ async function handleDownload(file: FileEntry) {+ try {+ await onDownload(file);+ } catch (e: any) {+ toast.error(e.message || m.common_failed());+ }+ }++ const columns = [+ { accessorKey: 'name', title: m.common_name(), sortable: true, cell: NameCell },+ { accessorKey: 'size', title: m.common_size(), sortable: true, cell: SizeCell },+ { accessorKey: 'modTime', title: m.common_created(), sortable: true, cell: CreatedCell }+ ] satisfies ColumnSpec<FileEntry & { id: string }>[];++ const mobileFields = [+ { id: 'size', label: m.common_size(), defaultVisible: true },+ { id: 'modTime', label: m.common_created(), defaultVisible: false }+ ];+</script>++{#snippet NameCell({ item }: { item: FileEntry })}+ <div class="flex items-center gap-2">+ {#if item.isDirectory}+ <FolderOpenIcon class="size-4 text-blue-500" />+ <button class="text-left font-medium hover:underline" onclick={() => onNavigate(item.path)}>+ {item.name}+ </button>+ {:else}+ <FileTextIcon class="text-muted-foreground size-4" />+ <span class="font-medium">{item.name}</span>+ {/if}+ {#if item.isSymlink}+ <Tooltip.Provider>+ <Tooltip.Root>+ <Tooltip.Trigger>+ <span class="inline-flex items-center gap-1 text-xs">+ <ExternalLinkIcon class="size-3 text-purple-500" />+ {#if item.linkTarget === '(external)'}+ <span class="text-amber-500">(external)</span>+ {/if}+ </span>+ </Tooltip.Trigger>+ <Tooltip.Content>+ {#if item.linkTarget === '(external)'}+ <p>{m.volumes_symlink_external_tooltip()}</p>+ {:else if item.linkTarget}+ <p>{m.volumes_symlink_target_tooltip({ target: item.linkTarget })}</p>+ {:else}+ <p>{m.volumes_symlink_tooltip()}</p>+ {/if}+ </Tooltip.Content>+ </Tooltip.Root>+ </Tooltip.Provider>+ {/if}+ </div>+{/snippet}++{#snippet SizeCell({ item, value }: { item: FileEntry; value: any })}+ <span class="text-muted-foreground text-sm">+ {item.isDirectory ? '--' : formatBytes(Number(value))}+ </span>+{/snippet}++{#snippet CreatedCell({ value }: { value: any })}+ <span class="text-muted-foreground text-sm">+ {format(new Date(String(value)), 'PP p')}+ </span>+{/snippet}++{#snippet RowActions({ item }: { item: FileEntry })}+ <DropdownMenu.Root>+ <DropdownMenu.Trigger>+ {#snippet child({ props })}+ <ArcaneButton+ {...props}+ action="base"+ tone="ghost"+ size="icon"+ class="relative size-8 p-0"+ icon={EllipsisIcon}+ showLabel={false}+ customLabel={m.common_open_menu()}+ />+ {/snippet}+ </DropdownMenu.Trigger>+ <DropdownMenu.Content align="end">+ <DropdownMenu.Group>+ {#if !item.isDirectory}+ <DropdownMenu.Item onclick={() => onPreview(item)}>+ <EyeOnIcon class="size-4" />+ {m.common_view()}+ </DropdownMenu.Item>+ <DropdownMenu.Item onclick={() => handleDownload(item)}>+ <DownloadIcon class="size-4" />+ {m.templates_download()}+ </DropdownMenu.Item>+ {#if onRestoreFromBackup && !item.isSymlink}+ <DropdownMenu.Item onclick={() => onRestoreFromBackup(item)}>+ <RestartIcon class="size-4" />+ Restore from backup+ </DropdownMenu.Item>+ {/if}+ <DropdownMenu.Separator />+ {/if}+ <DropdownMenu.Item variant="destructive" onclick={() => handleDelete(item)}>+ <TrashIcon class="size-4" />+ {m.common_delete()}+ </DropdownMenu.Item>+ </DropdownMenu.Group>+ </DropdownMenu.Content>+ </DropdownMenu.Root>+{/snippet}++{#snippet FileMobileCardSnippet({+ item,+ mobileFieldVisibility+}: {+ item: FileEntry;+ mobileFieldVisibility: MobileFieldVisibility;+})}+ <UniversalMobileCard+ {item}+ icon={{ component: item.isDirectory ? FolderOpenIcon : FileTextIcon, variant: item.isDirectory ? 'blue' : 'gray' }}+ title={(item) => item.name}+ fields={[+ {+ label: m.common_size(),+ getValue: (item) => (item.isDirectory ? '--' : formatBytes(item.size)),+ icon: EyeOnIcon,+ iconVariant: 'gray',+ show: mobileFieldVisibility.size ?? true+ }+ ]}+ footer={{+ label: m.common_created(),+ getValue: (item) => format(new Date(item.modTime), 'PP p'),+ icon: ClockIcon || 'div'+ }}+ rowActions={RowActions}+ onclick={() => item.isDirectory && onNavigate(item.path)}+ />+{/snippet}++<div class="file-browser-table bg-card overflow-hidden rounded-lg border shadow-sm">+ <ArcaneTable+ {persistKey}+ items={itemsPaginated}+ bind:requestOptions+ bind:mobileFieldVisibility+ onRefresh={async () => itemsPaginated}+ {columns}+ {mobileFields}+ rowActions={RowActions}+ mobileCard={FileMobileCardSnippet}+ unstyled+ withoutPagination+ withoutSearch+ selectionDisabled+ />+</div>++<style>+ @reference "../../../app.css";++ :global(.file-browser-table thead tr) {+ @apply bg-muted/30 hover:bg-muted/30;+ }++ :global(.file-browser-table tbody tr) {+ @apply hover:bg-muted/50 cursor-default border-none transition-colors;+ }++ :global(.file-browser-table td) {+ @apply py-2;+ }+</style>diff --git a/frontend/src/lib/components/file-browser/FilePreview.svelte b/frontend/src/lib/components/file-browser/FilePreview.sveltenew file mode 100644index 000000000..8b7af4c78--- /dev/null+++ b/frontend/src/lib/components/file-browser/FilePreview.svelte@@ -0,0 +1,64 @@+<script lang="ts">+ import type { FileEntry } from '$lib/types/file-browser.type';+ import { onMount } from 'svelte';+ import * as Sheet from '$lib/components/ui/sheet';+ import { LoadingSpinnerIcon } from '$lib/icons';++ let { file, fetchContent, onClose }: { file: FileEntry; fetchContent: (path: string) => Promise<string>; onClose: () => void } =+ $props();++ let content = $state<string | null>(null);+ let loading = $state(true);+ let error = $state<string | null>(null);++ function b64DecodeUnicode(str: string) {+ try {+ // Try to decode UTF-8 safely+ return decodeURIComponent(+ atob(str)+ .split('')+ .map(function (c) {+ return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);+ })+ .join('')+ );+ } catch (e) {+ // Fallback to plain atob if it's not proper UTF-8+ return atob(str);+ }+ }++ onMount(async () => {+ try {+ const res = await fetchContent(file.path);+ content = b64DecodeUnicode(res);+ } catch (e: any) {+ error = e.message || 'Failed to load preview';+ } finally {+ loading = false;+ }+ });+</script>++<Sheet.Root open={!!file} onOpenChange={(open) => !open && onClose()}>+ <Sheet.Content class="flex h-full flex-col sm:max-w-2xl">+ <Sheet.Header>+ <Sheet.Title class="truncate">{file.name}</Sheet.Title>+ <Sheet.Description class="break-all">{file.path}</Sheet.Description>+ </Sheet.Header>++ <div class="mt-6 min-h-0 flex-grow overflow-y-auto">+ {#if loading}+ <div class="flex h-full items-center justify-center p-12">+ <LoadingSpinnerIcon class="text-muted-foreground h-8 w-8" />+ </div>+ {:else if error}+ <div class="border-destructive/20 bg-destructive/10 text-destructive rounded border p-4">+ {error}+ </div>+ {:else}+ <pre class="bg-muted w-full rounded p-4 font-mono text-xs break-all whitespace-pre-wrap">{content}</pre>+ {/if}+ </div>+ </Sheet.Content>+</Sheet.Root>diff --git a/frontend/src/lib/components/file-browser/FileUploadDialog.svelte b/frontend/src/lib/components/file-browser/FileUploadDialog.sveltenew file mode 100644index 000000000..c59ab5310--- /dev/null+++ b/frontend/src/lib/components/file-browser/FileUploadDialog.svelte@@ -0,0 +1,108 @@+<script lang="ts">+ import * as Dialog from '$lib/components/ui/dialog';+ import { ArcaneButton } from '$lib/components/arcane-button';+ import { FileDropZone, displaySize, MEGABYTE, type FileDropZoneProps } from '$lib/components/ui/file-drop-zone';+ import { toast } from 'svelte-sonner';+ import * as m from '$lib/paraglide/messages.js';+ import { CloseIcon } from '$lib/icons';++ let {+ open = $bindable(false),+ currentPath,+ onUpload: onUploadAction+ }: {+ open: boolean;+ currentPath: string;+ onUpload: (file: File) => Promise<void>;+ } = $props();++ let files = $state<File[]>([]);+ let uploading = $state(false);++ const onUpload: FileDropZoneProps['onUpload'] = async (newFiles) => {+ files = [...files, ...newFiles];+ };++ const onFileRejected: FileDropZoneProps['onFileRejected'] = ({ reason, file }) => {+ toast.error(`${file.name} failed to upload!`, { description: reason });+ };++ function removeFile(index: number) {+ files = files.filter((_, i) => i !== index);+ }++ async function handleUpload() {+ if (files.length === 0) return;+ uploading = true;+ try {+ for (const file of files) {+ await onUploadAction(file);+ }+ toast.success(m.common_success());+ open = false;+ files = [];+ } catch (e: any) {+ toast.error(e.message || m.common_failed());+ } finally {+ uploading = false;+ }+ }+</script>++<Dialog.Root+ bind:open+ onOpenChange={(isOpen) => {+ if (!isOpen) files = [];+ }}+>+ <Dialog.Content class="sm:max-w-[500px]">+ <Dialog.Header>+ <Dialog.Title>{m.volumes_browser_upload_files()}</Dialog.Title>+ <Dialog.Description>+ Upload files to {currentPath}+ </Dialog.Description>+ </Dialog.Header>+ <div class="space-y-4 py-4">+ <FileDropZone {onUpload} {onFileRejected} multiple fileCount={files.length} disabled={uploading} />++ {#if files.length > 0}+ <div class="flex max-h-[200px] flex-col gap-2 overflow-y-auto pr-1">+ {#each files as file, i (file.name + i)}+ <div class="border-border bg-muted/50 flex items-center justify-between gap-2 rounded-lg border p-2">+ <div class="flex flex-col overflow-hidden">+ <span class="truncate text-xs font-medium">{file.name}</span>+ <span class="text-muted-foreground text-[10px]">{displaySize(file.size)}</span>+ </div>+ <ArcaneButton+ action="base"+ tone="ghost"+ size="icon"+ class="h-6 w-6"+ onclick={() => removeFile(i)}+ icon={CloseIcon}+ disabled={uploading}+ />+ </div>+ {/each}+ </div>+ {/if}+ </div>+ <Dialog.Footer>+ <ArcaneButton+ action="cancel"+ onclick={() => {+ open = false;+ files = [];+ }}+ disabled={uploading}+ />+ <ArcaneButton+ action="create"+ onclick={handleUpload}+ disabled={uploading || files.length === 0}+ loading={uploading}+ customLabel={uploading ? m.common_action_updating() : m.common_update()}+ />+ </Dialog.Footer>+ </Dialog.Content>+</Dialog.Root>diff --git a/frontend/src/lib/components/file-browser/GenericFileBrowser.svelte b/frontend/src/lib/components/file-browser/GenericFileBrowser.sveltenew file mode 100644index 000000000..bb74c5e97--- /dev/null+++ b/frontend/src/lib/components/file-browser/GenericFileBrowser.svelte@@ -0,0 +1,327 @@+<script lang="ts" module>+ import type { BackupEntry, FileEntry } from '$lib/types/file-browser.type';++ export interface FileProvider {+ list: (path: string) => Promise<FileEntry[]>;+ mkdir: (path: string) => Promise<void>;+ upload: (path: string, file: File) => Promise<void>;+ delete: (path: string) => Promise<void>;+ download: (path: string) => Promise<void>;+ getContent: (path: string) => Promise<{ content: string }>;+ listBackups?: () => Promise<BackupEntry[]>;+ restoreFromBackup?: (backupId: string, path: string) => Promise<void>;+ backupHasPath?: (backupId: string, path: string) => Promise<boolean>;+ }+</script>++<script lang="ts">+ import { onMount } from 'svelte';+ import FileList from './FileList.svelte';+ import FileBreadcrumb from './FileBreadcrumb.svelte';+ import { UploadIcon, MoveToFolderIcon, InfoIcon } from '$lib/icons';+ import { ArcaneButton } from '$lib/components/arcane-button';+ import CreateFolderDialog from './CreateFolderDialog.svelte';+ import FileUploadDialog from './FileUploadDialog.svelte';+ import FilePreview from './FilePreview.svelte';+ import * as m from '$lib/paraglide/messages.js';+ import { Spinner } from '$lib/components/ui/spinner/index.js';+ import { ResponsiveDialog } from '$lib/components/ui/responsive-dialog';+ import * as Select from '$lib/components/ui/select';+ import * as Alert from '$lib/components/ui/alert';+ import { Label } from '$lib/components/ui/label';+ import { toast } from 'svelte-sonner';+ import bytes from 'bytes';+ import { format } from 'date-fns';++ let { provider, rootLabel, persistKey }: { provider: FileProvider; rootLabel?: string; persistKey?: string } = $props();++ let currentPath = $state('/');+ let files = $state<FileEntry[]>([]);+ let loading = $state(true);+ let error = $state<string | null>(null);++ let showCreateFolder = $state(false);+ let showUpload = $state(false);+ let previewFile = $state<FileEntry | null>(null);+ let showRestoreFile = $state(false);+ let restoreTarget = $state<FileEntry | null>(null);+ let backups = $state<BackupEntry[]>([]);+ let loadingBackups = $state(false);+ let restoringFile = $state(false);+ let selectedBackupId = $state('');+ let backupHasFile = $state<boolean | null>(null);+ let checkingBackup = $state(false);+ let lastCheckedKey = $state('');+ const selectedBackup = $derived(backups.find((b) => b.id === selectedBackupId));++ const canRestoreFromBackup = $derived(!!provider.listBackups && !!provider.restoreFromBackup);+ const requiresBackupCheck = $derived(!!provider.backupHasPath);++ async function loadFiles(path: string) {+ loading = true;+ error = null;+ try {+ const result = await provider.list(path);+ // Sort: directories first, then alphabetically+ files = result.sort((a, b) => {+ if (a.isDirectory && !b.isDirectory) return -1;+ if (!a.isDirectory && b.isDirectory) return 1;+ return a.name.localeCompare(b.name);+ });+ currentPath = path;+ } catch (e: any) {+ error = e.message || m.common_failed();+ } finally {+ loading = false;+ }+ }++ function handleNavigate(path: string) {+ loadFiles(path);+ }++ async function loadBackups() {+ if (!provider.listBackups) return;+ loadingBackups = true;+ try {+ backups = await provider.listBackups();+ if (backups.length > 0) {+ selectedBackupId = backups[0].id;+ }+ } catch (e: any) {+ toast.error(e.message || m.common_failed());+ } finally {+ loadingBackups = false;+ }+ }++ function openRestoreFileDialog(file: FileEntry) {+ if (file.isDirectory || file.isSymlink) return;+ restoreTarget = file;+ selectedBackupId = '';+ backups = [];+ backupHasFile = null;+ lastCheckedKey = '';+ showRestoreFile = true;+ loadBackups();+ }++ async function handleRestoreFile() {+ if (!restoreTarget || !provider.restoreFromBackup || !selectedBackupId) return;+ restoringFile = true;+ try {+ await provider.restoreFromBackup(selectedBackupId, restoreTarget.path);+ toast.success(m.volumes_backup_file_restore_success());+ showRestoreFile = false;+ // Refresh the file list to show the restored file+ await loadFiles(currentPath);+ } catch (e: any) {+ toast.error(e.message || m.common_failed());+ } finally {+ restoringFile = false;+ }+ }++ async function checkBackupHasFile(backupId: string, filePath: string) {+ if (!provider.backupHasPath) return;+ const key = `${backupId}:${filePath}`;+ if (key === lastCheckedKey) return;+ lastCheckedKey = key;+ checkingBackup = true;+ backupHasFile = null;+ try {+ backupHasFile = await provider.backupHasPath(backupId, filePath);+ } catch (e: any) {+ backupHasFile = null;+ toast.error(e.message || m.common_failed());+ } finally {+ checkingBackup = false;+ }+ }++ function formatBackupLabel(backup: BackupEntry): string {+ const sizeLabel = bytes.format(backup.size, { unitSeparator: ' ' }) ?? '-';+ const createdLabel = backup.createdAt ? format(new Date(backup.createdAt), 'PP p') : '-';+ return `${backup.id} • ${createdLabel} • ${sizeLabel}`;+ }++ onMount(() => {+ loadFiles('/');+ });++ $effect(() => {+ if (!showRestoreFile) return;+ if (!requiresBackupCheck) return;+ if (!restoreTarget || !selectedBackupId) {+ backupHasFile = null;+ return;+ }+ checkBackupHasFile(selectedBackupId, restoreTarget.path);+ });+</script>++<div class="flex flex-col gap-4">+ <div class="flex items-center justify-between">+ <FileBreadcrumb path={currentPath} {rootLabel} onNavigate={handleNavigate} />+ <div class="flex gap-2">+ <ArcaneButton+ action="base"+ tone="outline"+ size="sm"+ onclick={() => (showCreateFolder = true)}+ icon={MoveToFolderIcon}+ customLabel={m.volumes_browser_new_folder()}+ />+ <ArcaneButton+ action="base"+ tone="outline"+ size="sm"+ onclick={() => (showUpload = true)}+ icon={UploadIcon}+ customLabel={m.volumes_browser_upload_files()}+ />+ </div>+ </div>++ {#if loading}+ <div class="flex justify-center p-12">+ <Spinner class="text-muted-foreground size-8" />+ </div>+ {:else if error}+ <div class="border-destructive/20 bg-destructive/10 text-destructive rounded-lg border p-8 text-center">+ {error}+ </div>+ {:else}+ <FileList+ {files}+ {currentPath}+ {persistKey}+ onNavigate={handleNavigate}+ onRefresh={() => loadFiles(currentPath)}+ onDelete={(file) => provider.delete(file.path)}+ onDownload={(file) => provider.download(file.path)}+ onPreview={(file) => (previewFile = file)}+ onRestoreFromBackup={canRestoreFromBackup ? openRestoreFileDialog : undefined}+ />+ {/if}+</div>++<CreateFolderDialog+ bind:open={showCreateFolder}+ {currentPath}+ onCreate={async (name) => {+ const fullPath = currentPath === '/' ? `/${name}` : `${currentPath}/${name}`;+ await provider.mkdir(fullPath);+ await loadFiles(currentPath);+ }}+/>++<FileUploadDialog+ bind:open={showUpload}+ {currentPath}+ onUpload={async (file) => {+ await provider.upload(currentPath, file);+ await loadFiles(currentPath);+ }}+/>++{#if previewFile}+ <FilePreview+ file={previewFile}+ fetchContent={async (path) => {+ const res = await provider.getContent(path);+ return res.content;+ }}+ onClose={() => (previewFile = null)}+ />+{/if}++<ResponsiveDialog+ bind:open={showRestoreFile}+ title="Restore file from backup"+ description="Select a backup to restore the chosen file."+ contentClass="sm:max-w-[520px]"+>+ {#snippet children()}+ <div class="space-y-4 py-2">+ <Alert.Root class="py-2 [&>svg]:top-2">+ <InfoIcon class="size-4" />+ <Alert.Description class="text-xs">+ {m.volumes_backup_safety_info()}+ </Alert.Description>+ </Alert.Root>++ {#if restoreTarget}+ <div class="text-muted-foreground text-xs">+ File: <code class="bg-muted/40 rounded px-1.5 py-0.5 font-mono">{restoreTarget.path}</code>+ </div>+ {/if}++ {#if loadingBackups}+ <div class="text-muted-foreground flex items-center gap-2 text-sm">+ <Spinner class="size-4" />+ Loading backups...+ </div>+ {:else if backups.length === 0}+ <div class="text-muted-foreground text-sm">No backups available.</div>+ {:else}+ <div class="space-y-2">+ <Label for="restore-backup-select">Backup</Label>+ <div class="w-full overflow-hidden">+ <Select.Root+ type="single"+ value={selectedBackupId}+ onValueChange={(value) => {+ selectedBackupId = value;+ }}+ >+ <Select.Trigger id="restore-backup-select" class="h-10 w-full overflow-hidden">+ <span class="min-w-0 flex-1 truncate">+ {selectedBackup ? formatBackupLabel(selectedBackup) : 'Select backup'}+ </span>+ </Select.Trigger>+ <Select.Content>+ {#each backups as backup (backup.id)}+ <Select.Item value={backup.id}>{formatBackupLabel(backup)}</Select.Item>+ {/each}+ </Select.Content>+ </Select.Root>+ </div>+ </div>+ {#if requiresBackupCheck}+ {#if checkingBackup}+ <div class="text-muted-foreground flex items-center gap-2 text-xs">+ <Spinner class="size-3" />+ Checking backup contents...+ </div>+ {:else if backupHasFile === false}+ <div class="text-destructive text-xs">This backup does not contain the selected file.</div>+ {/if}+ {/if}+ {/if}+ </div>+ {/snippet}++ {#snippet footer()}+ <ArcaneButton+ action="cancel"+ onclick={() => {+ showRestoreFile = false;+ restoreTarget = null;+ selectedBackupId = '';+ }}+ />+ <ArcaneButton+ action="create"+ customLabel="Restore file"+ onclick={handleRestoreFile}+ loading={restoringFile}+ disabled={restoringFile ||+ loadingBackups ||+ checkingBackup ||+ !selectedBackupId ||+ !restoreTarget ||+ (requiresBackupCheck && backupHasFile !== true)}+ />+ {/snippet}+</ResponsiveDialog>diff --git a/frontend/src/lib/components/file-browser/VolumeBrowser.svelte b/frontend/src/lib/components/file-browser/VolumeBrowser.sveltenew file mode 100644index 000000000..379aae53f--- /dev/null+++ b/frontend/src/lib/components/file-browser/VolumeBrowser.svelte@@ -0,0 +1,27 @@+<script lang="ts">+ import { volumeBrowserService } from '$lib/services/volume-browser-service';+ import { volumeBackupService } from '$lib/services/volume-backup-service';+ import GenericFileBrowser, { type FileProvider } from './GenericFileBrowser.svelte';++ let { volumeName }: { volumeName: string } = $props();++ const provider: FileProvider = {+ list: (path) => volumeBrowserService.listDirectory(volumeName, path),+ mkdir: (path) => volumeBrowserService.createDirectory(volumeName, path),+ upload: (path, file) => volumeBrowserService.uploadFile(volumeName, path, file),+ delete: (path) => volumeBrowserService.deleteFile(volumeName, path),+ download: (path) => volumeBrowserService.downloadFile(volumeName, path),+ getContent: (path) => volumeBrowserService.getFileContent(volumeName, path),+ listBackups: async () => {+ const res = await volumeBackupService.listBackups(volumeName, {+ pagination: { page: 1, limit: 200 },+ sort: { column: 'createdAt', direction: 'desc' }+ });+ return res.data;+ },+ restoreFromBackup: (backupId, path) => volumeBackupService.restoreBackupFiles(volumeName, backupId, [path]),+ backupHasPath: (backupId, path) => volumeBackupService.backupHasPath(backupId, path)+ };+</script>++<GenericFileBrowser {provider} rootLabel={volumeName} persistKey="volume-file-browser" />diff --git a/frontend/src/lib/components/file-browser/index.ts b/frontend/src/lib/components/file-browser/index.tsnew file mode 100644index 000000000..f676e369d--- /dev/null+++ b/frontend/src/lib/components/file-browser/index.ts@@ -0,0 +1,26 @@+import Root from './GenericFileBrowser.svelte';+import Breadcrumb from './FileBreadcrumb.svelte';+import List from './FileList.svelte';+import Preview from './FilePreview.svelte';+import UploadDialog from './FileUploadDialog.svelte';+import CreateFolderDialog from './CreateFolderDialog.svelte';+import VolumeBrowser from './VolumeBrowser.svelte';++export type { FileProvider } from './GenericFileBrowser.svelte';++export {+ Root,+ Breadcrumb,+ List,+ Preview,+ UploadDialog,+ CreateFolderDialog,+ VolumeBrowser,+ // aliases+ Root as FileBrowser,+ Breadcrumb as FileBreadcrumb,+ List as FileList,+ Preview as FilePreview,+ UploadDialog as FileUploadDialog,+ CreateFolderDialog as FileCreateFolderDialog+};diff --git a/frontend/src/lib/components/ui/file-drop-zone/file-drop-zone.svelte b/frontend/src/lib/components/ui/file-drop-zone/file-drop-zone.svelteindex b37929f96..a54d8203d 100644--- a/frontend/src/lib/components/ui/file-drop-zone/file-drop-zone.svelte+++ b/frontend/src/lib/components/ui/file-drop-zone/file-drop-zone.svelte@@ -13,6 +13,7 @@maxFileSize,fileCount,disabled = false,+ multiple,onUpload,onFileRejected,accept,@@ -161,7 +162,7 @@disabled={!canUploadFiles}{id}{accept}- multiple={maxFiles === undefined || maxFiles - (fileCount ?? 0) > 1}+ multiple={multiple ?? (maxFiles === undefined || maxFiles - (fileCount ?? 0) > 1)}type="file"onchange={change}class="hidden"diff --git a/frontend/src/lib/components/ui/file-drop-zone/types.ts b/frontend/src/lib/components/ui/file-drop-zone/types.tsindex 00531b4a9..e659f8cca 100644--- a/frontend/src/lib/components/ui/file-drop-zone/types.ts+++ b/frontend/src/lib/components/ui/file-drop-zone/types.ts@@ -18,6 +18,9 @@ export type FileDropZonePropsWithoutHTML = WithChildren<{/** Called when a file does not meet the upload criteria (size, or type) */onFileRejected?: (opts: { reason: FileRejectedReason; file: File }) => void;+ /** Whether to allow multiple files. If undefined, it will be true if maxFiles is not 1. */+ multiple?: boolean;+// just for extra documentation/** Takes a comma separated list of one or more file types.*@@ -40,4 +43,4 @@ export type FileDropZonePropsWithoutHTML = WithChildren<{accept?: string;}>;-export type FileDropZoneProps = FileDropZonePropsWithoutHTML & Omit<HTMLInputAttributes, 'multiple' | 'files'>;+export type FileDropZoneProps = FileDropZonePropsWithoutHTML & Omit<HTMLInputAttributes, 'files'>;diff --git a/frontend/src/lib/services/volume-backup-service.ts b/frontend/src/lib/services/volume-backup-service.tsnew file mode 100644index 000000000..a431c351a--- /dev/null+++ b/frontend/src/lib/services/volume-backup-service.ts@@ -0,0 +1,87 @@+import BaseAPIService from './api-service';+import { environmentStore } from '$lib/stores/environment.store.svelte';+import type { BackupEntry } from '$lib/types/file-browser.type';+import type { SearchPaginationSortRequest, Paginated } from '$lib/types/pagination.type';+import { transformPaginationParams } from '$lib/utils/params.util';++export type VolumeBackupListResponse = Paginated<BackupEntry> & { warnings?: string[] };++export class VolumeBackupService extends BaseAPIService {+ async createBackup(volumeName: string): Promise<BackupEntry> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const res = await this.api.post(`/environments/${envId}/volumes/${volumeName}/backups`);+ return res.data.data;+ }++ async listBackups(volumeName: string, options?: SearchPaginationSortRequest): Promise<VolumeBackupListResponse> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const params = transformPaginationParams(options);+ const res = await this.api.get(`/environments/${envId}/volumes/${volumeName}/backups`, { params });+ return res.data;+ }++ async restoreBackup(volumeName: string, backupId: string): Promise<void> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ return this.handleResponse(+ this.api.post(`/environments/${envId}/volumes/${volumeName}/backups/${backupId}/restore`)+ );+ }++ async restoreBackupFiles(volumeName: string, backupId: string, paths: string[]): Promise<void> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ return this.handleResponse(+ this.api.post(`/environments/${envId}/volumes/${volumeName}/backups/${backupId}/restore-files`, {+ paths+ })+ );+ }++ async backupHasPath(backupId: string, filePath: string): Promise<boolean> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const res = await this.api.get(`/environments/${envId}/volumes/backups/${backupId}/has-path`, {+ params: { path: filePath }+ });+ return !!res.data.data?.exists;+ }++ async listBackupFiles(backupId: string): Promise<string[]> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const res = await this.api.get(`/environments/${envId}/volumes/backups/${backupId}/files`);+ return res.data.data ?? [];+ }++ async deleteBackup(backupId: string): Promise<void> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ return this.handleResponse(this.api.delete(`/environments/${envId}/volumes/backups/${backupId}`));+ }++ async downloadBackup(backupId: string): Promise<void> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const res = await this.api.get(`/environments/${envId}/volumes/backups/${backupId}/download`, {+ responseType: 'blob'+ });++ const url = window.URL.createObjectURL(new Blob([res.data]));+ const link = document.createElement('a');+ link.href = url;+ link.setAttribute('download', `${backupId}.tar.gz`);+ document.body.appendChild(link);+ link.click();+ link.remove();+ }++ async uploadAndRestore(volumeName: string, file: File): Promise<void> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const formData = new FormData();+ formData.append('file', file);+ return this.handleResponse(+ this.api.post(`/environments/${envId}/volumes/${volumeName}/backups/upload`, formData, {+ headers: {+ 'Content-Type': 'multipart/form-data'+ }+ })+ );+ }+}++export const volumeBackupService = new VolumeBackupService();diff --git a/frontend/src/lib/services/volume-browser-service.ts b/frontend/src/lib/services/volume-browser-service.tsnew file mode 100644index 000000000..cec070a77--- /dev/null+++ b/frontend/src/lib/services/volume-browser-service.ts@@ -0,0 +1,73 @@+import BaseAPIService from './api-service';+import { environmentStore } from '$lib/stores/environment.store.svelte';+import type { FileEntry, FileContentResponse } from '$lib/types/file-browser.type';++export class VolumeBrowserService extends BaseAPIService {+ async listDirectory(volumeName: string, path: string = '/'): Promise<FileEntry[]> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const res = await this.api.get(`/environments/${envId}/volumes/${volumeName}/browse`, {+ params: { path }+ });+ return res.data.data;+ }++ async getFileContent(volumeName: string, path: string): Promise<FileContentResponse> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const res = await this.api.get(`/environments/${envId}/volumes/${volumeName}/browse/content`, {+ params: { path }+ });+ return res.data.data;+ }++ async downloadFile(volumeName: string, path: string): Promise<void> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const res = await this.api.get(`/environments/${envId}/volumes/${volumeName}/browse/download`, {+ params: { path },+ responseType: 'blob'+ });++ const url = window.URL.createObjectURL(new Blob([res.data]));+ const link = document.createElement('a');+ link.href = url;+ // Extract filename from path+ const fileName = path.split('/').pop() || 'download';+ link.setAttribute('download', fileName);+ document.body.appendChild(link);+ link.click();+ link.remove();+ }++ async uploadFile(volumeName: string, path: string, file: File): Promise<void> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ const formData = new FormData();+ formData.append('file', file);+ return this.handleResponse(+ this.api.post(`/environments/${envId}/volumes/${volumeName}/browse/upload`, formData, {+ params: { path },+ headers: {+ 'Content-Type': 'multipart/form-data'+ }+ })+ );+ }++ async createDirectory(volumeName: string, path: string): Promise<void> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ return this.handleResponse(+ this.api.post(`/environments/${envId}/volumes/${volumeName}/browse/mkdir`, null, {+ params: { path }+ })+ );+ }++ async deleteFile(volumeName: string, path: string): Promise<void> {+ const envId = await environmentStore.getCurrentEnvironmentId();+ return this.handleResponse(+ this.api.delete(`/environments/${envId}/volumes/${volumeName}/browse`, {+ params: { path }+ })+ );+ }+}++export const volumeBrowserService = new VolumeBrowserService();diff --git a/frontend/src/lib/types/file-browser.type.ts b/frontend/src/lib/types/file-browser.type.tsnew file mode 100644index 000000000..74d73d5d3--- /dev/null+++ b/frontend/src/lib/types/file-browser.type.ts@@ -0,0 +1,22 @@+export interface FileEntry {+ name: string;+ path: string;+ isDirectory: boolean;+ size: number;+ modTime: string;+ mode: string;+ isSymlink: boolean;+ linkTarget?: string;+}++export interface FileContentResponse {+ content: string; // Base64 encoded bytes from Go+ mimeType: string;+}++export interface BackupEntry {+ id: string;+ volumeName: string;+ size: number;+ createdAt: string;+}diff --git a/frontend/src/lib/types/pagination.type.ts b/frontend/src/lib/types/pagination.type.tsindex 9d8067883..239560eee 100644--- a/frontend/src/lib/types/pagination.type.ts+++ b/frontend/src/lib/types/pagination.type.ts@@ -16,6 +16,7 @@ export type SearchPaginationSortRequest = {pagination?: PaginationRequest;sort?: SortRequest;filters?: FilterMap;+ includeInternal?: boolean;};export type PaginationResponse = {diff --git a/frontend/src/lib/types/settings.type.ts b/frontend/src/lib/types/settings.type.tsindex 8ac76b451..9829f9f1e 100644--- a/frontend/src/lib/types/settings.type.ts+++ b/frontend/src/lib/types/settings.type.ts@@ -24,6 +24,7 @@ export type Settings = {dockerHost: string;accentColor: string;autoInjectEnv: boolean;+ backupVolumeName?: string;authLocalEnabled: boolean;authSessionTimeout: number;diff --git a/frontend/src/lib/utils/params.util.ts b/frontend/src/lib/utils/params.util.tsindex 3d67be0c4..3fa2b57cf 100644--- a/frontend/src/lib/utils/params.util.ts+++ b/frontend/src/lib/utils/params.util.ts@@ -30,5 +30,9 @@ export function transformPaginationParams(options?: SearchPaginationSortRequest)});}+ if (typeof options.includeInternal === 'boolean') {+ params.includeInternal = String(options.includeInternal);+ }+return params;}diff --git a/frontend/src/lib/utils/table-persistence.util.ts b/frontend/src/lib/utils/table-persistence.util.tsindex 46bba4acd..26e9dfa15 100644--- a/frontend/src/lib/utils/table-persistence.util.ts+++ b/frontend/src/lib/utils/table-persistence.util.ts@@ -10,7 +10,8 @@ function cloneRequest(options: SearchPaginationSortRequest): SearchPaginationSorsearch: options.search,filters: options.filters ? { ...options.filters } : undefined,pagination: options.pagination ? { ...options.pagination } : undefined,- sort: options.sort ? { ...options.sort } : undefined+ sort: options.sort ? { ...options.sort } : undefined,+ includeInternal: options.includeInternal};}diff --git a/frontend/src/routes/(app)/containers/container-table.svelte b/frontend/src/routes/(app)/containers/container-table.svelteindex 99d1d3f7c..e207b8a66 100644--- a/frontend/src/routes/(app)/containers/container-table.svelte+++ b/frontend/src/routes/(app)/containers/container-table.svelte@@ -115,6 +115,27 @@return 'amber';}+ async function refreshContainers(options: SearchPaginationSortRequest) {+ const result = await containerService.getContainers(options);+ containers = result;+ return result;+ }++ function getCurrentLimit() {+ return requestOptions?.pagination?.limit ?? containers?.pagination?.itemsPerPage ?? 20;+ }++ function setShowInternal(value: boolean) {+ customSettings = { ...customSettings, showInternalContainers: value };+ const nextOptions: SearchPaginationSortRequest = {+ ...requestOptions,+ includeInternal: value,+ pagination: { page: 1, limit: getCurrentLimit() }+ };+ requestOptions = nextOptions;+ refreshContainers(nextOptions);+ }+async function performContainerAction(action: 'start' | 'stop' | 'restart', id: string) {// Set action status for this specific containerif (action === 'start') {@@ -406,6 +427,9 @@let mobileFieldVisibility = $state<Record<string, boolean>>({});let customSettings = $state<Record<string, unknown>>({});+ let showInternal = $derived.by(() => {+ return (customSettings.showInternalContainers as boolean) ?? false;+ });let collapsedGroupsState = $state<PersistedState<Record<string, boolean>> | null>(null);let collapsedGroups = $derived(collapsedGroupsState?.current ?? {});let columnVisibility = $state<Record<string, boolean>>({});@@ -471,6 +495,15 @@customSettings = { ...customSettings, groupByProject: value };}+ $effect(() => {+ const current = requestOptions?.includeInternal;+ if (showInternal && current !== true) {+ setShowInternal(true);+ } else if (!showInternal && current === true) {+ setShowInternal(false);+ }+ });+function toggleGroup(groupName: string) {if (!collapsedGroupsState) return;collapsedGroupsState.current = {@@ -897,7 +930,7 @@bind:mobileFieldVisibilitybind:customSettingsbind:columnVisibility- onRefresh={async (options) => (containers = await containerService.getContainers(options))}+ onRefresh={refreshContainers}{columns}{mobileFields}{bulkActions}@@ -911,6 +944,9 @@<DropdownMenu.CheckboxItem bind:checked={() => groupByProject, (v) => setGroupByProject(!!v)}>{m.containers_group_by_project()}</DropdownMenu.CheckboxItem>+ <DropdownMenu.CheckboxItem bind:checked={() => showInternal, (v) => setShowInternal(!!v)}>+ {`${m.common_show()} ${m.internal()} ${m.containers_title()}`}+ </DropdownMenu.CheckboxItem>{/snippet}{#snippet GroupedTableView({diff --git a/frontend/src/routes/(app)/volumes/[volumeName]/+page.svelte b/frontend/src/routes/(app)/volumes/[volumeName]/+page.svelteindex 4255d330c..ee118ae8e 100644--- a/frontend/src/routes/(app)/volumes/[volumeName]/+page.svelte+++ b/frontend/src/routes/(app)/volumes/[volumeName]/+page.svelte@@ -14,16 +14,32 @@import { untrack } from 'svelte';import { volumeService } from '$lib/services/volume-service.js';import { ResourceDetailLayout, type DetailAction } from '$lib/layouts';+ import TabbedPageLayout from '$lib/layouts/tabbed-page-layout.svelte';+ import { VolumeBrowser } from '$lib/components/file-browser';+ import BackupList from '../components/volume-backup-table.svelte';+ import settingsStore from '$lib/stores/config-store';let { data } = $props();let volume = $state(untrack(() => data.volume));let containersDetailed = $state<{ id: string; name: string }[]>(untrack(() => data.containersDetailed ?? []));+ const backupVolumeName = $derived.by(() => $settingsStore?.backupVolumeName || 'arcane-backups');+ const isBackupVolume = $derived(volume?.name === backupVolumeName);+let isLoading = $state({ remove: false });const createdDate = $derived(volume.createdAt ? format(new Date(volume.createdAt), 'PP p') : m.common_unknown());+ let selectedTab = $state('overview');++ const tabItems = $derived([+ { value: 'overview', label: m.common_overview() },+ { value: 'browser', label: m.volumes_nav_browser() },+ { value: 'backups', label: m.volumes_nav_backups() }+ ]);+async function handleRemoveVolumeConfirm(volumeName: string) {const safeName = volumeName?.trim() || m.common_unknown();+ if (safeName === backupVolumeName) return;const message = volume.inUse? `${m.volumes_remove_confirm_message({ name: safeName })}\n\n${m.volumes_remove_in_use_warning()}`: m.volumes_remove_confirm_message({ name: safeName });@@ -55,242 +71,287 @@action: 'remove',label: m.common_remove(),loading: isLoading.remove,- disabled: isLoading.remove,+ disabled: isLoading.remove || isBackupVolume,onclick: () => handleRemoveVolumeConfirm(volume.name)}]);-</script>--<ResourceDetailLayout backUrl="/volumes" backLabel={m.volumes_title()} title={volume.name} {actions}>- {#snippet badges()}- {#if volume.inUse}- <StatusBadge variant="green" text={m.common_in_use()} />- {:else}- <StatusBadge variant="amber" text={m.common_unused()} />- {/if}- {#if volume.driver}- <StatusBadge variant="blue" text={volume.driver} />- {/if}- {#if volume.scope}- <StatusBadge variant="purple" text={volume.scope} />- {/if}- {/snippet}- {#if volume}- <div class="space-y-6">- <Card.Root>- <Card.Header icon={InfoIcon}>- <div class="flex flex-col space-y-1.5">- <Card.Title>{m.common_details_title({ resource: m.resource_volume_cap() })}</Card.Title>- <Card.Description>{m.common_details_description({ resource: m.resource_volume() })}</Card.Description>- </div>- </Card.Header>- <Card.Content class="p-4">- <div class="grid grid-cols-1 gap-x-4 gap-y-6 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-6">- <div class="flex items-start gap-3">- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-gray-500/10 p-2">- <BoxIcon class="size-5 text-gray-500" />- </div>- <div class="min-w-0 flex-1">- <p class="text-muted-foreground text-sm font-medium">{m.common_name()}</p>- <p class="mt-1 cursor-pointer text-sm font-semibold break-all select-all sm:text-base" title="Click to select">- {volume.name}- </p>- </div>- </div>-- <div class="flex items-start gap-3">- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-blue-500/10 p-2">- <VolumesIcon class="size-5 text-blue-500" />- </div>- <div class="min-w-0 flex-1">- <p class="text-muted-foreground text-sm font-medium">{m.common_driver()}</p>- <p class="mt-1 cursor-pointer text-sm font-semibold select-all sm:text-base" title="Click to select">- {volume.driver}- </p>- </div>- </div>+ function onTabChange(value: string) {+ selectedTab = value;+ }+</script>- <div class="flex items-start gap-3">- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-green-500/10 p-2">- <ClockIcon class="size-5 text-green-500" />- </div>- <div class="min-w-0 flex-1">- <p class="text-muted-foreground text-sm font-medium">{m.common_created()}</p>- <p class="mt-1 cursor-pointer text-sm font-semibold select-all sm:text-base" title="Click to select">- {createdDate}- </p>- </div>- </div>+{#if volume}+ <TabbedPageLayout backUrl="/volumes" backLabel={m.volumes_title()} {tabItems} {selectedTab} {onTabChange}>+ {#snippet headerInfo()}+ <div class="flex flex-col gap-1">+ <h1 class="text-2xl font-bold tracking-tight break-all sm:text-3xl">{volume.name}</h1>+ <div class="flex flex-wrap items-center gap-2 pt-1">+ {#if volume.inUse}+ <StatusBadge variant="green" text={m.common_in_use()} />+ {:else}+ <StatusBadge variant="amber" text={m.common_unused()} />+ {/if}+ {#if volume.driver}+ <StatusBadge variant="blue" text={volume.driver} />+ {/if}+ {#if volume.scope}+ <StatusBadge variant="purple" text={volume.scope} />+ {/if}+ </div>+ </div>+ {/snippet}- <div class="flex items-start gap-3">- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-purple-500/10 p-2">- <GlobeIcon class="size-5 text-purple-500" />- </div>- <div class="min-w-0 flex-1">- <p class="text-muted-foreground text-sm font-medium">{m.common_scope()}</p>- <p class="mt-1 cursor-pointer text-sm font-semibold capitalize select-all sm:text-base" title="Click to select">- {volume.scope}- </p>- </div>- </div>+ {#snippet headerActions()}+ <div class="flex items-center gap-2">+ {#each actions as act (act.id)}+ <ArcaneButton+ action={act.action}+ customLabel={act.label}+ loading={act.loading}+ disabled={act.disabled}+ onclick={act.onclick}+ />+ {/each}+ </div>+ {/snippet}- <div class="flex items-start gap-3">- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-amber-500/10 p-2">- <InfoIcon class="size-5 text-amber-500" />- </div>- <div class="min-w-0 flex-1">- <p class="text-muted-foreground text-sm font-medium">{m.common_status()}</p>- <p class="mt-1 text-base font-semibold">- {#if volume.inUse}- <StatusBadge variant="green" text={m.common_in_use()} />- {:else}- <StatusBadge variant="amber" text={m.common_unused()} />- {/if}- </p>+ {#snippet tabContent(tab)}+ <div class="space-y-6">+ {#if tab === 'overview'}+ <Card.Root>+ <Card.Header icon={InfoIcon}>+ <div class="flex flex-col space-y-1.5">+ <Card.Title>{m.common_details_title({ resource: m.resource_volume_cap() })}</Card.Title>+ <Card.Description>{m.common_details_description({ resource: m.resource_volume() })}</Card.Description></div>- </div>+ </Card.Header>+ <Card.Content class="p-4">+ <div class="grid grid-cols-1 gap-x-4 gap-y-6 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-6">+ <div class="flex items-start gap-3">+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-gray-500/10 p-2">+ <BoxIcon class="size-5 text-gray-500" />+ </div>+ <div class="min-w-0 flex-1">+ <p class="text-muted-foreground text-sm font-medium">{m.common_name()}</p>+ <p+ class="mt-1 cursor-pointer text-sm font-semibold break-all select-all sm:text-base"+ title="Click to select"+ >+ {volume.name}+ </p>+ </div>+ </div>- <div class="col-span-1 flex items-start gap-3 sm:col-span-2 lg:col-span-3 xl:col-span-4 2xl:col-span-6">- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-teal-500/10 p-2">- <LayersIcon class="size-5 text-teal-500" />- </div>- <div class="min-w-0 flex-1">- <p class="text-muted-foreground text-sm font-medium">{m.common_mountpoint()}</p>- <div class="bg-muted/50 mt-2 cursor-pointer rounded-lg border p-3 select-all" title="Click to select">- <code class="font-mono text-sm break-all">{volume.mountpoint}</code>+ <div class="flex items-start gap-3">+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-blue-500/10 p-2">+ <VolumesIcon class="size-5 text-blue-500" />+ </div>+ <div class="min-w-0 flex-1">+ <p class="text-muted-foreground text-sm font-medium">{m.common_driver()}</p>+ <p class="mt-1 cursor-pointer text-sm font-semibold select-all sm:text-base" title="Click to select">+ {volume.driver}+ </p>+ </div></div>- </div>- </div>- </div>- </Card.Content>- </Card.Root>- <Card.Root>- <Card.Header icon={ContainersIcon}>- <div class="flex flex-col space-y-1.5">- <Card.Title>{m.volumes_containers_using_title()}</Card.Title>- <Card.Description>{m.volumes_containers_using_description()}</Card.Description>- </div>- </Card.Header>- <Card.Content class="p-4">- {#if containersDetailed.length > 0}- <Card.Root variant="outlined">- <Card.Content class="divide-y p-0">- {#each containersDetailed as c (c.id)}- <div class="flex flex-col p-3 sm:flex-row sm:items-center">- <div class="mb-2 w-full font-medium break-all sm:mb-0 sm:w-1/3">- <a href="/containers/{c.id}" class="text-primary flex items-center hover:underline">- <ContainersIcon class="text-muted-foreground mr-1.5 size-3.5" />- {c.name}- </a>- </div>- <div class="w-full pl-0 sm:w-2/3 sm:pl-4">- <code- class="bg-muted text-muted-foreground cursor-pointer rounded px-1.5 py-0.5 font-mono text-xs break-all select-all sm:text-sm"- title="Click to select"- >- {truncateString(c.id, 48)}- </code>- </div>+ <div class="flex items-start gap-3">+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-green-500/10 p-2">+ <ClockIcon class="size-5 text-green-500" /></div>- {/each}- </Card.Content>- </Card.Root>- {:else if volume.containers && volume.containers.length > 0}- <!-- Fallback to IDs if names not resolved -->- <Card.Root variant="subtle">- <Card.Content class="divide-y p-0">- {#each volume.containers as id (id)}- <div class="flex items-center justify-between gap-3 p-3">- <code class="font-mono text-sm break-all">{truncateString(id, 48)}</code>- <a href={`/containers/${id}`} class="text-primary text-sm hover:underline">{m.common_view()}</a>+ <div class="min-w-0 flex-1">+ <p class="text-muted-foreground text-sm font-medium">{m.common_created()}</p>+ <p class="mt-1 cursor-pointer text-sm font-semibold select-all sm:text-base" title="Click to select">+ {createdDate}+ </p></div>- {/each}- </Card.Content>- </Card.Root>- {:else}- <div class="text-muted-foreground">{m.volumes_no_containers_using()}</div>- {/if}- </Card.Content>- </Card.Root>+ </div>- {#if volume.labels && Object.keys(volume.labels).length > 0}- <Card.Root>- <Card.Header icon={TagIcon}>- <div class="flex flex-col space-y-1.5">- <Card.Title>{m.common_labels()}</Card.Title>- <Card.Description>{m.volumes_labels_description()}</Card.Description>- </div>- </Card.Header>- <Card.Content class="p-4">- <div class="grid grid-cols-1 gap-3 lg:grid-cols-2 2xl:grid-cols-3">- {#each Object.entries(volume.labels) as [key, value] (key)}- <Card.Root variant="subtle">- <Card.Content class="flex flex-col gap-2 p-4">- <div class="text-muted-foreground text-xs font-semibold tracking-wide break-all uppercase">{key}</div>- <div- class="text-foreground cursor-pointer font-mono text-sm font-medium break-all select-all"+ <div class="flex items-start gap-3">+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-purple-500/10 p-2">+ <GlobeIcon class="size-5 text-purple-500" />+ </div>+ <div class="min-w-0 flex-1">+ <p class="text-muted-foreground text-sm font-medium">{m.common_scope()}</p>+ <p+ class="mt-1 cursor-pointer text-sm font-semibold capitalize select-all sm:text-base"title="Click to select">- {value}+ {volume.scope}+ </p>+ </div>+ </div>++ <div class="flex items-start gap-3">+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-amber-500/10 p-2">+ <InfoIcon class="size-5 text-amber-500" />+ </div>+ <div class="min-w-0 flex-1">+ <p class="text-muted-foreground text-sm font-medium">{m.common_status()}</p>+ <p class="mt-1 text-base font-semibold">+ {#if volume.inUse}+ <StatusBadge variant="green" text={m.common_in_use()} />+ {:else}+ <StatusBadge variant="amber" text={m.common_unused()} />+ {/if}+ </p>+ </div>+ </div>++ <div class="col-span-1 flex items-start gap-3 sm:col-span-2 lg:col-span-3 xl:col-span-4 2xl:col-span-6">+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-teal-500/10 p-2">+ <LayersIcon class="size-5 text-teal-500" />+ </div>+ <div class="min-w-0 flex-1">+ <p class="text-muted-foreground text-sm font-medium">{m.common_mountpoint()}</p>+ <div class="bg-muted/50 mt-2 cursor-pointer rounded-lg border p-3 select-all" title="Click to select">+ <code class="font-mono text-sm break-all">{volume.mountpoint}</code></div>+ </div>+ </div>+ </div>+ </Card.Content>+ </Card.Root>++ <Card.Root>+ <Card.Header icon={ContainersIcon}>+ <div class="flex flex-col space-y-1.5">+ <Card.Title>{m.volumes_containers_using_title()}</Card.Title>+ <Card.Description>{m.volumes_containers_using_description()}</Card.Description>+ </div>+ </Card.Header>+ <Card.Content class="p-4">+ {#if containersDetailed.length > 0}+ <Card.Root variant="outlined">+ <Card.Content class="divide-y p-0">+ {#each containersDetailed as c (c.id)}+ <div class="flex flex-col p-3 sm:flex-row sm:items-center">+ <div class="mb-2 w-full font-medium break-all sm:mb-0 sm:w-1/3">+ <a href="/containers/{c.id}" class="text-primary flex items-center hover:underline">+ <ContainersIcon class="text-muted-foreground mr-1.5 size-3.5" />+ {c.name}+ </a>+ </div>+ <div class="w-full pl-0 sm:w-2/3 sm:pl-4">+ <code+ class="bg-muted text-muted-foreground cursor-pointer rounded px-1.5 py-0.5 font-mono text-xs break-all select-all sm:text-sm"+ title="Click to select"+ >+ {truncateString(c.id, 48)}+ </code>+ </div>+ </div>+ {/each}</Card.Content></Card.Root>- {/each}- </div>- </Card.Content>- </Card.Root>- {/if}-- {#if volume.options && Object.keys(volume.options).length > 0}- <Card.Root>- <Card.Header icon={VolumesIcon}>- <div class="flex flex-col space-y-1.5">- <Card.Title>{m.common_driver_options()}</Card.Title>- <Card.Description>{m.volumes_driver_options_description()}</Card.Description>- </div>- </Card.Header>- <Card.Content class="p-4">- <div class="grid grid-cols-1 gap-3 lg:grid-cols-2 2xl:grid-cols-3">- {#each Object.entries(volume.options) as [key, value] (key)}+ {:else if volume.containers && volume.containers.length > 0}+ <!-- Fallback to IDs if names not resolved --><Card.Root variant="subtle">- <Card.Content class="flex flex-col gap-2 p-4">- <div class="text-muted-foreground text-xs font-semibold tracking-wide break-all uppercase">{key}</div>- <div- class="text-foreground cursor-pointer font-mono text-sm font-medium break-all select-all"- title="Click to select"- >- {value}- </div>+ <Card.Content class="divide-y p-0">+ {#each volume.containers as id (id)}+ <div class="flex items-center justify-between gap-3 p-3">+ <code class="font-mono text-sm break-all">{truncateString(id, 48)}</code>+ <a href={`/containers/${id}`} class="text-primary text-sm hover:underline">{m.common_view()}</a>+ </div>+ {/each}</Card.Content></Card.Root>- {/each}- </div>- </Card.Content>- </Card.Root>- {/if}+ {:else}+ <div class="text-muted-foreground">{m.volumes_no_containers_using()}</div>+ {/if}+ </Card.Content>+ </Card.Root>- {#if (!volume.labels || Object.keys(volume.labels).length === 0) && (!volume.options || Object.keys(volume.options).length === 0)}- <Card.Root class="bg-muted/10 border shadow-sm">- <Card.Content class="pt-6 pb-6 text-center">- <div class="flex flex-col items-center justify-center">- <div class="bg-muted/30 mb-4 rounded-full p-3">- <TagIcon class="text-muted-foreground size-5 opacity-50" />- </div>- <p class="text-muted-foreground">{m.volumes_no_labels_or_options()}</p>- </div>- </Card.Content>- </Card.Root>- {/if}- </div>- {:else}+ {#if volume.labels && Object.keys(volume.labels).length > 0}+ <Card.Root>+ <Card.Header icon={TagIcon}>+ <div class="flex flex-col space-y-1.5">+ <Card.Title>{m.common_labels()}</Card.Title>+ <Card.Description>{m.volumes_labels_description()}</Card.Description>+ </div>+ </Card.Header>+ <Card.Content class="p-4">+ <div class="grid grid-cols-1 gap-3 lg:grid-cols-2 2xl:grid-cols-3">+ {#each Object.entries(volume.labels) as [key, value] (key)}+ <Card.Root variant="subtle">+ <Card.Content class="flex flex-col gap-2 p-4">+ <div class="text-muted-foreground text-xs font-semibold tracking-wide break-all uppercase">+ {key}+ </div>+ <div+ class="text-foreground cursor-pointer font-mono text-sm font-medium break-all select-all"+ title="Click to select"+ >+ {value}+ </div>+ </Card.Content>+ </Card.Root>+ {/each}+ </div>+ </Card.Content>+ </Card.Root>+ {/if}++ {#if volume.options && Object.keys(volume.options).length > 0}+ <Card.Root>+ <Card.Header icon={VolumesIcon}>+ <div class="flex flex-col space-y-1.5">+ <Card.Title>{m.common_driver_options()}</Card.Title>+ <Card.Description>{m.volumes_driver_options_description()}</Card.Description>+ </div>+ </Card.Header>+ <Card.Content class="p-4">+ <div class="grid grid-cols-1 gap-3 lg:grid-cols-2 2xl:grid-cols-3">+ {#each Object.entries(volume.options) as [key, value] (key)}+ <Card.Root variant="subtle">+ <Card.Content class="flex flex-col gap-2 p-4">+ <div class="text-muted-foreground text-xs font-semibold tracking-wide break-all uppercase">+ {key}+ </div>+ <div+ class="text-foreground cursor-pointer font-mono text-sm font-medium break-all select-all"+ title="Click to select"+ >+ {value}+ </div>+ </Card.Content>+ </Card.Root>+ {/each}+ </div>+ </Card.Content>+ </Card.Root>+ {/if}++ {#if (!volume.labels || Object.keys(volume.labels).length === 0) && (!volume.options || Object.keys(volume.options).length === 0)}+ <Card.Root class="bg-muted/10 border shadow-sm">+ <Card.Content class="pt-6 pb-6 text-center">+ <div class="flex flex-col items-center justify-center">+ <div class="bg-muted/30 mb-4 rounded-full p-3">+ <TagIcon class="text-muted-foreground size-5 opacity-50" />+ </div>+ <p class="text-muted-foreground">{m.volumes_no_labels_or_options()}</p>+ </div>+ </Card.Content>+ </Card.Root>+ {/if}+ {:else if tab === 'browser'}+ <VolumeBrowser volumeName={volume.name} />+ {:else if tab === 'backups'}+ <BackupList volumeName={volume.name} />+ {/if}+ </div>+ {/snippet}+ </TabbedPageLayout>+{:else}+ <ResourceDetailLayout backUrl="/volumes" backLabel={m.volumes_title()} title="Volume" {actions}><div class="flex flex-col items-center justify-center px-4 py-16 text-center"><div class="bg-muted/30 mb-4 rounded-full p-4"><BoxIcon class="text-muted-foreground size-10 opacity-70" /></div><h2 class="mb-2 text-xl font-medium">{m.common_not_found_title({ resource: m.volumes_title() })}</h2>- <p class="text-muted-foreground mb-6">{m.common_not_found_description({ resource: m.volumes_title().toLowerCase() })}</p>+ <p class="text-muted-foreground mb-6">+ {m.common_not_found_description({ resource: m.volumes_title().toLowerCase() })}+ </p><ArcaneButtonaction="cancel"@@ -299,5 +360,5 @@size="sm"/></div>- {/if}-</ResourceDetailLayout>+ </ResourceDetailLayout>+{/if}diff --git a/frontend/src/routes/(app)/volumes/components/volume-backup-table.svelte b/frontend/src/routes/(app)/volumes/components/volume-backup-table.sveltenew file mode 100644index 000000000..918b215ab--- /dev/null+++ b/frontend/src/routes/(app)/volumes/components/volume-backup-table.svelte@@ -0,0 +1,412 @@+<script lang="ts">+import { volumeBackupService, type VolumeBackupListResponse } from '$lib/services/volume-backup-service';+ import { volumeService } from '$lib/services/volume-service';+ import type { BackupEntry } from '$lib/types/file-browser.type';+ import { onMount } from 'svelte';+ import {+ LoadingSpinnerIcon,+ TrashIcon,+ AddIcon,+ ClockIcon,+ VolumesIcon,+ InfoIcon,+ DownloadIcon,+ RestartIcon,+ EllipsisIcon,+ FileTextIcon,+ AlertIcon+ } from '$lib/icons';+ import { ArcaneButton } from '$lib/components/arcane-button';+ import { toast } from 'svelte-sonner';+ import * as m from '$lib/paraglide/messages.js';+ import bytes from 'bytes';+ import { format } from 'date-fns';+ import ArcaneTable from '$lib/components/arcane-table/arcane-table.svelte';+import type { SearchPaginationSortRequest } from '$lib/types/pagination.type';+ import { UniversalMobileCard, type ColumnSpec, type MobileFieldVisibility } from '$lib/components/arcane-table';+ import * as DropdownMenu from '$lib/components/ui/dropdown-menu';+ import { openConfirmDialog } from '$lib/components/confirm-dialog';+ import { ResponsiveDialog } from '$lib/components/ui/responsive-dialog';+ import { Input } from '$lib/components/ui/input';+ import { ScrollArea } from '$lib/components/ui/scroll-area';+ import * as Checkbox from '$lib/components/ui/checkbox';+ import * as Alert from '$lib/components/ui/alert';++ let { volumeName }: { volumeName: string } = $props();++let backupsPaginated = $state<VolumeBackupListResponse>({+ data: [],+ pagination: {+ currentPage: 1,+ totalPages: 1,+ totalItems: 0,+ itemsPerPage: 10+ }+});+let backupWarnings = $state<string[]>([]);++ let requestOptions = $state<SearchPaginationSortRequest>({+ pagination: { page: 1, limit: 10 },+ sort: { column: 'createdAt', direction: 'desc' }+ });++ let loading = $state(true);+ let creating = $state(false);+ let restoringFiles = $state(false);+ let showRestoreFiles = $state(false);+ let restoreTarget = $state<BackupEntry | null>(null);+ let backupFiles = $state<string[]>([]);+ let backupFilesLoading = $state(false);+ let backupFilesSearch = $state('');+ let selectedPaths = $state<string[]>([]);+ const filteredBackupFiles = $derived.by(() => {+ const q = backupFilesSearch.trim().toLowerCase();+ if (!q) return backupFiles;+ return backupFiles.filter((p) => p.toLowerCase().includes(q));+ });++ async function loadData(options: SearchPaginationSortRequest): Promise<VolumeBackupListResponse> {+ loading = true;+ try {+ const result = await volumeBackupService.listBackups(volumeName, options);+ backupsPaginated = result;+ backupWarnings = result.warnings ?? [];+ return result;+ } catch (e: any) {+ toast.error(e.message || 'Failed to load backups');+ return backupsPaginated;+ } finally {+ loading = false;+ }+ }++ async function handleCreate() {+ creating = true;+ try {+ await volumeBackupService.createBackup(volumeName);+ toast.success(m.common_success());+ await loadData(requestOptions);+ } catch (e: any) {+ toast.error(e.message || m.common_failed());+ } finally {+ creating = false;+ }+ }++ async function handleDelete(backup: BackupEntry) {+ openConfirmDialog({+ title: m.common_remove_title({ resource: 'Backup' }),+ message: m.volumes_backup_delete_confirm(),+ confirm: {+ label: m.common_remove(),+ destructive: true,+ action: async () => {+ try {+ await volumeBackupService.deleteBackup(backup.id);+ toast.success(m.common_delete_success({ resource: 'Backup' }));+ await loadData(requestOptions);+ } catch (e: any) {+ toast.error(e.message || m.common_delete_failed({ resource: 'Backup' }));+ }+ }+ }+ });+ }++ async function openRestoreFilesDialog(backup: BackupEntry) {+ restoreTarget = backup;+ selectedPaths = [];+ backupFiles = [];+ backupFilesSearch = '';+ showRestoreFiles = true;+ backupFilesLoading = true;+ try {+ backupFiles = await volumeBackupService.listBackupFiles(backup.id);+ } catch (e: any) {+ toast.error(e.message || m.common_failed());+ } finally {+ backupFilesLoading = false;+ }+ }++ function togglePath(path: string, checked: boolean) {+ if (checked) {+ if (!selectedPaths.includes(path)) {+ selectedPaths = [...selectedPaths, path];+ }+ return;+ }+ selectedPaths = selectedPaths.filter((p) => p !== path);+ }++ function selectAllVisible() {+ const next = new Set(selectedPaths);+ for (const p of filteredBackupFiles) {+ next.add(p);+ }+ selectedPaths = Array.from(next);+ }++ function clearSelection() {+ selectedPaths = [];+ }++ async function handleRestore(backup: BackupEntry) {+ // Check if volume is in use+ let usageWarning = '';+ try {+ const usage = await volumeService.getVolumeUsage(volumeName);+ if (usage.inUse && usage.containers?.length > 0) {+ usageWarning = m.volumes_backup_restore_in_use_warning({ count: usage.containers.length });+ }+ } catch {+ // Ignore errors checking usage+ }++ openConfirmDialog({+ title: m.volumes_backup_restore_title(),+ message: m.volumes_backup_restore_message({ volumeName }) + usageWarning,+ confirm: {+ label: m.volumes_backups_restore(),+ destructive: !!usageWarning,+ action: async () => {+ try {+ await volumeBackupService.restoreBackup(volumeName, backup.id);+ toast.success(m.volumes_backup_restore_success());+ await loadData(requestOptions);+ } catch (e: any) {+ toast.error(e.message || m.common_failed());+ }+ }+ }+ });+ }++ async function handleRestoreFiles() {+ if (!restoreTarget) return;+ if (!selectedPaths.length) return;++ restoringFiles = true;+ try {+ await volumeBackupService.restoreBackupFiles(volumeName, restoreTarget.id, selectedPaths);+ toast.success(m.volumes_backup_restore_files_success({ count: selectedPaths.length }));+ showRestoreFiles = false;+ } catch (e: any) {+ toast.error(e.message || m.common_failed());+ } finally {+ restoringFiles = false;+ }+ }++ function formatBytes(value: number): string {+ return bytes.format(value, { unitSeparator: ' ' }) ?? '-';+ }++ onMount(async () => {+ await loadData(requestOptions);+ });++ const columns = [+ { accessorKey: 'id', title: m.common_id(), sortable: true, cell: IdCell },+ { accessorKey: 'size', title: m.common_size(), sortable: true, cell: SizeCell },+ { accessorKey: 'createdAt', title: m.common_created(), sortable: true, cell: CreatedCell }+ ] satisfies ColumnSpec<BackupEntry>[];++ const mobileFields = [{ id: 'size', label: m.common_size(), defaultVisible: true }];++ let mobileFieldVisibility = $state<Record<string, boolean>>({});+</script>++{#snippet IdCell({ value }: { value: any })}+ <code class="font-mono text-xs font-medium">{value}</code>+{/snippet}++{#snippet SizeCell({ value }: { value: any })}+ {formatBytes(Number(value))}+{/snippet}++{#snippet CreatedCell({ value }: { value: any })}+ {format(new Date(String(value)), 'PP p')}+{/snippet}++{#snippet RowActions({ item }: { item: BackupEntry })}+ <DropdownMenu.Root>+ <DropdownMenu.Trigger>+ {#snippet child({ props })}+ <ArcaneButton+ {...props}+ action="base"+ tone="ghost"+ size="icon"+ class="relative size-8 p-0"+ icon={EllipsisIcon}+ showLabel={false}+ customLabel={m.common_open_menu()}+ />+ {/snippet}+ </DropdownMenu.Trigger>+ <DropdownMenu.Content align="end">+ <DropdownMenu.Group>+ <DropdownMenu.Item onclick={() => handleRestore(item)}>+ <RestartIcon class="size-4" />+ Restore+ </DropdownMenu.Item>+ <DropdownMenu.Item onclick={() => openRestoreFilesDialog(item)}>+ <FileTextIcon class="size-4" />+ Restore files+ </DropdownMenu.Item>+ <DropdownMenu.Item onclick={() => volumeBackupService.downloadBackup(item.id)}>+ <DownloadIcon class="size-4" />+ {m.templates_download()}+ </DropdownMenu.Item>+ <DropdownMenu.Separator />+ <DropdownMenu.Item variant="destructive" onclick={() => handleDelete(item)}>+ <TrashIcon class="size-4" />+ {m.common_remove()}+ </DropdownMenu.Item>+ </DropdownMenu.Group>+ </DropdownMenu.Content>+ </DropdownMenu.Root>+{/snippet}++{#snippet ToolbarActions()}+ <ArcaneButton+ action="create"+ customLabel={m.volumes_backup_create()}+ loading={creating}+ disabled={creating}+ onclick={handleCreate}+ size="sm"+ icon={AddIcon}+ />+{/snippet}++{#snippet BackupMobileCardSnippet({+ item,+ mobileFieldVisibility+}: {+ item: BackupEntry;+ mobileFieldVisibility: MobileFieldVisibility;+})}+ <UniversalMobileCard+ {item}+ icon={{ component: VolumesIcon, variant: 'blue' }}+ title={(item) => item.id}+ fields={[+ {+ label: m.common_size(),+ getValue: (item) => formatBytes(item.size),+ icon: InfoIcon,+ iconVariant: 'gray',+ show: mobileFieldVisibility.size ?? true+ }+ ]}+ footer={{+ label: m.common_created(),+ getValue: (item) => format(new Date(item.createdAt), 'PP p'),+ icon: ClockIcon+ }}+ rowActions={RowActions}+ />+{/snippet}++<div class="space-y-4">+ <div class="flex items-center justify-between">+ <h2 class="text-lg font-semibold">{m.volumes_backups_title()}</h2>+ </div>++ {#if backupWarnings.length > 0}+ <Alert.Root variant="warning" class="py-2 [&>svg]:top-2">+ <AlertIcon class="size-4" />+ <Alert.Description class="text-xs">+ {backupWarnings[0]}+ </Alert.Description>+ </Alert.Root>+ {/if}++ <ArcaneTable+ persistKey="arcane-volume-backup-table"+ items={backupsPaginated}+ bind:requestOptions+ bind:mobileFieldVisibility+ onRefresh={loadData}+ {columns}+ {mobileFields}+ rowActions={RowActions}+ mobileCard={BackupMobileCardSnippet}+ customToolbarActions={ToolbarActions}+ />+</div>++<ResponsiveDialog+ bind:open={showRestoreFiles}+ title="Restore files"+ description="Select files from this backup to restore."+ contentClass="sm:max-w-[640px]"+>+ {#snippet children()}+ <div class="space-y-3 py-2">+ <Alert.Root class="py-2 [&>svg]:top-2">+ <InfoIcon class="size-4" />+ <Alert.Description class="text-xs">+ {m.volumes_backup_safety_info()}+ </Alert.Description>+ </Alert.Root>++ <div class="flex items-center justify-between gap-2">+ <Input class="h-9" placeholder="Search files" bind:value={backupFilesSearch} />+ <div class="flex items-center gap-2">+ <ArcaneButton action="base" tone="ghost" size="sm" onclick={selectAllVisible} customLabel="Select all" />+ <ArcaneButton action="base" tone="ghost" size="sm" onclick={clearSelection} customLabel="Clear" />+ </div>+ </div>++ <ScrollArea class="h-64 rounded-md border">+ {#if backupFilesLoading}+ <div class="flex items-center justify-center py-8">+ <LoadingSpinnerIcon class="text-muted-foreground size-5" />+ </div>+ {:else if filteredBackupFiles.length === 0}+ <div class="text-muted-foreground flex items-center justify-center py-8 text-sm">No files found in this backup.</div>+ {:else}+ <div class="divide-border/40 divide-y">+ {#each filteredBackupFiles as filePath}+ <div class="flex items-center gap-3 px-3 py-2">+ <Checkbox.Root+ checked={selectedPaths.includes(filePath)}+ onCheckedChange={(value) => togglePath(filePath, !!value)}+ />+ <code class="font-mono text-xs break-all">{filePath}</code>+ </div>+ {/each}+ </div>+ {/if}+ </ScrollArea>++ <Alert.Root variant="warning" class="py-2 [&>svg]:top-2">+ <AlertIcon class="size-4" />+ <Alert.Description class="text-xs">+ {m.volumes_backup_overwrite_warning()}+ </Alert.Description>+ </Alert.Root>+ </div>+ {/snippet}++ {#snippet footer()}+ <ArcaneButton+ action="cancel"+ onclick={() => {+ showRestoreFiles = false;+ selectedPaths = [];+ backupFilesSearch = '';+ }}+ />+ <ArcaneButton+ action="create"+ customLabel="Restore files"+ onclick={handleRestoreFiles}+ loading={restoringFiles}+ disabled={restoringFiles || selectedPaths.length === 0}+ />+ {/snippet}+</ResponsiveDialog>diff --git a/frontend/src/routes/(app)/volumes/volume-table.svelte b/frontend/src/routes/(app)/volumes/volume-table.svelteindex 2b82cc242..e977c812c 100644--- a/frontend/src/routes/(app)/volumes/volume-table.svelte+++ b/frontend/src/routes/(app)/volumes/volume-table.svelte@@ -19,6 +19,7 @@import bytes from 'bytes';import { TrashIcon, EllipsisIcon, InspectIcon, VolumesIcon, CalendarIcon } from '$lib/icons';import { Spinner } from '$lib/components/ui/spinner';+ import settingsStore from '$lib/stores/config-store';let {volumes = $bindable(),@@ -34,6 +35,10 @@removing: false});+ const backupVolumeName = $derived.by(() => $settingsStore?.backupVolumeName || 'arcane-backups');+ const isBackupVolumeName = (name?: string) => (name ?? '') === backupVolumeName;+ const isBackupVolume = (item: VolumeSummaryDto) => isBackupVolumeName(item.name);+// Lazy load volume sizes - this is a slow operationlet volumeSizesPromise = $state<Promise<Map<string, VolumeSizeInfo>> | null>(null);@@ -51,6 +56,7 @@async function handleRemoveVolumeConfirm(name: string) {const safeName = name?.trim() || m.common_unknown();+ if (isBackupVolumeName(safeName)) return;openConfirmDialog({title: m.common_remove_title({ resource: m.resource_volume() }),message: m.common_remove_confirm({ resource: `${m.resource_volume()} "${safeName}"` }),@@ -88,8 +94,14 @@let failureCount = 0;const idToName = new Map(volumes.data.map((v) => [v.id, v.name] as const));+ const idsToDelete = ids.filter((id) => !isBackupVolumeName(idToName.get(id)));+ if (!idsToDelete.length) {+ isLoading.removing = false;+ selectedIds = [];+ return;+ }- for (const id of ids) {+ for (const id of idsToDelete) {const name = idToName.get(id);const safeName = name?.trim() || m.common_unknown();const result = await tryCatch(volumeService.deleteVolume(safeName));@@ -136,14 +148,19 @@{ id: 'driver', label: m.common_driver(), defaultVisible: true }];+ const deletableSelectedIds = $derived.by(() => {+ const idToName = new Map(volumes.data.map((v) => [v.id, v.name] as const));+ return (selectedIds ?? []).filter((id) => !isBackupVolumeName(idToName.get(id)));+ });+const bulkActions = $derived.by<BulkAction[]>(() => [{id: 'remove',- label: m.common_remove_selected_count({ count: selectedIds?.length ?? 0 }),+ label: m.common_remove_selected_count({ count: deletableSelectedIds.length }),action: 'remove',- onClick: handleDeleteSelected,+ onClick: () => handleDeleteSelected(deletableSelectedIds),loading: isLoading.removing,- disabled: isLoading.removing,+ disabled: isLoading.removing || deletableSelectedIds.length === 0,icon: TrashIcon}]);@@ -268,7 +285,11 @@<InspectIcon class="size-4" />{m.common_inspect()}</DropdownMenu.Item>- <DropdownMenu.Item variant="destructive" onclick={() => handleRemoveVolumeConfirm(item.name)} disabled={item.inUse}>+ <DropdownMenu.Item+ variant="destructive"+ onclick={() => handleRemoveVolumeConfirm(item.name)}+ disabled={item.inUse || isBackupVolume(item)}+ ><TrashIcon class="size-4" />{m.common_remove()}</DropdownMenu.Item>diff --git a/types/volume/backup.go b/types/volume/backup.gonew file mode 100644index 000000000..e9f9aca8f--- /dev/null+++ b/types/volume/backup.go@@ -0,0 +1,8 @@+package volume++type BackupEntry struct {+ ID string `json:"id" doc:"Unique identifier of the backup"`+ VolumeName string `json:"volumeName" doc:"Name of the volume"`+ Size int64 `json:"size" doc:"Size of the backup archive in bytes"`+ CreatedAt string `json:"createdAt" doc:"When the backup was created"`+}diff --git a/types/volume/browse.go b/types/volume/browse.gonew file mode 100644index 000000000..d690a1f1d--- /dev/null+++ b/types/volume/browse.go@@ -0,0 +1,21 @@+package volume++import "time"++type FileEntry struct {+ Name string `json:"name" doc:"Name of the file or directory"`+ Path string `json:"path" doc:"Full path to the file"`+ IsDirectory bool `json:"isDirectory" doc:"Whether this entry is a directory"`+ Size int64 `json:"size" doc:"Size of the file in bytes"`+ ModTime time.Time `json:"modTime" doc:"Last modification time"`+ Mode string `json:"mode" doc:"File mode/permissions"`+ IsSymlink bool `json:"isSymlink" doc:"Whether this entry is a symbolic link"`+ LinkTarget string `json:"linkTarget,omitempty" doc:"Target of the symbolic link"`+}++type FileMetadata struct {+ FileEntry+ MimeType string `json:"mimeType" doc:"MIME type of the file"`+ IsText bool `json:"isText" doc:"Whether the file is a text file"`+ IsBinary bool `json:"isBinary" doc:"Whether the file is a binary file"`+}