Skip to content

Modern Docker Management, Designed for Everyone

fix: allow disabling vulnerability management per environment (#3914)

Kyle Mendell4e432b30a694
diff --git a/backend/internal/bootstrap/jobs_bootstrap.go b/backend/internal/bootstrap/jobs_bootstrap.go
index 0662ada5b..63b91ba35 100644
--- a/backend/internal/bootstrap/jobs_bootstrap.go
+++ b/backend/internal/bootstrap/jobs_bootstrap.go
@@ -7,6 +7,8 @@ import (
"net/http"
"slices"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+
"emperror.dev/errors"
"github.com/getarcaneapp/arcane/backend/v2/internal/activity"
@@ -356,7 +358,7 @@ func setupSettingsSubscriptionsInternal(params settingsSubscriptionsParams) erro
subscribe(
[]string{
- "vulnerabilityScanEnabled", "vulnerabilityScanInterval", "trivyNetwork", "trivySecurityOpts", "trivyPrivileged",
+ features.VulnerabilityManagementSettingKey, "vulnerabilityScanEnabled", "vulnerabilityScanInterval", "trivyNetwork", "trivySecurityOpts", "trivyPrivileged",
"trivyResourceLimitsEnabled", "trivyCpuLimit", "trivyMemoryLimitMb", "trivyConcurrentScanContainers",
},
func(_ []libarcane.SettingUpdate) {
@@ -366,7 +368,7 @@ func setupSettingsSubscriptionsInternal(params settingsSubscriptionsParams) erro
},
)
- subscribe([]string{"imageAutoPatchEnabled", "imageAutoPatchInterval"}, func(_ []libarcane.SettingUpdate) {
+ subscribe([]string{features.VulnerabilityManagementSettingKey, "imageAutoPatchEnabled", "imageAutoPatchInterval"}, func(_ []libarcane.SettingUpdate) {
if err := params.Scheduler.RescheduleJob(params.LifecycleCtx, params.AutoPatch); err != nil {
slog.WarnContext(params.LifecycleCtx, "Failed to reschedule auto-patch job", "error", err)
}
diff --git a/backend/internal/bootstrap/jobs_bootstrap_test.go b/backend/internal/bootstrap/jobs_bootstrap_test.go
index cd1bea98e..cd4c5c488 100644
--- a/backend/internal/bootstrap/jobs_bootstrap_test.go
+++ b/backend/internal/bootstrap/jobs_bootstrap_test.go
@@ -11,17 +11,23 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/actors"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler"
+ "github.com/getarcaneapp/arcane/types/v2/features"
schedulertypes "github.com/getarcaneapp/arcane/types/v2/scheduler"
"github.com/stretchr/testify/require"
"go.uber.org/fx/fxtest"
)
type settingsSubscriptionStubInternal struct {
- pollingCallback func([]libarcane.SettingUpdate)
- timeoutCallback func([]libarcane.SettingUpdate)
+ featureCallbacks []func([]libarcane.SettingUpdate)
+ pollingCallback func([]libarcane.SettingUpdate)
+ timeoutCallback func([]libarcane.SettingUpdate)
}
func (s *settingsSubscriptionStubInternal) SubscribeSettingsChanges(keys []string, callback func([]libarcane.SettingUpdate)) func() {
+ if slices.Contains(keys, features.VulnerabilityManagementSettingKey) {
+ s.featureCallbacks = append(s.featureCallbacks, callback)
+ }
if slices.Contains(keys, "pollingEnabled") {
s.pollingCallback = callback
}
@@ -33,9 +39,13 @@ func (s *settingsSubscriptionStubInternal) SubscribeSettingsChanges(keys []strin
type settingsSubscriptionSchedulerStubInternal struct {
rescheduled chan struct{}
+ jobs []string
}
-func (s *settingsSubscriptionSchedulerStubInternal) RescheduleJob(context.Context, schedulertypes.Job) error {
+func (s *settingsSubscriptionSchedulerStubInternal) RescheduleJob(_ context.Context, job schedulertypes.Job) error {
+ if job != nil {
+ s.jobs = append(s.jobs, job.Name())
+ }
select {
case <-s.rescheduled:
default:
@@ -111,3 +121,29 @@ func TestSettingsTimeoutSyncDoesNotBlockOtherEffectsInternal(t *testing.T) {
defer cancel()
require.NoError(t, lifecycle.Stop(stopCtx))
}
+
+func TestFeatureChangeReschedulesScanAndPatchJobsInternal(t *testing.T) {
+ lifecycle := fxtest.NewLifecycle(t)
+ runtime, err := actors.NewRuntime(t.Context(), lifecycle)
+ require.NoError(t, err)
+ settings := &settingsSubscriptionStubInternal{}
+ schedulerStub := &settingsSubscriptionSchedulerStubInternal{rescheduled: make(chan struct{})}
+ require.NoError(t, setupSettingsSubscriptionsInternal(settingsSubscriptionsParams{
+ Lifecycle: lifecycle,
+ LifecycleCtx: t.Context(),
+ Config: &config.Config{},
+ Scheduler: schedulerStub,
+ ActorRuntime: runtime,
+ Settings: settings,
+ VulnerabilityScan: scheduler.NewVulnerabilityScanJob(nil, nil),
+ AutoPatch: scheduler.NewAutoPatchJob(nil, nil),
+ }))
+ require.Len(t, settings.featureCallbacks, 2)
+ for _, callback := range settings.featureCallbacks {
+ callback([]libarcane.SettingUpdate{{Key: features.VulnerabilityManagementSettingKey, Value: "false"}})
+ }
+ require.ElementsMatch(t, []string{scheduler.VulnerabilityScanJobName, scheduler.AutoPatchJobName}, schedulerStub.jobs)
+ stopCtx, cancel := context.WithTimeout(context.Background(), time.Second)
+ defer cancel()
+ require.NoError(t, lifecycle.Stop(stopCtx))
+}
diff --git a/backend/internal/common/api_error.go b/backend/internal/common/api_error.go
index 0853cd4e6..1194d505d 100644
--- a/backend/internal/common/api_error.go
+++ b/backend/internal/common/api_error.go
@@ -13,6 +13,7 @@ const (
APIErrorCodeBadRequest APIErrorCode = "BAD_REQUEST"
APIErrorCodeUnauthorized APIErrorCode = "UNAUTHORIZED"
APIErrorCodeForbidden APIErrorCode = "FORBIDDEN"
+ APIErrorCodeFeatureDisabled APIErrorCode = "feature_disabled"
APIErrorCodeNotFound APIErrorCode = "NOT_FOUND"
APIErrorCodeConflict APIErrorCode = "CONFLICT"
APIErrorCodeInternalServerError APIErrorCode = "INTERNAL_SERVER_ERROR"
@@ -113,6 +114,8 @@ func ToAPIError(err error) *APIError {
return NewAPIError(err.Error(), APIErrorCodeBadRequest, http.StatusBadRequest)
case errors.Is(err, ErrUnauthorized):
return NewAPIError(err.Error(), APIErrorCodeUnauthorized, http.StatusUnauthorized)
+ case errors.Is(err, ErrFeatureDisabled):
+ return NewAPIError(err.Error(), APIErrorCodeFeatureDisabled, http.StatusForbidden)
case errors.Is(err, ErrForbidden):
return NewAPIError(err.Error(), APIErrorCodeForbidden, http.StatusForbidden)
case errors.Is(err, ErrNotFound):
diff --git a/backend/internal/common/errors.go b/backend/internal/common/errors.go
index 864037287..19ae6b8d0 100644
--- a/backend/internal/common/errors.go
+++ b/backend/internal/common/errors.go
@@ -59,6 +59,7 @@ func (e *classified) Format(s fmt.State, verb rune) {
}
var (
+ ErrFeatureDisabled = Classify(ErrForbidden, errors.Sentinel("feature disabled"))
ErrInvalidToken = errors.Sentinel("invalid token")
ErrExpiredToken = errors.Sentinel("token expired")
ErrTokenVersionMismatch = errors.Sentinel("token version mismatch")
diff --git a/backend/internal/config/schema/schema.go b/backend/internal/config/schema/schema.go
index 222987b10..d7524dd44 100644
--- a/backend/internal/config/schema/schema.go
+++ b/backend/internal/config/schema/schema.go
@@ -126,8 +126,11 @@ var overrideDocRules = map[string]overrideDocRule{
"pruneBuildCacheUntil": {
requires: "SCHEDULED_PRUNE_ENABLED=true and PRUNE_BUILD_CACHE_MODE=olderThan to have effect at runtime.",
},
+ "featureVulnerabilityManagementEnabled": {
+ note: "Disabling retains existing reports and scanner settings, allows active work to finish, and leaves standalone image patching available.",
+ },
"vulnerabilityScanInterval": {
- requires: "VULNERABILITY_SCAN_ENABLED=true to have effect at runtime.",
+ requires: "FEATURE_VULNERABILITY_MANAGEMENT_ENABLED=true and VULNERABILITY_SCAN_ENABLED=true to have effect at runtime.",
},
"autoHealInterval": {
requires: "AUTO_HEAL_ENABLED=true to have effect at runtime.",
diff --git a/backend/internal/config/schema/schema_test.go b/backend/internal/config/schema/schema_test.go
index a6493c2dd..a628f0ffc 100644
--- a/backend/internal/config/schema/schema_test.go
+++ b/backend/internal/config/schema/schema_test.go
@@ -58,6 +58,12 @@ func TestGenerate_SettingEnvOverridesMatchModelMetadata(t *testing.T) {
assert.Equal(t, expectedSettingOverrideKeys, sortedSettingKeys(doc.SettingEnvOverrides))
entries := mapSettingOverrideEntries(doc.SettingEnvOverrides)
+ feature, ok := entries["featureVulnerabilityManagementEnabled"]
+ require.True(t, ok)
+ assert.Equal(t, "FEATURE_VULNERABILITY_MANAGEMENT_ENABLED", feature.Env)
+ assert.Equal(t, "true", feature.DefaultValue)
+ assert.Equal(t, "boolean", feature.Type)
+ assert.True(t, feature.Public)
dockerTimeout, ok := entries["dockerApiTimeout"]
require.True(t, ok)
@@ -304,6 +310,7 @@ var expectedSettingOverrideKeys = []string{
"eventCleanupInterval",
"experimentalFeaturesEnabled",
"expiredSessionsCleanupInterval",
+ "featureVulnerabilityManagementEnabled",
"followProjectSymlinks",
"gitOperationTimeout",
"gitSyncMaxBinarySizeMb",
diff --git a/backend/internal/imagepatch/handler.go b/backend/internal/imagepatch/handler.go
index 69c71c163..5682a5b7c 100644
--- a/backend/internal/imagepatch/handler.go
+++ b/backend/internal/imagepatch/handler.go
@@ -4,6 +4,8 @@ import (
"context"
"net/http"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+
"emperror.dev/errors"
"github.com/danielgtaylor/huma/v2"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
@@ -74,6 +76,8 @@ func (h *ImagePatchHandler) PatchImage(ctx context.Context, input *PatchImageInp
record, err := h.imagePatchService.PatchImage(runtimeCtx, input.EnvironmentID, input.ImageID, input.Body, *user)
if err != nil {
switch {
+ case errors.Is(err, common.ErrFeatureDisabled):
+ return nil, handlerutil.FeatureDisabledError(features.VulnerabilityManagement)
case errors.Is(err, common.ErrBadRequest):
return nil, huma.Error400BadRequest(err.Error())
case errors.Is(err, common.ErrNotFound):
@@ -97,6 +101,9 @@ func (h *ImagePatchHandler) ListPatchTargets(ctx context.Context, input *ListPat
targets, paginationResp, err := h.imagePatchService.ListPatchTargets(ctx, input.EnvironmentID, params)
if err != nil {
+ if errors.Is(err, common.ErrFeatureDisabled) {
+ return nil, handlerutil.FeatureDisabledError(features.VulnerabilityManagement)
+ }
return nil, huma.Error500InternalServerError(errors.WithMessage(err, "Failed to list image patch targets").Error())
}
if targets == nil {
diff --git a/backend/internal/imagepatch/imagepatch.go b/backend/internal/imagepatch/imagepatch.go
index 5aed299ea..fae0dc8c7 100644
--- a/backend/internal/imagepatch/imagepatch.go
+++ b/backend/internal/imagepatch/imagepatch.go
@@ -11,6 +11,8 @@ import (
"strings"
"time"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+
"emperror.dev/errors"
"github.com/containerd/platforms"
"github.com/distribution/reference"
@@ -86,6 +88,11 @@ func NewImagePatchService(db *database.DB, dockerService *docker.DockerClientSer
// PatchImage starts a background patch run for the given image and returns the
// pending record (carrying the activity ID) immediately.
func (s *ImagePatchService) PatchImage(ctx context.Context, envID, imageID string, opts imagepatch.PatchOptions, user common.User) (*imagepatch.PatchRecord, error) {
+ if strings.TrimSpace(opts.ScanID) != "" {
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ return nil, err
+ }
+ }
runCtx := utils.ActivityRuntimeContext(ctx, nil)
dockerClient, err := s.dockerService.GetClient(ctx)
@@ -197,6 +204,14 @@ func (s *ImagePatchService) patchInBackgroundInternal(ctx context.Context, recor
return
}
+ if record.Mode == string(imagepatch.PatchModeReport) {
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ s.finishPatchRecordInternal(ctx, record, imagepatch.PatchStatusFailed, err.Error(), nil, 0)
+ s.completePatchActivityInternal(ctx, activityID, false, err.Error())
+ return
+ }
+ }
+
// Copa consumes the scan report as a file; materialize the stored report
// into a temp file for the duration of the run.
reportPath := ""
@@ -289,6 +304,19 @@ func (s *ImagePatchService) patchInBackgroundInternal(ctx context.Context, recor
}
}
+ s.verifyPatchedImageInternal(ctx, record, activityID)
+
+ s.finishPatchRecordInternal(ctx, record, imagepatch.PatchStatusCompleted, "", packagesUpdated, durationMs)
+ slog.InfoContext(ctx, "image patch completed",
+ "environmentId", record.EnvironmentID,
+ "imageRef", record.OriginalRef,
+ "patchedRef", record.PatchedRef,
+ "durationMs", durationMs,
+ )
+ s.completePatchActivityInternal(ctx, activityID, true, "")
+}
+
+func (s *ImagePatchService) verifyPatchedImageInternal(ctx context.Context, record *ImagePatchRecord, activityID string) {
// Warn when the expected patched tag is missing from the daemon (e.g. copa
// took the multi-platform path and arch-suffixed the tag). When it exists,
// re-scan it so the security page can show whether the patch worked.
@@ -296,22 +324,13 @@ func (s *ImagePatchService) patchInBackgroundInternal(ctx context.Context, recor
if patchedInspect, err := dockerClient.ImageInspect(ctx, record.PatchedRef); err != nil {
slog.WarnContext(ctx, "patched image tag not found after patching", "patchedRef", record.PatchedRef, "error", err)
s.appendPatchActivityInternal(ctx, activityID, 95, "Patched image was created but the expected tag "+record.PatchedRef+" was not found; check the image list")
- } else if s.vulnerabilityService != nil {
+ } else if s.vulnerabilityService != nil && s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) {
s.appendPatchActivityInternal(ctx, activityID, 95, "Re-scanning patched image to verify the patch")
if _, err := s.vulnerabilityService.ScanImage(context.WithoutCancel(ctx), record.EnvironmentID, patchedInspect.ID, common.User{Username: "System"}); err != nil {
slog.WarnContext(ctx, "failed to start verification scan of patched image", "patchedRef", record.PatchedRef, "error", err)
}
}
}
-
- s.finishPatchRecordInternal(ctx, record, imagepatch.PatchStatusCompleted, "", packagesUpdated, durationMs)
- slog.InfoContext(ctx, "image patch completed",
- "environmentId", record.EnvironmentID,
- "imageRef", record.OriginalRef,
- "patchedRef", record.PatchedRef,
- "durationMs", durationMs,
- )
- s.completePatchActivityInternal(ctx, activityID, true, "")
}
// platformPinnedRefInternal resolves a tag reference to the manifest digest of
@@ -501,6 +520,9 @@ func (s *ImagePatchService) PatchedRefs(ctx context.Context, envID string) (map[
// that are themselves patch outputs are folded into their original's row: they
// are excluded from the list and surface as that row's LastPatchScan instead.
func (s *ImagePatchService) ListPatchTargets(ctx context.Context, envID string, params pagination.QueryParams) ([]imagepatch.PatchTarget, pagination.Response, error) {
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ return nil, pagination.Response{}, err
+ }
patchedRefs, err := s.PatchedRefs(ctx, envID)
if err != nil {
return nil, pagination.Response{}, err
@@ -670,6 +692,9 @@ func (s *ImagePatchService) latestPatchesByImageInternal(ctx context.Context, en
// images already patched since their latest scan. Used by the scheduled
// auto-patch job.
func (s *ImagePatchService) PatchFlaggedImages(ctx context.Context, envID string, user common.User) (patched, skipped int, err error) {
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ return 0, 0, err
+ }
var scans []vulnerability.VulnerabilityScanRecord
if err := s.db.WithContext(ctx).
Where("status = ? AND fixable_count > 0", vulnerability.ScanStatusCompleted).
@@ -685,6 +710,9 @@ func (s *ImagePatchService) PatchFlaggedImages(ctx context.Context, envID string
}
for i := range scans {
+ if !s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) {
+ return patched, skipped + len(scans) - i, errors.WrapIff(common.ErrFeatureDisabled, "remaining patches stopped because feature %s was disabled", features.VulnerabilityManagement)
+ }
scan := &scans[i]
if _, isPatchOutput := patchedRefs[scan.ImageName]; isPatchOutput {
diff --git a/backend/internal/imagepatch/imagepatch_feature_test.go b/backend/internal/imagepatch/imagepatch_feature_test.go
new file mode 100644
index 000000000..eefdfcbfa
--- /dev/null
+++ b/backend/internal/imagepatch/imagepatch_feature_test.go
@@ -0,0 +1,125 @@
+package imagepatch
+
+import (
+ "context"
+ "github.com/moby/moby/client"
+ "net/http"
+ "net/http/httptest"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/getarcaneapp/arcane/backend/v2/internal/actors"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/config"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/database"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/docker"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/settings"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/vulnerability"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+ "github.com/getarcaneapp/arcane/types/v2/imagepatch"
+ "github.com/libtnb/sqlite"
+ "github.com/stretchr/testify/require"
+ "go.uber.org/fx/fxtest"
+ "gorm.io/gorm"
+)
+
+func patchFeatureSettingsInternal(t *testing.T) (*settings.SettingsService, *database.DB) {
+ t.Helper()
+ gdb, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+ require.NoError(t, err)
+ require.NoError(t, gdb.AutoMigrate(&settings.SettingVariable{}, &vulnerability.VulnerabilityScanRecord{}, &vulnerability.VulnerabilityReportRecord{}, &ImagePatchRecord{}))
+ db := &database.DB{DB: gdb}
+ lifecycle := fxtest.NewLifecycle(t)
+ runtime, err := actors.NewRuntime(t.Context(), lifecycle)
+ require.NoError(t, err)
+ writes, err := actors.NewExecutor(t.Context(), runtime, "patch-feature-writes", t.Name(), 3)
+ require.NoError(t, err)
+ effects, err := actors.NewExecutor(t.Context(), runtime, "patch-feature-effects", t.Name(), 3)
+ require.NoError(t, err)
+ t.Cleanup(func() {
+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+ defer cancel()
+ require.NoError(t, writes.Stop(ctx))
+ require.NoError(t, effects.Stop(ctx))
+ require.NoError(t, lifecycle.Stop(ctx))
+ })
+ svc, err := settings.NewSettingsService(t.Context(), db, writes, effects)
+ require.NoError(t, err)
+ return svc, db
+}
+
+func TestVulnerabilityFeatureBlocksReportPatchesOnly(t *testing.T) {
+ settingsSvc, db := patchFeatureSettingsInternal(t)
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
+ svc := &ImagePatchService{
+ settingsService: settingsSvc,
+ db: db,
+ dockerService: docker.NewDockerClientService(t.Context(), nil, &config.Config{DockerHost: "unix:///nonexistent-arcane-feature-test.sock"}, nil),
+ }
+ _, err := svc.PatchImage(t.Context(), "0", "test-image", imagepatch.PatchOptions{ScanID: "test-image"}, common.User{})
+ require.ErrorIs(t, err, common.ErrFeatureDisabled)
+ _, _, err = svc.ListPatchTargets(t.Context(), "0", pagination.QueryParams{})
+ require.ErrorIs(t, err, common.ErrFeatureDisabled)
+ _, _, err = svc.PatchFlaggedImages(t.Context(), "0", common.User{})
+ require.ErrorIs(t, err, common.ErrFeatureDisabled)
+ // Standalone patching still reaches Docker; this test deliberately has no daemon.
+ _, err = svc.PatchImage(t.Context(), "0", "test-image", imagepatch.PatchOptions{}, common.User{})
+ require.Error(t, err)
+ require.NotErrorIs(t, err, common.ErrFeatureDisabled)
+ require.Contains(t, err.Error(), "failed to connect to Docker")
+}
+
+func TestQueuedReportPatchStopsWhenFeatureDisabled(t *testing.T) {
+ settingsSvc, db := patchFeatureSettingsInternal(t)
+ svc := &ImagePatchService{settingsService: settingsSvc, db: db, patchSlot: make(chan struct{}, 1)}
+ record := &ImagePatchRecord{EnvironmentID: "0", OriginalImageID: "test-image", Mode: string(imagepatch.PatchModeReport), Status: string(imagepatch.PatchStatusPatching)}
+ require.NoError(t, db.Create(record).Error)
+ svc.patchSlot <- struct{}{}
+ done := make(chan struct{})
+ go func() {
+ defer close(done)
+ svc.patchInBackgroundInternal(t.Context(), record, imagepatch.PatchOptions{ScanID: "test-image"}, nil, "", "")
+ }()
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
+ // The active patch owns its slot until it finishes normally.
+ require.Len(t, svc.patchSlot, 1)
+ <-svc.patchSlot
+ select {
+ case <-done:
+ case <-time.After(time.Second):
+ t.Fatal("queued patch did not stop")
+ }
+ var stored ImagePatchRecord
+ require.NoError(t, db.First(&stored, "id = ?", record.ID).Error)
+ require.Equal(t, string(imagepatch.PatchStatusFailed), stored.Status)
+ require.NotNil(t, stored.Error)
+ require.Contains(t, *stored.Error, string(features.VulnerabilityManagement))
+ require.Empty(t, svc.patchSlot)
+}
+
+func TestDisabledFeatureSkipsPatchVerificationScan(t *testing.T) {
+ settingsSvc, _ := patchFeatureSettingsInternal(t)
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
+ var inspected atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ inspected.Add(1)
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"Id":"patched-image"}`))
+ }))
+ defer server.Close()
+ dockerClient, err := client.New(client.WithHost(server.URL), client.WithAPIVersion("1.41"))
+ require.NoError(t, err)
+ defer dockerClient.Close()
+ svc := &ImagePatchService{
+ settingsService: settingsSvc,
+ dockerService: &docker.DockerClientService{Client: dockerClient},
+ // Any attempt to scan would access unconfigured dependencies and fail.
+ vulnerabilityService: &vulnerability.VulnerabilityService{},
+ }
+ require.NotPanics(t, func() {
+ svc.verifyPatchedImageInternal(t.Context(), &ImagePatchRecord{EnvironmentID: "0", PatchedRef: "test:patched"}, "")
+ })
+ require.Equal(t, int32(1), inspected.Load())
+}
diff --git a/backend/internal/settings/features.go b/backend/internal/settings/features.go
new file mode 100644
index 000000000..b4ff69a2d
--- /dev/null
+++ b/backend/internal/settings/features.go
@@ -0,0 +1,48 @@
+package settings
+
+import (
+ "context"
+ "strconv"
+
+ "emperror.dev/errors"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+)
+
+// IsFeatureEnabled resolves feature availability on this environment.
+func (s *SettingsService) IsFeatureEnabled(ctx context.Context, id features.ID) bool {
+ definition, ok := features.Lookup(id)
+ if !ok {
+ return false
+ }
+ if s == nil {
+ return definition.DefaultEnabled
+ }
+ cfg := s.GetSettingsOrDefaults(ctx)
+ value, _, _, err := cfg.FieldByKey(definition.SettingKey)
+ if err != nil || value == "" {
+ return definition.DefaultEnabled
+ }
+ enabled, err := strconv.ParseBool(value)
+ if err != nil {
+ return definition.DefaultEnabled
+ }
+ return enabled
+}
+
+// RequireFeature rejects operations when their runtime feature is disabled.
+func (s *SettingsService) RequireFeature(ctx context.Context, id features.ID) error {
+ if s.IsFeatureEnabled(ctx, id) {
+ return nil
+ }
+ return errors.WrapIff(common.ErrFeatureDisabled, "feature %s is disabled", id)
+}
+
+func validateFeatureSettingInternal(key, value string) error {
+ for _, definition := range features.All() {
+ if definition.SettingKey == key && value != "true" && value != "false" {
+ return common.Classify(common.ErrValidation, errors.Errorf("%s must be true or false", key))
+ }
+ }
+ return nil
+}
diff --git a/backend/internal/settings/features_test.go b/backend/internal/settings/features_test.go
new file mode 100644
index 000000000..40a0f3fbd
--- /dev/null
+++ b/backend/internal/settings/features_test.go
@@ -0,0 +1,101 @@
+package settings
+
+import (
+ "context"
+ "net/http"
+ "testing"
+
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+ settingstypes "github.com/getarcaneapp/arcane/types/v2/settings"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSettingsService_FeatureDefaultsAndUnknownFeature(t *testing.T) {
+ var svc *SettingsService
+ require.True(t, svc.IsFeatureEnabled(t.Context(), features.VulnerabilityManagement))
+ require.NoError(t, svc.RequireFeature(t.Context(), features.VulnerabilityManagement))
+ require.False(t, svc.IsFeatureEnabled(t.Context(), features.ID("unknown")))
+
+ svc, err := newSettingsServiceForTestInternal(t, t.Context(), setupSettingsTestDB(t))
+ require.NoError(t, err)
+ require.True(t, svc.IsFeatureEnabled(t.Context(), features.VulnerabilityManagement))
+ require.NoError(t, svc.EnsureDefaultSettings(t.Context()))
+ var stored SettingVariable
+ require.NoError(t, svc.db.Where("key = ?", features.VulnerabilityManagementSettingKey).First(&stored).Error)
+ require.Equal(t, "true", stored.Value)
+ require.Contains(t, svc.ListSettings(SettingVisibilityPublic), SettingVariable{Key: features.VulnerabilityManagementSettingKey, Value: "true"})
+}
+
+func TestSettingsService_FeaturePersistenceAndEnvironmentIsolation(t *testing.T) {
+ ctx := t.Context()
+ db := setupSettingsTestDB(t)
+ svc, err := newSettingsServiceForTestInternal(t, ctx, db)
+ require.NoError(t, err)
+ other, err := newSettingsServiceForTestInternal(t, ctx, setupSettingsTestDB(t))
+ require.NoError(t, err)
+
+ var notifications int
+ unsubscribe := svc.SubscribeSettingsChanges([]string{features.VulnerabilityManagementSettingKey}, func([]libarcane.SettingUpdate) { notifications++ })
+ defer unsubscribe()
+ scheduled := "true"
+ ignore := "CVE-2026-12345"
+ require.NoError(t, svc.UpdateSetting(ctx, "trivyIgnore", ignore))
+ _, err = svc.UpdateSettings(ctx, settingstypes.Update{VulnerabilityScanEnabled: &scheduled})
+ require.NoError(t, err)
+ disabled := "false"
+ _, err = svc.UpdateSettings(ctx, settingstypes.Update{FeatureVulnerabilityManagementEnabled: &disabled})
+ require.NoError(t, err)
+ waitForSettingsNotificationsInternal(t, svc)
+ require.Equal(t, 1, notifications)
+ require.False(t, svc.IsFeatureEnabled(ctx, features.VulnerabilityManagement))
+ require.True(t, other.IsFeatureEnabled(ctx, features.VulnerabilityManagement))
+ err = svc.RequireFeature(ctx, features.VulnerabilityManagement)
+ require.ErrorIs(t, err, common.ErrFeatureDisabled)
+ require.ErrorIs(t, err, common.ErrForbidden)
+ require.Contains(t, err.Error(), string(features.VulnerabilityManagement))
+ apiErr := common.ToAPIError(err)
+ require.Equal(t, http.StatusForbidden, apiErr.HTTPStatus())
+ require.Equal(t, common.APIErrorCodeFeatureDisabled, apiErr.Code)
+
+ reloaded, err := newSettingsServiceForTestInternal(t, ctx, db)
+ require.NoError(t, err)
+ require.False(t, reloaded.IsFeatureEnabled(ctx, features.VulnerabilityManagement))
+ enabled := "true"
+ _, err = svc.UpdateSettings(ctx, settingstypes.Update{FeatureVulnerabilityManagementEnabled: &enabled})
+ require.NoError(t, err)
+ require.True(t, svc.IsFeatureEnabled(ctx, features.VulnerabilityManagement))
+ cfg, err := svc.GetSettings(ctx)
+ require.NoError(t, err)
+ require.Equal(t, scheduled, cfg.VulnerabilityScanEnabled.Value)
+ require.Equal(t, ignore, cfg.TrivyIgnore.Value)
+}
+
+func TestSettingsService_FeatureEnvironmentOverride(t *testing.T) {
+ t.Setenv("FEATURE_VULNERABILITY_MANAGEMENT_ENABLED", "false")
+ svc, err := newSettingsServiceForTestInternal(t, t.Context(), setupSettingsTestDB(t))
+ require.NoError(t, err)
+ enabled := "true"
+ _, err = svc.UpdateSettings(t.Context(), settingstypes.Update{FeatureVulnerabilityManagementEnabled: &enabled})
+ require.NoError(t, err)
+ require.True(t, svc.IsEnvOverrideActive(features.VulnerabilityManagementSettingKey))
+ require.False(t, svc.IsFeatureEnabled(t.Context(), features.VulnerabilityManagement))
+ require.Contains(t, svc.ListSettings(SettingVisibilityPublic), SettingVariable{Key: features.VulnerabilityManagementSettingKey, Value: "false"})
+}
+
+func TestSettingsService_RejectInvalidFeatureBoolean(t *testing.T) {
+ for _, invalid := range []string{"", "yes", "0", "TRUE"} {
+ t.Run(invalid, func(t *testing.T) {
+ svc, err := newSettingsServiceForTestInternal(t, t.Context(), setupSettingsTestDB(t))
+ require.NoError(t, err)
+ _, err = svc.UpdateSettings(t.Context(), settingstypes.Update{FeatureVulnerabilityManagementEnabled: &invalid})
+ require.ErrorIs(t, err, common.ErrValidation)
+ err = svc.UpdateSetting(t.Context(), features.VulnerabilityManagementSettingKey, invalid)
+ require.ErrorIs(t, err, common.ErrValidation)
+ err = svc.UpdateSettingValues(context.Background(), []libarcane.SettingUpdate{{Key: features.VulnerabilityManagementSettingKey, Value: invalid}})
+ require.ErrorIs(t, err, common.ErrValidation)
+ require.True(t, svc.IsFeatureEnabled(t.Context(), features.VulnerabilityManagement))
+ })
+ }
+}
diff --git a/backend/internal/settings/model.go b/backend/internal/settings/model.go
index d4e686b3b..30b825209 100644
--- a/backend/internal/settings/model.go
+++ b/backend/internal/settings/model.go
@@ -124,50 +124,51 @@ type Settings struct {
DepotToken SettingVariable `key:"depotToken,envOverride,sensitive" meta:"label=Depot Token;type=password;keywords=depot,token,api,secret,build,provider;category=build;description=Depot API token"`
// Authentication and security categories
- AuthLocalEnabled SettingVariable `key:"authLocalEnabled,public" meta:"label=Local Authentication;type=boolean;keywords=local,auth,authentication,username,password,login,credentials;category=authentication;description=Enable local username/password authentication" catmeta:"id=authentication;title=Authentication;icon=lock;url=/settings/authentication;description=Manage authentication providers, password policy, and session behavior"`
- AuthSessionTimeout SettingVariable `key:"authSessionTimeout" meta:"label=Session Timeout;type=number;keywords=session,timeout,expire,duration,lifetime,minutes,logout;category=authentication;description=How long user sessions remain active"`
- AuthPasswordPolicy SettingVariable `key:"authPasswordPolicy" meta:"label=Password Policy;type=select;keywords=password,policy,strength,complexity,requirements,security,rules;category=authentication;description=Set password strength requirements"`
- VulnerabilityScanEnabled SettingVariable `key:"vulnerabilityScanEnabled" meta:"label=Scheduled Vulnerability Scan;type=boolean;keywords=vulnerability,scan,security,trivy,schedule,automatic,cve;category=security;description=Enable scheduled vulnerability scanning of all Docker images" catmeta:"id=security;title=Security;icon=shield;url=/settings/security;description=Configure vulnerability scanning and runtime security settings"`
- VulnerabilityScanInterval SettingVariable `key:"vulnerabilityScanInterval" meta:"label=Vulnerability Scan Interval;type=cron;keywords=vulnerability,scan,interval,schedule,frequency,trivy,cve;category=security;description=How often to run scheduled vulnerability scans (cron expression)"`
- TrivyDbRegistry SettingVariable `key:"trivyDbRegistry,envOverride" meta:"label=Trivy DB Registry;type=select;keywords=trivy,db,java-db,checks,registry,ghcr,docker,hub,vulnerability,security,scanner;category=security;description=Container registry used to pull the Trivy vulnerability database artifacts"`
- TrivyNetwork SettingVariable `key:"trivyNetwork,envOverride" meta:"label=Trivy Network;type=text;keywords=trivy,network,mode,bridge,host,none,scanner,vulnerability,security;category=security;description=Docker network mode/network name used for Trivy scan containers. Leave empty to inherit Arcane's network automatically."`
- TrivySecurityOpts SettingVariable `key:"trivySecurityOpts,envOverride" meta:"label=Trivy Security Options;type=textarea;keywords=trivy,security,opt,security_opt,selinux,labels,apparmor,scanner;category=security;description=Docker security options applied to Trivy scan containers. Use commas or new lines to separate entries (for example: label=disable)"`
- TrivyPrivileged SettingVariable `key:"trivyPrivileged,envOverride" meta:"label=Trivy Privileged;type=boolean;keywords=trivy,privileged,security,selinux,scanner;category=security;description=Run Trivy scan containers in privileged mode when required by the host security policy"`
- TrivyResourceLimitsEnabled SettingVariable `key:"trivyResourceLimitsEnabled,envOverride" meta:"label=Trivy Resource Limits;type=boolean;keywords=trivy,resources,limits,cpu,memory,ram,security,scan;category=security;description=Enable CPU and memory limits for Trivy scan containers"`
- TrivyCpuLimit SettingVariable `key:"trivyCpuLimit,envOverride" meta:"label=Trivy CPU Limit (cores);type=number;keywords=trivy,cpu,cores,limit,scanner,resources;category=security;description=Maximum CPU cores for Trivy scan containers (supports decimals, e.g. 1.5). Set 0 to disable CPU limit"`
- TrivyMemoryLimitMb SettingVariable `key:"trivyMemoryLimitMb,envOverride" meta:"label=Trivy Memory Limit (MB);type=number;keywords=trivy,memory,ram,mb,limit,scanner,resources;category=security;description=Maximum memory for Trivy scan containers in MB. Set 0 to disable memory limit"`
- TrivyConcurrentScanContainers SettingVariable `key:"trivyConcurrentScanContainers,envOverride" meta:"label=Trivy Concurrent Scan Containers;type=number;keywords=trivy,concurrent,scan,containers,parallel,workers,limit,security;category=security;description=Maximum number of concurrent Trivy scan containers for manual and scheduled scans. Minimum 1"`
- TrivyConfig SettingVariable `key:"trivyConfig" meta:"label=Trivy Config (YAML);type=textarea;keywords=trivy,config,yaml,configuration,scanner,settings;category=security;description=Trivy configuration file content in YAML format"`
- TrivyIgnore SettingVariable `key:"trivyIgnore" meta:"label=.trivyignore;type=textarea;keywords=trivy,ignore,ignorefile,vulnerabilities,exceptions,exclusions;category=security;description=Trivy ignore file content - one vulnerability ID per line"`
- TrivyServerEnabled SettingVariable `key:"trivyServerEnabled,envOverride" meta:"label=Trivy Client/Server Mode;type=boolean;keywords=trivy,server,client,remote,scanner,vulnerability,security,armv7,32bit;category=security;description=Scan against a remote Trivy server instead of downloading the vulnerability database locally. Recommended for 32-bit hosts (arm/v7) where the local DB cannot be memory-mapped."`
- TrivyServerUrl SettingVariable `key:"trivyServerUrl,envOverride" meta:"label=Trivy Server URL;type=text;keywords=trivy,server,url,remote,scanner,vulnerability,security;category=security;description=URL of the remote Trivy server (e.g. http://trivy.example.com:4954). Used when client/server mode is enabled."`
- TrivyServerToken SettingVariable `key:"trivyServerToken,envOverride,sensitive" meta:"label=Trivy Server Token;type=password;keywords=trivy,server,token,auth,remote,scanner,security;category=security;description=Optional authentication token sent to the remote Trivy server. Leave empty if the server requires no token."`
- TrivyIgnoreUnfixed SettingVariable `key:"trivyIgnoreUnfixed,envOverride" meta:"label=Only Report Fixable Vulnerabilities;type=boolean;keywords=trivy,fixable,unfixed,ignore,vulnerability,security,noise,fixes;category=security;description=Only report vulnerabilities that have a known fix available. Reduces noise from vulnerabilities you cannot act on."`
- ImagePatchSuffix SettingVariable `key:"imagePatchSuffix" meta:"label=Patched Image Tag Suffix;type=text;keywords=patch,copa,copacetic,image,tag,suffix,vulnerability,security;category=security;description=Suffix appended to the source tag when patching an image (default: patched)"`
- ImagePatchTimeoutSec SettingVariable `key:"imagePatchTimeoutSec,envOverride" meta:"label=Image Patch Timeout (seconds);type=number;keywords=patch,copa,copacetic,image,timeout,seconds,buildkit,security;category=security;description=Timeout for a single image patch operation in seconds (default: 600)"`
- ImagePatchAllPlatforms SettingVariable `key:"imagePatchAllPlatforms" meta:"label=Patch All Platforms;type=boolean;keywords=patch,copa,copacetic,image,platform,architecture,multi,arch,security;category=security;description=Patch every platform in a multi-platform image instead of only the platform this server runs on"`
- ImageAutoPatchEnabled SettingVariable `key:"imageAutoPatchEnabled" meta:"label=Scheduled Image Patching;type=boolean;keywords=patch,copa,copacetic,image,automatic,schedule,vulnerability,security,cve;category=security;description=Automatically patch images whose latest vulnerability scan found fixable OS package vulnerabilities"`
- ImageAutoPatchInterval SettingVariable `key:"imageAutoPatchInterval" meta:"label=Image Patch Interval;type=cron;keywords=patch,copa,copacetic,image,interval,schedule,frequency,cron,security;category=security;description=How often to run scheduled image patching (cron expression)"`
- LifecycleEnabled SettingVariable `key:"lifecycleEnabled,envOverride" meta:"label=Enable Lifecycle Hooks;type=boolean;keywords=lifecycle,hook,hooks,pre-deploy,script,gitops,sops,secrets;category=security;description=Allow GitOps syncs to configure pre-deploy lifecycle scripts. Disabled by default because scripts are repo-trusted code that runs on every deploy"`
- LifecycleDefaultRunnerImage SettingVariable `key:"lifecycleDefaultRunnerImage,envOverride" meta:"label=Lifecycle Hook Runner Image;type=text;keywords=lifecycle,hook,runner,image,container,pre-deploy,script,gitops;category=security;description=Default container image used to run GitOps pre-deploy lifecycle scripts when a sync does not override it"`
- LifecycleMaxTimeoutSec SettingVariable `key:"lifecycleMaxTimeoutSec,envOverride" meta:"label=Lifecycle Hook Max Timeout (seconds);type=number;keywords=lifecycle,hook,timeout,seconds,limit,maximum,script,pre-deploy;category=security;description=Maximum allowed timeout for lifecycle scripts in seconds (default: 300)"`
- OidcEnabled SettingVariable `key:"oidcEnabled,public,envOverride" meta:"label=OIDC Authentication;type=boolean;keywords=oidc,openid,connect,sso,oauth,external,provider,federation;category=authentication;description=Enable OpenID Connect (OIDC) authentication"`
- OidcClientId SettingVariable `key:"oidcClientId,authrequired,envOverride" meta:"label=OIDC Client ID;type=text;keywords=oidc,client,id,oauth,openid;category=authentication;description=OIDC provider client ID"`
- OidcClientSecret SettingVariable `key:"oidcClientSecret,sensitive,envOverride" meta:"label=OIDC Client Secret;type=password;keywords=oidc,client,secret,oauth,openid;category=authentication;description=OIDC provider client secret"`
- OidcIssuerUrl SettingVariable `key:"oidcIssuerUrl,authrequired,envOverride" meta:"label=OIDC Issuer URL;type=text;keywords=oidc,issuer,url,oauth,openid,provider;category=authentication;description=OIDC provider issuer URL"`
- OidcAuthorizationEndpoint SettingVariable `key:"oidcAuthorizationEndpoint,envOverride" meta:"label=OIDC Authorization Endpoint;type=text;keywords=oidc,authorization,endpoint,oauth,openid;category=authentication;description=Override OIDC authorization endpoint"`
- OidcTokenEndpoint SettingVariable `key:"oidcTokenEndpoint,envOverride" meta:"label=OIDC Token Endpoint;type=text;keywords=oidc,token,endpoint,oauth,openid;category=authentication;description=Override OIDC token endpoint"`
- OidcUserinfoEndpoint SettingVariable `key:"oidcUserinfoEndpoint,envOverride" meta:"label=OIDC Userinfo Endpoint;type=text;keywords=oidc,userinfo,endpoint,oauth,openid;category=authentication;description=Override OIDC userinfo endpoint"`
- OidcJwksEndpoint SettingVariable `key:"oidcJwksEndpoint,envOverride" meta:"label=OIDC JWKS Endpoint;type=text;keywords=oidc,jwks,keys,endpoint,oauth,openid;category=authentication;description=Override OIDC JWKS endpoint"`
- OidcDeviceAuthorizationEndpoint SettingVariable `key:"oidcDeviceAuthorizationEndpoint,envOverride" meta:"label=OIDC Device Authorization Endpoint;type=text;keywords=oidc,device,authorization,endpoint,oauth,openid,cli;category=authentication;description=Override OIDC device authorization endpoint for CLI authentication"`
- OidcScopes SettingVariable `key:"oidcScopes,authrequired,envOverride" meta:"label=OIDC Scopes;type=text;keywords=oidc,scopes,oauth,openid,permissions;category=authentication;description=OIDC scopes to request"`
- OidcGroupsClaim SettingVariable `key:"oidcGroupsClaim,authrequired,envOverride" meta:"label=OIDC Groups Claim;type=text;keywords=oidc,groups,claim,role,mapping,rbac;category=authentication;description=Claim name to read group memberships from for role mapping (default: groups)"`
- OidcSkipTlsVerify SettingVariable `key:"oidcSkipTlsVerify,authrequired,envOverride" meta:"label=OIDC Skip TLS Verify;type=boolean;keywords=oidc,tls,verify,skip,insecure;category=authentication;description=Skip TLS verification for OIDC provider"`
- OidcAutoRedirectToProvider SettingVariable `key:"oidcAutoRedirectToProvider,public,envOverride" meta:"label=OIDC Auto Redirect;type=boolean;keywords=oidc,auto,redirect,automatic,login,provider,sso;category=authentication;description=Automatically redirect to OIDC provider on login page"`
- OidcMergeAccounts SettingVariable `key:"oidcMergeAccounts,authrequired,envOverride" meta:"label=OIDC Account Merging;type=boolean;keywords=oidc,merge,link,accounts,email,match,existing,users,combine;category=authentication;description=Allow OIDC logins to merge with existing accounts by email"`
- OidcProviderName SettingVariable `key:"oidcProviderName,public,envOverride" meta:"label=OIDC Provider Name;type=text;keywords=oidc,provider,name,display,label,sso;category=authentication;description=Custom name for the OIDC provider (e.g., Authentik, Keycloak)"`
- OidcProviderLogoUrl SettingVariable `key:"oidcProviderLogoUrl,public,envOverride" meta:"label=OIDC Provider Logo URL;type=text;keywords=oidc,provider,logo,url,image,icon,sso;category=authentication;description=Custom logo URL for the OIDC provider"`
- OidcMobileRedirectUris SettingVariable `key:"oidcMobileRedirectUris,envOverride" meta:"label=OIDC Mobile Redirect URIs;type=text;keywords=oidc,mobile,redirect,uri,callback,scheme,ios,android,native;category=authentication;description=Comma-separated allowlist of native app redirect URIs (e.g., arcane-mobile://oidc-callback)"`
+ AuthLocalEnabled SettingVariable `key:"authLocalEnabled,public" meta:"label=Local Authentication;type=boolean;keywords=local,auth,authentication,username,password,login,credentials;category=authentication;description=Enable local username/password authentication" catmeta:"id=authentication;title=Authentication;icon=lock;url=/settings/authentication;description=Manage authentication providers, password policy, and session behavior"`
+ AuthSessionTimeout SettingVariable `key:"authSessionTimeout" meta:"label=Session Timeout;type=number;keywords=session,timeout,expire,duration,lifetime,minutes,logout;category=authentication;description=How long user sessions remain active"`
+ AuthPasswordPolicy SettingVariable `key:"authPasswordPolicy" meta:"label=Password Policy;type=select;keywords=password,policy,strength,complexity,requirements,security,rules;category=authentication;description=Set password strength requirements"`
+ FeatureVulnerabilityManagementEnabled SettingVariable `key:"featureVulnerabilityManagementEnabled,public,envOverride" meta:"label=Vulnerability management;type=boolean;keywords=features,vulnerability,security,scan,enable,disable;category=general;description=Enable vulnerability management for this environment. Disabling retains reports and configuration and leaves standalone image patching available"`
+ VulnerabilityScanEnabled SettingVariable `key:"vulnerabilityScanEnabled" meta:"label=Scheduled Vulnerability Scan;type=boolean;keywords=vulnerability,scan,security,trivy,schedule,automatic,cve;category=security;description=Enable scheduled vulnerability scanning of all Docker images" catmeta:"id=security;title=Security;icon=shield;url=/settings/security;description=Configure vulnerability scanning and runtime security settings"`
+ VulnerabilityScanInterval SettingVariable `key:"vulnerabilityScanInterval" meta:"label=Vulnerability Scan Interval;type=cron;keywords=vulnerability,scan,interval,schedule,frequency,trivy,cve;category=security;description=How often to run scheduled vulnerability scans (cron expression)"`
+ TrivyDbRegistry SettingVariable `key:"trivyDbRegistry,envOverride" meta:"label=Trivy DB Registry;type=select;keywords=trivy,db,java-db,checks,registry,ghcr,docker,hub,vulnerability,security,scanner;category=security;description=Container registry used to pull the Trivy vulnerability database artifacts"`
+ TrivyNetwork SettingVariable `key:"trivyNetwork,envOverride" meta:"label=Trivy Network;type=text;keywords=trivy,network,mode,bridge,host,none,scanner,vulnerability,security;category=security;description=Docker network mode/network name used for Trivy scan containers. Leave empty to inherit Arcane's network automatically."`
+ TrivySecurityOpts SettingVariable `key:"trivySecurityOpts,envOverride" meta:"label=Trivy Security Options;type=textarea;keywords=trivy,security,opt,security_opt,selinux,labels,apparmor,scanner;category=security;description=Docker security options applied to Trivy scan containers. Use commas or new lines to separate entries (for example: label=disable)"`
+ TrivyPrivileged SettingVariable `key:"trivyPrivileged,envOverride" meta:"label=Trivy Privileged;type=boolean;keywords=trivy,privileged,security,selinux,scanner;category=security;description=Run Trivy scan containers in privileged mode when required by the host security policy"`
+ TrivyResourceLimitsEnabled SettingVariable `key:"trivyResourceLimitsEnabled,envOverride" meta:"label=Trivy Resource Limits;type=boolean;keywords=trivy,resources,limits,cpu,memory,ram,security,scan;category=security;description=Enable CPU and memory limits for Trivy scan containers"`
+ TrivyCpuLimit SettingVariable `key:"trivyCpuLimit,envOverride" meta:"label=Trivy CPU Limit (cores);type=number;keywords=trivy,cpu,cores,limit,scanner,resources;category=security;description=Maximum CPU cores for Trivy scan containers (supports decimals, e.g. 1.5). Set 0 to disable CPU limit"`
+ TrivyMemoryLimitMb SettingVariable `key:"trivyMemoryLimitMb,envOverride" meta:"label=Trivy Memory Limit (MB);type=number;keywords=trivy,memory,ram,mb,limit,scanner,resources;category=security;description=Maximum memory for Trivy scan containers in MB. Set 0 to disable memory limit"`
+ TrivyConcurrentScanContainers SettingVariable `key:"trivyConcurrentScanContainers,envOverride" meta:"label=Trivy Concurrent Scan Containers;type=number;keywords=trivy,concurrent,scan,containers,parallel,workers,limit,security;category=security;description=Maximum number of concurrent Trivy scan containers for manual and scheduled scans. Minimum 1"`
+ TrivyConfig SettingVariable `key:"trivyConfig" meta:"label=Trivy Config (YAML);type=textarea;keywords=trivy,config,yaml,configuration,scanner,settings;category=security;description=Trivy configuration file content in YAML format"`
+ TrivyIgnore SettingVariable `key:"trivyIgnore" meta:"label=.trivyignore;type=textarea;keywords=trivy,ignore,ignorefile,vulnerabilities,exceptions,exclusions;category=security;description=Trivy ignore file content - one vulnerability ID per line"`
+ TrivyServerEnabled SettingVariable `key:"trivyServerEnabled,envOverride" meta:"label=Trivy Client/Server Mode;type=boolean;keywords=trivy,server,client,remote,scanner,vulnerability,security,armv7,32bit;category=security;description=Scan against a remote Trivy server instead of downloading the vulnerability database locally. Recommended for 32-bit hosts (arm/v7) where the local DB cannot be memory-mapped."`
+ TrivyServerUrl SettingVariable `key:"trivyServerUrl,envOverride" meta:"label=Trivy Server URL;type=text;keywords=trivy,server,url,remote,scanner,vulnerability,security;category=security;description=URL of the remote Trivy server (e.g. http://trivy.example.com:4954). Used when client/server mode is enabled."`
+ TrivyServerToken SettingVariable `key:"trivyServerToken,envOverride,sensitive" meta:"label=Trivy Server Token;type=password;keywords=trivy,server,token,auth,remote,scanner,security;category=security;description=Optional authentication token sent to the remote Trivy server. Leave empty if the server requires no token."`
+ TrivyIgnoreUnfixed SettingVariable `key:"trivyIgnoreUnfixed,envOverride" meta:"label=Only Report Fixable Vulnerabilities;type=boolean;keywords=trivy,fixable,unfixed,ignore,vulnerability,security,noise,fixes;category=security;description=Only report vulnerabilities that have a known fix available. Reduces noise from vulnerabilities you cannot act on."`
+ ImagePatchSuffix SettingVariable `key:"imagePatchSuffix" meta:"label=Patched Image Tag Suffix;type=text;keywords=patch,copa,copacetic,image,tag,suffix,vulnerability,security;category=security;description=Suffix appended to the source tag when patching an image (default: patched)"`
+ ImagePatchTimeoutSec SettingVariable `key:"imagePatchTimeoutSec,envOverride" meta:"label=Image Patch Timeout (seconds);type=number;keywords=patch,copa,copacetic,image,timeout,seconds,buildkit,security;category=security;description=Timeout for a single image patch operation in seconds (default: 600)"`
+ ImagePatchAllPlatforms SettingVariable `key:"imagePatchAllPlatforms" meta:"label=Patch All Platforms;type=boolean;keywords=patch,copa,copacetic,image,platform,architecture,multi,arch,security;category=security;description=Patch every platform in a multi-platform image instead of only the platform this server runs on"`
+ ImageAutoPatchEnabled SettingVariable `key:"imageAutoPatchEnabled" meta:"label=Scheduled Image Patching;type=boolean;keywords=patch,copa,copacetic,image,automatic,schedule,vulnerability,security,cve;category=security;description=Automatically patch images whose latest vulnerability scan found fixable OS package vulnerabilities"`
+ ImageAutoPatchInterval SettingVariable `key:"imageAutoPatchInterval" meta:"label=Image Patch Interval;type=cron;keywords=patch,copa,copacetic,image,interval,schedule,frequency,cron,security;category=security;description=How often to run scheduled image patching (cron expression)"`
+ LifecycleEnabled SettingVariable `key:"lifecycleEnabled,envOverride" meta:"label=Enable Lifecycle Hooks;type=boolean;keywords=lifecycle,hook,hooks,pre-deploy,script,gitops,sops,secrets;category=security;description=Allow GitOps syncs to configure pre-deploy lifecycle scripts. Disabled by default because scripts are repo-trusted code that runs on every deploy"`
+ LifecycleDefaultRunnerImage SettingVariable `key:"lifecycleDefaultRunnerImage,envOverride" meta:"label=Lifecycle Hook Runner Image;type=text;keywords=lifecycle,hook,runner,image,container,pre-deploy,script,gitops;category=security;description=Default container image used to run GitOps pre-deploy lifecycle scripts when a sync does not override it"`
+ LifecycleMaxTimeoutSec SettingVariable `key:"lifecycleMaxTimeoutSec,envOverride" meta:"label=Lifecycle Hook Max Timeout (seconds);type=number;keywords=lifecycle,hook,timeout,seconds,limit,maximum,script,pre-deploy;category=security;description=Maximum allowed timeout for lifecycle scripts in seconds (default: 300)"`
+ OidcEnabled SettingVariable `key:"oidcEnabled,public,envOverride" meta:"label=OIDC Authentication;type=boolean;keywords=oidc,openid,connect,sso,oauth,external,provider,federation;category=authentication;description=Enable OpenID Connect (OIDC) authentication"`
+ OidcClientId SettingVariable `key:"oidcClientId,authrequired,envOverride" meta:"label=OIDC Client ID;type=text;keywords=oidc,client,id,oauth,openid;category=authentication;description=OIDC provider client ID"`
+ OidcClientSecret SettingVariable `key:"oidcClientSecret,sensitive,envOverride" meta:"label=OIDC Client Secret;type=password;keywords=oidc,client,secret,oauth,openid;category=authentication;description=OIDC provider client secret"`
+ OidcIssuerUrl SettingVariable `key:"oidcIssuerUrl,authrequired,envOverride" meta:"label=OIDC Issuer URL;type=text;keywords=oidc,issuer,url,oauth,openid,provider;category=authentication;description=OIDC provider issuer URL"`
+ OidcAuthorizationEndpoint SettingVariable `key:"oidcAuthorizationEndpoint,envOverride" meta:"label=OIDC Authorization Endpoint;type=text;keywords=oidc,authorization,endpoint,oauth,openid;category=authentication;description=Override OIDC authorization endpoint"`
+ OidcTokenEndpoint SettingVariable `key:"oidcTokenEndpoint,envOverride" meta:"label=OIDC Token Endpoint;type=text;keywords=oidc,token,endpoint,oauth,openid;category=authentication;description=Override OIDC token endpoint"`
+ OidcUserinfoEndpoint SettingVariable `key:"oidcUserinfoEndpoint,envOverride" meta:"label=OIDC Userinfo Endpoint;type=text;keywords=oidc,userinfo,endpoint,oauth,openid;category=authentication;description=Override OIDC userinfo endpoint"`
+ OidcJwksEndpoint SettingVariable `key:"oidcJwksEndpoint,envOverride" meta:"label=OIDC JWKS Endpoint;type=text;keywords=oidc,jwks,keys,endpoint,oauth,openid;category=authentication;description=Override OIDC JWKS endpoint"`
+ OidcDeviceAuthorizationEndpoint SettingVariable `key:"oidcDeviceAuthorizationEndpoint,envOverride" meta:"label=OIDC Device Authorization Endpoint;type=text;keywords=oidc,device,authorization,endpoint,oauth,openid,cli;category=authentication;description=Override OIDC device authorization endpoint for CLI authentication"`
+ OidcScopes SettingVariable `key:"oidcScopes,authrequired,envOverride" meta:"label=OIDC Scopes;type=text;keywords=oidc,scopes,oauth,openid,permissions;category=authentication;description=OIDC scopes to request"`
+ OidcGroupsClaim SettingVariable `key:"oidcGroupsClaim,authrequired,envOverride" meta:"label=OIDC Groups Claim;type=text;keywords=oidc,groups,claim,role,mapping,rbac;category=authentication;description=Claim name to read group memberships from for role mapping (default: groups)"`
+ OidcSkipTlsVerify SettingVariable `key:"oidcSkipTlsVerify,authrequired,envOverride" meta:"label=OIDC Skip TLS Verify;type=boolean;keywords=oidc,tls,verify,skip,insecure;category=authentication;description=Skip TLS verification for OIDC provider"`
+ OidcAutoRedirectToProvider SettingVariable `key:"oidcAutoRedirectToProvider,public,envOverride" meta:"label=OIDC Auto Redirect;type=boolean;keywords=oidc,auto,redirect,automatic,login,provider,sso;category=authentication;description=Automatically redirect to OIDC provider on login page"`
+ OidcMergeAccounts SettingVariable `key:"oidcMergeAccounts,authrequired,envOverride" meta:"label=OIDC Account Merging;type=boolean;keywords=oidc,merge,link,accounts,email,match,existing,users,combine;category=authentication;description=Allow OIDC logins to merge with existing accounts by email"`
+ OidcProviderName SettingVariable `key:"oidcProviderName,public,envOverride" meta:"label=OIDC Provider Name;type=text;keywords=oidc,provider,name,display,label,sso;category=authentication;description=Custom name for the OIDC provider (e.g., Authentik, Keycloak)"`
+ OidcProviderLogoUrl SettingVariable `key:"oidcProviderLogoUrl,public,envOverride" meta:"label=OIDC Provider Logo URL;type=text;keywords=oidc,provider,logo,url,image,icon,sso;category=authentication;description=Custom logo URL for the OIDC provider"`
+ OidcMobileRedirectUris SettingVariable `key:"oidcMobileRedirectUris,envOverride" meta:"label=OIDC Mobile Redirect URIs;type=text;keywords=oidc,mobile,redirect,uri,callback,scheme,ios,android,native;category=authentication;description=Comma-separated allowlist of native app redirect URIs (e.g., arcane-mobile://oidc-callback)"`
// Notifications category (placeholder for category metadata only - actual settings managed via notification service)
NotificationsCategoryPlaceholder SettingVariable `key:"notificationsCategory,internal" meta:"label=Notifications;type=internal;keywords=notifications,alerts,email,discord,webhooks,events,messages;category=notifications;description=Configure notification providers and alerts" catmeta:"id=notifications;title=Notifications;icon=bell;url=/settings/notifications;description=Configure email and Discord notifications for container and image updates"`
diff --git a/backend/internal/settings/service.go b/backend/internal/settings/service.go
index ae07bbe58..c6ec04aab 100644
--- a/backend/internal/settings/service.go
+++ b/backend/internal/settings/service.go
@@ -197,92 +197,93 @@ func (s *SettingsService) getDefaultSettings() *Settings {
// DefaultSettingsConfig returns the canonical default settings model used by Arcane.
func DefaultSettingsConfig() *Settings {
return &Settings{
- ProjectsDirectory: SettingVariable{Value: "/app/data/projects"},
- TemplatesDirectory: SettingVariable{Value: "/app/data/templates"},
- FollowProjectSymlinks: SettingVariable{Value: "false"},
- SwarmStackSourcesDirectory: SettingVariable{Value: "/app/data/swarm/sources"},
- DiskUsagePath: SettingVariable{Value: "/app/data/projects"},
- AutoUpdate: SettingVariable{Value: "false"},
- AutoUpdateInterval: SettingVariable{Value: "0 0 0 * * *"},
- AutoUpdateExcludedContainers: SettingVariable{Value: ""},
- PollingEnabled: SettingVariable{Value: "true"},
- PollingInterval: SettingVariable{Value: "0 0 * * * *"},
- ImageEventWatcherEnabled: SettingVariable{Value: "false"},
- DockerClientRefreshInterval: SettingVariable{Value: "*/30 * * * * *"},
- EventCleanupInterval: SettingVariable{Value: "0 0 */6 * * *"},
- ExpiredSessionsCleanupInterval: SettingVariable{Value: "0 0 0 * * *"},
- ActivityHistoryRetentionDays: SettingVariable{Value: "30"},
- ActivityHistoryMaxEntries: SettingVariable{Value: "1000"},
- MaxConcurrentActivities: SettingVariable{Value: "5"},
- AutoInjectEnv: SettingVariable{Value: "false"},
- DefaultDeployPullPolicy: SettingVariable{Value: "missing"},
- ToolsImageRegistry: SettingVariable{Value: "ghcr.io"},
- UpdateCheckRegistry: SettingVariable{Value: "auto"},
- ScheduledPruneEnabled: SettingVariable{Value: "false"},
- ScheduledPruneInterval: SettingVariable{Value: "0 0 0 * * *"},
- PruneContainerMode: SettingVariable{Value: "stopped"},
- PruneContainerUntil: SettingVariable{Value: ""},
- PruneImageMode: SettingVariable{Value: "dangling"},
- PruneImageUntil: SettingVariable{Value: ""},
- PruneVolumeMode: SettingVariable{Value: "none"},
- PruneNetworkMode: SettingVariable{Value: "unused"},
- PruneNetworkUntil: SettingVariable{Value: ""},
- PruneBuildCacheMode: SettingVariable{Value: "none"},
- PruneBuildCacheUntil: SettingVariable{Value: ""},
- AutoHealEnabled: SettingVariable{Value: "false"},
- AutoHealInterval: SettingVariable{Value: "*/30 * * * * *"},
- AutoHealExcludedContainers: SettingVariable{Value: ""},
- AutoHealMaxRestarts: SettingVariable{Value: "5"},
- AutoHealRestartWindow: SettingVariable{Value: "30"},
- VolumeHelperIdleTimeout: SettingVariable{Value: "10"},
- BaseServerURL: SettingVariable{Value: "http://localhost"},
- EnableGravatar: SettingVariable{Value: "true"},
- ExperimentalFeaturesEnabled: SettingVariable{Value: "false"},
- AvatarMaxUploadSizeMb: SettingVariable{Value: "2"},
- DefaultShell: SettingVariable{Value: "/bin/sh"},
- DockerHost: SettingVariable{Value: "unix:///var/run/docker.sock"},
- BuildsDirectory: SettingVariable{Value: "/builds"},
- AuthLocalEnabled: SettingVariable{Value: "true"},
- AuthSessionTimeout: SettingVariable{Value: "1440"},
- AuthPasswordPolicy: SettingVariable{Value: "strong"},
- VulnerabilityScanEnabled: SettingVariable{Value: "false"},
- VulnerabilityScanInterval: SettingVariable{Value: "0 0 0 * * *"},
- TrivyDbRegistry: SettingVariable{Value: "ghcr.io"},
- TrivyNetwork: SettingVariable{Value: ""},
- TrivySecurityOpts: SettingVariable{Value: ""},
- TrivyPrivileged: SettingVariable{Value: "false"},
- TrivyResourceLimitsEnabled: SettingVariable{Value: "true"},
- TrivyCpuLimit: SettingVariable{Value: "1"},
- TrivyMemoryLimitMb: SettingVariable{Value: "0"},
- TrivyConcurrentScanContainers: SettingVariable{Value: "1"},
- TrivyServerEnabled: SettingVariable{Value: "false"},
- TrivyServerUrl: SettingVariable{Value: ""},
- TrivyServerToken: SettingVariable{Value: ""},
- TrivyIgnoreUnfixed: SettingVariable{Value: "true"},
- OidcEnabled: SettingVariable{Value: "false"},
- OidcClientId: SettingVariable{Value: ""},
- OidcClientSecret: SettingVariable{Value: ""},
- OidcIssuerUrl: SettingVariable{Value: ""},
- OidcAuthorizationEndpoint: SettingVariable{Value: ""},
- OidcTokenEndpoint: SettingVariable{Value: ""},
- OidcUserinfoEndpoint: SettingVariable{Value: ""},
- OidcJwksEndpoint: SettingVariable{Value: ""},
- OidcScopes: SettingVariable{Value: "openid email profile"},
- OidcGroupsClaim: SettingVariable{Value: "groups"},
- OidcSkipTlsVerify: SettingVariable{Value: "false"},
- OidcAutoRedirectToProvider: SettingVariable{Value: "false"},
- OidcMergeAccounts: SettingVariable{Value: "false"},
- OidcProviderName: SettingVariable{Value: ""},
- OidcProviderLogoUrl: SettingVariable{Value: ""},
- OidcMobileRedirectUris: SettingVariable{Value: "arcane-mobile://oidc-callback"},
- MaxImageUploadSize: SettingVariable{Value: "500"},
- GitSyncMaxFiles: SettingVariable{Value: "500"},
- GitSyncMaxTotalSizeMb: SettingVariable{Value: "50"},
- GitSyncMaxBinarySizeMb: SettingVariable{Value: "10"},
- EnvironmentHealthInterval: SettingVariable{Value: "0 */2 * * * *"},
- LifecycleEnabled: SettingVariable{Value: "false"},
- LifecycleDefaultRunnerImage: SettingVariable{Value: "alpine:latest"},
- LifecycleMaxTimeoutSec: SettingVariable{Value: "300"},
+ ProjectsDirectory: SettingVariable{Value: "/app/data/projects"},
+ TemplatesDirectory: SettingVariable{Value: "/app/data/templates"},
+ FollowProjectSymlinks: SettingVariable{Value: "false"},
+ SwarmStackSourcesDirectory: SettingVariable{Value: "/app/data/swarm/sources"},
+ DiskUsagePath: SettingVariable{Value: "/app/data/projects"},
+ AutoUpdate: SettingVariable{Value: "false"},
+ AutoUpdateInterval: SettingVariable{Value: "0 0 0 * * *"},
+ AutoUpdateExcludedContainers: SettingVariable{Value: ""},
+ PollingEnabled: SettingVariable{Value: "true"},
+ PollingInterval: SettingVariable{Value: "0 0 * * * *"},
+ ImageEventWatcherEnabled: SettingVariable{Value: "false"},
+ DockerClientRefreshInterval: SettingVariable{Value: "*/30 * * * * *"},
+ EventCleanupInterval: SettingVariable{Value: "0 0 */6 * * *"},
+ ExpiredSessionsCleanupInterval: SettingVariable{Value: "0 0 0 * * *"},
+ ActivityHistoryRetentionDays: SettingVariable{Value: "30"},
+ ActivityHistoryMaxEntries: SettingVariable{Value: "1000"},
+ MaxConcurrentActivities: SettingVariable{Value: "5"},
+ AutoInjectEnv: SettingVariable{Value: "false"},
+ DefaultDeployPullPolicy: SettingVariable{Value: "missing"},
+ ToolsImageRegistry: SettingVariable{Value: "ghcr.io"},
+ UpdateCheckRegistry: SettingVariable{Value: "auto"},
+ ScheduledPruneEnabled: SettingVariable{Value: "false"},
+ ScheduledPruneInterval: SettingVariable{Value: "0 0 0 * * *"},
+ PruneContainerMode: SettingVariable{Value: "stopped"},
+ PruneContainerUntil: SettingVariable{Value: ""},
+ PruneImageMode: SettingVariable{Value: "dangling"},
+ PruneImageUntil: SettingVariable{Value: ""},
+ PruneVolumeMode: SettingVariable{Value: "none"},
+ PruneNetworkMode: SettingVariable{Value: "unused"},
+ PruneNetworkUntil: SettingVariable{Value: ""},
+ PruneBuildCacheMode: SettingVariable{Value: "none"},
+ PruneBuildCacheUntil: SettingVariable{Value: ""},
+ AutoHealEnabled: SettingVariable{Value: "false"},
+ AutoHealInterval: SettingVariable{Value: "*/30 * * * * *"},
+ AutoHealExcludedContainers: SettingVariable{Value: ""},
+ AutoHealMaxRestarts: SettingVariable{Value: "5"},
+ AutoHealRestartWindow: SettingVariable{Value: "30"},
+ VolumeHelperIdleTimeout: SettingVariable{Value: "10"},
+ BaseServerURL: SettingVariable{Value: "http://localhost"},
+ EnableGravatar: SettingVariable{Value: "true"},
+ ExperimentalFeaturesEnabled: SettingVariable{Value: "false"},
+ AvatarMaxUploadSizeMb: SettingVariable{Value: "2"},
+ DefaultShell: SettingVariable{Value: "/bin/sh"},
+ DockerHost: SettingVariable{Value: "unix:///var/run/docker.sock"},
+ BuildsDirectory: SettingVariable{Value: "/builds"},
+ AuthLocalEnabled: SettingVariable{Value: "true"},
+ AuthSessionTimeout: SettingVariable{Value: "1440"},
+ AuthPasswordPolicy: SettingVariable{Value: "strong"},
+ FeatureVulnerabilityManagementEnabled: SettingVariable{Value: "true"},
+ VulnerabilityScanEnabled: SettingVariable{Value: "false"},
+ VulnerabilityScanInterval: SettingVariable{Value: "0 0 0 * * *"},
+ TrivyDbRegistry: SettingVariable{Value: "ghcr.io"},
+ TrivyNetwork: SettingVariable{Value: ""},
+ TrivySecurityOpts: SettingVariable{Value: ""},
+ TrivyPrivileged: SettingVariable{Value: "false"},
+ TrivyResourceLimitsEnabled: SettingVariable{Value: "true"},
+ TrivyCpuLimit: SettingVariable{Value: "1"},
+ TrivyMemoryLimitMb: SettingVariable{Value: "0"},
+ TrivyConcurrentScanContainers: SettingVariable{Value: "1"},
+ TrivyServerEnabled: SettingVariable{Value: "false"},
+ TrivyServerUrl: SettingVariable{Value: ""},
+ TrivyServerToken: SettingVariable{Value: ""},
+ TrivyIgnoreUnfixed: SettingVariable{Value: "true"},
+ OidcEnabled: SettingVariable{Value: "false"},
+ OidcClientId: SettingVariable{Value: ""},
+ OidcClientSecret: SettingVariable{Value: ""},
+ OidcIssuerUrl: SettingVariable{Value: ""},
+ OidcAuthorizationEndpoint: SettingVariable{Value: ""},
+ OidcTokenEndpoint: SettingVariable{Value: ""},
+ OidcUserinfoEndpoint: SettingVariable{Value: ""},
+ OidcJwksEndpoint: SettingVariable{Value: ""},
+ OidcScopes: SettingVariable{Value: "openid email profile"},
+ OidcGroupsClaim: SettingVariable{Value: "groups"},
+ OidcSkipTlsVerify: SettingVariable{Value: "false"},
+ OidcAutoRedirectToProvider: SettingVariable{Value: "false"},
+ OidcMergeAccounts: SettingVariable{Value: "false"},
+ OidcProviderName: SettingVariable{Value: ""},
+ OidcProviderLogoUrl: SettingVariable{Value: ""},
+ OidcMobileRedirectUris: SettingVariable{Value: "arcane-mobile://oidc-callback"},
+ MaxImageUploadSize: SettingVariable{Value: "500"},
+ GitSyncMaxFiles: SettingVariable{Value: "500"},
+ GitSyncMaxTotalSizeMb: SettingVariable{Value: "50"},
+ GitSyncMaxBinarySizeMb: SettingVariable{Value: "10"},
+ EnvironmentHealthInterval: SettingVariable{Value: "0 */2 * * * *"},
+ LifecycleEnabled: SettingVariable{Value: "false"},
+ LifecycleDefaultRunnerImage: SettingVariable{Value: "alpine:latest"},
+ LifecycleMaxTimeoutSec: SettingVariable{Value: "300"},
DockerAPITimeout: SettingVariable{Value: "30"},
DockerImagePullTimeout: SettingVariable{Value: "600"},
@@ -497,6 +498,9 @@ func (s *SettingsService) getEffectiveSettingsConfigInternal(ctx context.Context
}
func (s *SettingsService) UpdateSetting(ctx context.Context, key, value string) error {
+ if err := validateFeatureSettingInternal(key, value); err != nil {
+ return err
+ }
if err := libarcane.ValidateCronSetting(key, value); err != nil {
return errors.WrapIff(err, "invalid cron expression for %s", key)
}
@@ -514,6 +518,9 @@ func (s *SettingsService) UpdateSetting(ctx context.Context, key, value string)
func (s *SettingsService) UpdateSettingValues(ctx context.Context, updates []libarcane.SettingUpdate) error {
values := make([]SettingVariable, 0, len(updates))
for _, update := range updates {
+ if err := validateFeatureSettingInternal(update.Key, update.Value); err != nil {
+ return err
+ }
values = append(values, SettingVariable{Key: update.Key, Value: update.Value})
}
_, err := s.writes.Execute(ctx, "update setting values", func(writeCtx context.Context) (actors.NoPayload, error) {
@@ -649,6 +656,10 @@ func (s *SettingsService) prepareUpdateValues(updates settingstypes.Update, cfg,
continue
}
+ if err := validateFeatureSettingInternal(key, value); err != nil {
+ return nil, err
+ }
+
if key == libarcane.DepotTokenSettingKey {
// Sensitive token: only update when explicitly provided.
// Empty input preserves existing token.
diff --git a/backend/internal/vulnerability/handler.go b/backend/internal/vulnerability/handler.go
index 36ba0e5fc..ae0d61acf 100644
--- a/backend/internal/vulnerability/handler.go
+++ b/backend/internal/vulnerability/handler.go
@@ -2,8 +2,11 @@ package vulnerability
import (
"context"
+ "log/slog"
"net/http"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+
"emperror.dev/errors"
"github.com/danielgtaylor/huma/v2"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
@@ -91,12 +94,26 @@ type ScannerStatus struct {
// RegisterVulnerability registers vulnerability scanning routes using Huma.
func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityService, appCtx handlerutil.ActivityAppContext) {
+ featureMiddleware := huma.Middlewares{func(ctx huma.Context, next func(huma.Context)) {
+ if vulnerabilityService != nil {
+ if err := vulnerabilityService.settingsService.RequireFeature(ctx.Context(), features.VulnerabilityManagement); err != nil {
+ ctx.SetHeader("Content-Type", "application/problem+json")
+ ctx.SetStatus(http.StatusForbidden)
+ if writeErr := api.Marshal(ctx.BodyWriter(), "application/json", handlerutil.FeatureDisabledError(features.VulnerabilityManagement)); writeErr != nil {
+ slog.WarnContext(ctx.Context(), "failed to write feature-disabled response", "error", writeErr)
+ }
+ return
+ }
+ }
+ next(ctx)
+ }}
h := &VulnerabilityHandler{
vulnerabilityService: vulnerabilityService,
appCtx: appCtx.Context(),
}
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "scan-image-vulnerabilities",
Method: http.MethodPost,
Path: "/environments/{id}/images/{imageId}/vulnerabilities/scan",
@@ -107,6 +124,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsScan, h.ScanImage)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "get-image-vulnerabilities",
Method: http.MethodGet,
Path: "/environments/{id}/images/{imageId}/vulnerabilities",
@@ -117,6 +135,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsRead, h.GetScanResult)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "get-image-vulnerability-summary",
Method: http.MethodGet,
Path: "/environments/{id}/images/{imageId}/vulnerabilities/summary",
@@ -127,6 +146,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsRead, h.GetScanSummary)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "get-image-vulnerability-summaries",
Method: http.MethodPost,
Path: "/environments/{id}/images/vulnerabilities/summaries",
@@ -137,6 +157,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsRead, h.GetScanSummaries)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "list-image-vulnerabilities",
Method: http.MethodGet,
Path: "/environments/{id}/images/{imageId}/vulnerabilities/list",
@@ -147,6 +168,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsRead, h.ListImageVulnerabilities)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "get-vulnerability-scanner-status",
Method: http.MethodGet,
Path: "/environments/{id}/vulnerabilities/scanner-status",
@@ -157,6 +179,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsRead, h.GetScannerStatus)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "get-environment-vulnerability-summary",
Method: http.MethodGet,
Path: "/environments/{id}/vulnerabilities/summary",
@@ -167,6 +190,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsRead, h.GetEnvironmentSummary)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "list-environment-vulnerabilities",
Method: http.MethodGet,
Path: "/environments/{id}/vulnerabilities/all",
@@ -177,6 +201,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsRead, h.ListAllVulnerabilities)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "list-environment-vulnerability-image-options",
Method: http.MethodGet,
Path: "/environments/{id}/vulnerabilities/image-options",
@@ -187,6 +212,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsRead, h.ListAllVulnerabilityImageOptions)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "ignore-vulnerability",
Method: http.MethodPost,
Path: "/environments/{id}/vulnerabilities/ignore",
@@ -197,6 +223,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsManage, h.IgnoreVulnerability)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "unignore-vulnerability",
Method: http.MethodDelete,
Path: "/environments/{id}/vulnerabilities/ignore/{ignoreId}",
@@ -207,6 +234,7 @@ func RegisterVulnerability(api huma.API, vulnerabilityService *VulnerabilityServ
}, authz.PermVulnsManage, h.UnignoreVulnerability)
middleware.RegisterWithPermission(api, huma.Operation{
+ Middlewares: featureMiddleware,
OperationID: "list-ignored-vulnerabilities",
Method: http.MethodGet,
Path: "/environments/{id}/vulnerabilities/ignored",
@@ -227,6 +255,9 @@ func (h *VulnerabilityHandler) ScanImage(ctx context.Context, input *ScanImageIn
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
result, err := h.vulnerabilityService.ScanImage(runtimeCtx, input.EnvironmentID, input.ImageID, *user)
if err != nil {
+ if errors.Is(err, common.ErrFeatureDisabled) {
+ return nil, handlerutil.FeatureDisabledError(features.VulnerabilityManagement)
+ }
return nil, huma.Error500InternalServerError(errors.WithMessage(err, "Failed to scan image for vulnerabilities").Error())
}
@@ -254,6 +285,9 @@ func (h *VulnerabilityHandler) GetScanSummaries(ctx context.Context, input *GetS
summaries, err := h.vulnerabilityService.GetScanSummariesByImageIDs(ctx, imageIDs)
if err != nil {
+ if errors.Is(err, common.ErrFeatureDisabled) {
+ return nil, handlerutil.FeatureDisabledError(features.VulnerabilityManagement)
+ }
return nil, huma.Error500InternalServerError(errors.WithMessage(err, "Failed to scan image for vulnerabilities").Error())
}
diff --git a/backend/internal/vulnerability/vulnerability_feature_test.go b/backend/internal/vulnerability/vulnerability_feature_test.go
new file mode 100644
index 000000000..8d67421ca
--- /dev/null
+++ b/backend/internal/vulnerability/vulnerability_feature_test.go
@@ -0,0 +1,167 @@
+package vulnerability
+
+import (
+ "context"
+ "net/http"
+ "net/http/httptest"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/getarcaneapp/arcane/backend/v2/internal/docker"
+ "github.com/moby/moby/client"
+
+ "github.com/getarcaneapp/arcane/backend/v2/internal/actors"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/database"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/notification"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/settings"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+ "github.com/getarcaneapp/arcane/types/v2/vulnerability"
+ "github.com/libtnb/sqlite"
+ "github.com/stretchr/testify/require"
+ "go.uber.org/fx/fxtest"
+ "gorm.io/gorm"
+)
+
+func featureSettingsInternal(t *testing.T) (*settings.SettingsService, *database.DB) {
+ t.Helper()
+ gdb, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+ require.NoError(t, err)
+ require.NoError(t, gdb.AutoMigrate(&settings.SettingVariable{}, &VulnerabilityScanRecord{}, &VulnerabilityScanItem{}, &VulnerabilityReportRecord{}, &VulnerabilityIgnore{}))
+ db := &database.DB{DB: gdb}
+ lifecycle := fxtest.NewLifecycle(t)
+ runtime, err := actors.NewRuntime(t.Context(), lifecycle)
+ require.NoError(t, err)
+ writes, err := actors.NewExecutor(t.Context(), runtime, "vuln-feature-writes", t.Name(), 3)
+ require.NoError(t, err)
+ effects, err := actors.NewExecutor(t.Context(), runtime, "vuln-feature-effects", t.Name(), 3)
+ require.NoError(t, err)
+ t.Cleanup(func() {
+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+ defer cancel()
+ require.NoError(t, writes.Stop(ctx))
+ require.NoError(t, effects.Stop(ctx))
+ require.NoError(t, lifecycle.Stop(ctx))
+ })
+ svc, err := settings.NewSettingsService(t.Context(), db, writes, effects)
+ require.NoError(t, err)
+ return svc, db
+}
+
+func TestVulnerabilityFeatureDisabledRejectsScansAndRetainsReports(t *testing.T) {
+ settingsSvc, db := featureSettingsInternal(t)
+ svc := &VulnerabilityService{settingsService: settingsSvc, db: db}
+ require.NoError(t, db.Create(&VulnerabilityScanRecord{ID: "test-image", ImageName: "test:latest", Status: ScanStatusCompleted, ScanTime: time.Now()}).Error)
+ require.NoError(t, db.Create(&VulnerabilityReportRecord{ImageID: "test-image", Data: "stored report"}).Error)
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
+
+ _, err := svc.ScanImage(t.Context(), "0", "test-image", common.User{})
+ require.ErrorIs(t, err, common.ErrFeatureDisabled)
+ _, _, err = svc.ScanAllImages(t.Context(), "0", common.User{}, false)
+ require.ErrorIs(t, err, common.ErrFeatureDisabled)
+ _, _, err = svc.setupTrivyBatchContainersInternal(t.Context(), 1)
+ require.ErrorIs(t, err, common.ErrFeatureDisabled)
+ summaries, err := svc.GetScanSummariesByImageIDs(t.Context(), []string{"test-image"})
+ require.NoError(t, err)
+ require.Empty(t, summaries)
+ count, err := svc.ActionableCountExcludingIgnored(t.Context())
+ require.NoError(t, err)
+ require.Zero(t, count)
+
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, true))
+ summaries, err = svc.GetScanSummariesByImageIDs(t.Context(), []string{"test-image"})
+ require.NoError(t, err)
+ require.Contains(t, summaries, "test-image")
+ var report VulnerabilityReportRecord
+ require.NoError(t, db.First(&report, "image_id = ?", "test-image").Error)
+ require.Equal(t, "stored report", report.Data)
+}
+
+func TestVulnerabilityFeatureDisabledWhileWaitingForSlot(t *testing.T) {
+ tests := []struct {
+ name string
+ queuedImage string
+ slots int
+ }{
+ {name: "waiting for capacity", queuedImage: "other-image", slots: 1},
+ {name: "waiting for the same image", queuedImage: "active-image", slots: 2},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ settingsSvc, _ := featureSettingsInternal(t)
+ require.NoError(t, settingsSvc.SetIntSetting(t.Context(), "trivyConcurrentScanContainers", tt.slots))
+ var inspections atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ inspections.Add(1)
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"Id":"scanner-image"}`))
+ }))
+ defer server.Close()
+ dockerClient, err := client.New(client.WithHost(server.URL), client.WithAPIVersion("1.41"))
+ require.NoError(t, err)
+ defer dockerClient.Close()
+ svc := &VulnerabilityService{settingsService: settingsSvc, dockerService: &docker.DockerClientService{Client: dockerClient}}
+ _, release, err := svc.acquireTrivyScanSlotInternal(t.Context(), "active-image", false)
+ require.NoError(t, err)
+ require.NotNil(t, release)
+ _, queuedRelease, err := svc.acquireTrivyScanSlotInternal(t.Context(), tt.queuedImage, false)
+ require.NoError(t, err)
+ require.Nil(t, queuedRelease)
+ result := make(chan error, 1)
+ started := make(chan struct{})
+ go func() {
+ close(started)
+ _, done, err := svc.acquireTrivyScanSlotInternal(t.Context(), tt.queuedImage, true)
+ if done != nil {
+ done()
+ }
+ result <- err
+ }()
+ <-started
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
+ // An admitted scan can prepare its scanner even after the feature is disabled.
+ scannerImage, err := svc.ensureTrivyImageInternal(t.Context())
+ require.NoError(t, err)
+ require.NotEmpty(t, scannerImage)
+ require.Equal(t, int32(1), inspections.Load())
+ require.Len(t, svc.trivyScanSlots, tt.slots-1)
+ release()
+ select {
+ case err := <-result:
+ require.ErrorIs(t, err, common.ErrFeatureDisabled)
+ case <-time.After(time.Second):
+ t.Fatal("queued scan did not return after the active scan released its resources")
+ }
+ require.Len(t, svc.trivyScanSlots, tt.slots)
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, true))
+ _, done, err := svc.acquireTrivyScanSlotInternal(t.Context(), tt.queuedImage, false)
+ require.NoError(t, err)
+ require.NotNil(t, done)
+ done()
+ })
+ }
+}
+
+func TestDisabledScheduledItemPreservesPreviousResult(t *testing.T) {
+ settingsSvc, db := featureSettingsInternal(t)
+ svc := &VulnerabilityService{settingsService: settingsSvc, db: db}
+ require.NoError(t, db.Create(&VulnerabilityScanRecord{ID: "test-image", Status: ScanStatusCompleted, ScanTime: time.Now()}).Error)
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
+ status := svc.scanSingleImage(t.Context(), nil, "test-image", "test:latest", "", "0", common.User{}, newScheduledScanNotificationSummary())
+ require.Equal(t, scanStatusSkipped, status)
+ var scan VulnerabilityScanRecord
+ require.NoError(t, db.First(&scan, "id = ?", "test-image").Error)
+ require.Equal(t, string(vulnerability.ScanStatusCompleted), scan.Status)
+}
+
+func TestDisabledFeatureSuppressesScheduledSummaryNotification(t *testing.T) {
+ settingsSvc, _ := featureSettingsInternal(t)
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
+ svc := &VulnerabilityService{settingsService: settingsSvc, notificationService: &notification.NotificationService{}}
+ summary := newScheduledScanNotificationSummary()
+ summary.totalFixable = 1
+ require.NotPanics(t, func() {
+ svc.sendScheduledVulnerabilitySummaryInternal(t.Context(), 1, summary)
+ })
+}
diff --git a/backend/internal/vulnerability/vulnerability_query.go b/backend/internal/vulnerability/vulnerability_query.go
index 513c46c9b..20798b19b 100644
--- a/backend/internal/vulnerability/vulnerability_query.go
+++ b/backend/internal/vulnerability/vulnerability_query.go
@@ -7,6 +7,8 @@ import (
"sort"
"strings"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+
"emperror.dev/errors"
"github.com/samber/mo"
@@ -20,7 +22,7 @@ import (
// GetScanResult retrieves the most recent scan result for an image
func (s *VulnerabilityService) GetScanResult(ctx context.Context, imageID string) (*vulnerability.ScanResult, error) {
- if s.db == nil {
+ if !s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) || s.db == nil {
return nil, nil
}
@@ -45,7 +47,7 @@ func (s *VulnerabilityService) GetScanResult(ctx context.Context, imageID string
// GetScanSummary retrieves just the summary for an image (for list views)
func (s *VulnerabilityService) GetScanSummary(ctx context.Context, imageID string) (*vulnerability.ScanSummary, error) {
- if s.db == nil {
+ if !s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) || s.db == nil {
return nil, nil
}
@@ -166,7 +168,7 @@ func (s *VulnerabilityService) GetEnvironmentSummary(ctx context.Context) (*vuln
}
}
- if s.db == nil {
+ if !s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) || s.db == nil {
return summary, nil
}
@@ -239,7 +241,7 @@ func (s *VulnerabilityService) currentImageIDsInternal(ctx context.Context) (ids
// high_count columns; with ignore records it is a single COUNT over the
// per-CVE item rows.
func (s *VulnerabilityService) ActionableCountExcludingIgnored(ctx context.Context) (int, error) {
- if s.db == nil {
+ if !s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) || s.db == nil {
return 0, nil
}
@@ -303,7 +305,7 @@ func (s *VulnerabilityService) ListAllVulnerabilities(ctx context.Context, envID
params.Limit = 20
}
- if s.db == nil {
+ if !s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) || s.db == nil {
return []vulnerability.VulnerabilityWithImage{}, pagination.BuildResponse(0, 0, params), nil
}
@@ -396,7 +398,7 @@ const listAllVulnerabilityRecordBatchSizeInternal = 25
// ListAllVulnerabilityImageOptions returns unique image names (or image IDs when name is empty)
// for vulnerability filtering, optionally constrained by severity.
func (s *VulnerabilityService) ListAllVulnerabilityImageOptions(ctx context.Context, severityFilter string) ([]string, error) {
- if s.db == nil {
+ if !s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) || s.db == nil {
return []string{}, nil
}
@@ -551,7 +553,7 @@ func severityRankInternal(severity vulnerability.Severity) int {
// GetScanSummariesByImageIDs retrieves scan summaries for multiple images
func (s *VulnerabilityService) GetScanSummariesByImageIDs(ctx context.Context, imageIDs []string) (map[string]*vulnerability.ScanSummary, error) {
- if s.db == nil || len(imageIDs) == 0 {
+ if !s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) || s.db == nil || len(imageIDs) == 0 {
return make(map[string]*vulnerability.ScanSummary), nil
}
diff --git a/backend/internal/vulnerability/vulnerability_scan.go b/backend/internal/vulnerability/vulnerability_scan.go
index 027822dfe..96ef0f2fb 100644
--- a/backend/internal/vulnerability/vulnerability_scan.go
+++ b/backend/internal/vulnerability/vulnerability_scan.go
@@ -2,6 +2,7 @@ package vulnerability
import (
"github.com/getarcaneapp/arcane/backend/v2/internal/event"
+ "github.com/getarcaneapp/arcane/types/v2/features"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
@@ -99,6 +100,9 @@ func (s *VulnerabilityService) applyScanPhaseToResultInternal(result *vulnerabil
// ScanImage scans an image for vulnerabilities using Trivy
func (s *VulnerabilityService) ScanImage(ctx context.Context, envID string, imageID string, user common.User) (*vulnerability.ScanResult, error) {
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ return nil, err
+ }
scanCtx := utils.ActivityRuntimeContext(ctx, nil)
// Get Docker client to inspect the image
@@ -121,6 +125,15 @@ func (s *VulnerabilityService) ScanImage(ctx context.Context, envID string, imag
imageName = imageInspect.RepoDigests[0]
}
+ slotID, releaseSlot, err := s.acquireTrivyScanSlotInternal(scanCtx, imageID, false)
+ if err != nil {
+ return nil, err
+ }
+ status := vulnerability.ScanStatusPending
+ if releaseSlot != nil {
+ status = vulnerability.ScanStatusScanning
+ }
+
slog.InfoContext(scanCtx,
"vulnerability scan queued",
"environmentId", envID,
@@ -138,7 +151,7 @@ func (s *VulnerabilityService) ScanImage(ctx context.Context, envID string, imag
ImageID: imageID,
ImageName: imageName,
ScanTime: time.Now(),
- Status: vulnerability.ScanStatusScanning,
+ Status: status,
ActivityID: mo.EmptyableToOption(strings.TrimSpace(activityID)).ToPointer(),
}
s.applyScanPhaseToResultInternal(pendingResult)
@@ -158,9 +171,7 @@ func (s *VulnerabilityService) ScanImage(ctx context.Context, envID string, imag
)
}
- go func(bgCtx context.Context, scanEnvID, imgID, imgName string, scanUser common.User, scanActivityID string) {
- s.scanImageInBackgroundInternal(bgCtx, scanEnvID, imgID, imgName, scanUser, scanActivityID)
- }(scanCtx, envID, imageID, imageName, user, activityID)
+ go s.scanImageInBackgroundInternal(scanCtx, envID, imageID, imageName, user, activityID, slotID, releaseSlot)
return pendingResult, nil
}
@@ -199,7 +210,17 @@ func (s *VulnerabilityService) markStaleScanIfNeeded(ctx context.Context, record
}
}
-func (s *VulnerabilityService) scanImageInBackgroundInternal(ctx context.Context, envID string, imageID, imageName string, user common.User, activityID string) {
+func (s *VulnerabilityService) scanImageInBackgroundInternal(ctx context.Context, envID string, imageID, imageName string, user common.User, activityID string, slotID int, releaseSlot func()) {
+ var err error
+ if releaseSlot == nil {
+ slotID, releaseSlot, err = s.acquireTrivyScanSlotInternal(ctx, imageID, true)
+ }
+ if releaseSlot != nil {
+ defer releaseSlot()
+ if updateErr := s.db.WithContext(ctx).Model(&VulnerabilityScanRecord{}).Where("id = ?", imageID).Update("status", ScanStatusScanning).Error; updateErr != nil {
+ slog.WarnContext(ctx, "failed to mark queued scan as running", "imageId", imageID, "error", updateErr)
+ }
+ }
defer s.clearScanPhaseInternal(imageID)
s.setScanPhaseInternal(imageID, vulnerability.ScanPhaseCreatingContainer)
s.updateVulnerabilityScanActivityInternal(ctx, activityID, vulnerability.ScanPhaseCreatingContainer, 10, "Preparing vulnerability scanner")
@@ -211,17 +232,24 @@ func (s *VulnerabilityService) scanImageInBackgroundInternal(ctx context.Context
"imageName", imageName,
)
- scannerImage, err := s.ensureTrivyImageInternal(ctx)
+ var scannerImage string
+ if err == nil {
+ scannerImage, err = s.ensureTrivyImageInternal(ctx)
+ }
if err != nil {
s.setScanPhaseInternal(imageID, vulnerability.ScanPhaseStoringResults)
s.updateVulnerabilityScanActivityInternal(ctx, activityID, vulnerability.ScanPhaseStoringResults, 90, "Unable to prepare vulnerability scanner")
+ errorMessage := "Trivy scanner is not available: " + err.Error()
+ if errors.Is(err, common.ErrFeatureDisabled) {
+ errorMessage = err.Error()
+ }
result := &vulnerability.ScanResult{
ImageID: imageID,
ImageName: imageName,
ScanTime: time.Now(),
Status: vulnerability.ScanStatusFailed,
ActivityID: mo.EmptyableToOption(strings.TrimSpace(activityID)).ToPointer(),
- Error: "Trivy scanner is not available: " + err.Error(),
+ Error: errorMessage,
}
if saveErr := s.saveScanResultWithRetryInternal(ctx, result); saveErr != nil {
slog.WarnContext(ctx, "failed to save scan result", "error", saveErr)
@@ -240,7 +268,7 @@ func (s *VulnerabilityService) scanImageInBackgroundInternal(ctx context.Context
s.setScanPhaseInternal(imageID, vulnerability.ScanPhaseScanningImage)
s.updateVulnerabilityScanActivityInternal(ctx, activityID, vulnerability.ScanPhaseScanningImage, 45, "Scanning image for vulnerabilities")
startTime := time.Now()
- result, err := s.runTrivyScan(ctx, scannerImage, imageName, imageID)
+ result, err := s.runTrivyScanInternal(ctx, scannerImage, imageName, imageID, slotID)
duration := time.Since(startTime).Milliseconds()
if err != nil {
@@ -416,7 +444,7 @@ func (s *VulnerabilityService) runScheduledImageScanInternal(
imageName, imageID, scannerVersion string,
) (*vulnerability.ScanResult, int64, error) {
startTime := time.Now()
- slotID, releaseSlot, slotErr := s.acquireTrivyScanSlotInternal(ctx)
+ slotID, releaseSlot, slotErr := s.acquireTrivyScanSlotInternal(ctx, "", true)
if slotErr != nil {
return nil, 0, slotErr
}
@@ -430,6 +458,9 @@ func (s *VulnerabilityService) runScheduledImageScanInternal(
}
defer func() { containerPool <- containerID }()
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ return nil, 0, err
+ }
result, scanErr := s.execTrivyScanInContainer(ctx, containerID, imageName, imageID, scannerVersion, slotID)
return result, time.Since(startTime).Milliseconds(), scanErr
@@ -513,7 +544,7 @@ func (s *VulnerabilityService) sendScheduledVulnerabilitySummaryInternal(
scanned int,
summary *scheduledScanNotificationSummary,
) {
- if summary.totalFixable == 0 || s.notificationService == nil {
+ if !s.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) || summary.totalFixable == 0 || s.notificationService == nil {
return
}
@@ -539,6 +570,9 @@ func (s *VulnerabilityService) sendScheduledVulnerabilitySummaryInternal(
// the overhead of creating/destroying a container per scan. The caller-supplied
// user is recorded in the event log.
func (s *VulnerabilityService) ScanAllImages(ctx context.Context, envID string, user common.User, force bool) (scanned, failed int, err error) {
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ return 0, 0, err
+ }
images, err := s.dockerService.ListImages(ctx)
if err != nil {
return 0, 0, errors.WrapIf(err, "failed to list images")
@@ -577,6 +611,7 @@ func (s *VulnerabilityService) ScanAllImages(ctx context.Context, envID string,
notificationSummary := newScheduledScanNotificationSummary()
var scannedCount, failedCount atomic.Int64
+ var featureStopped atomic.Bool
g, gctx := errgroup.WithContext(ctx)
g.SetLimit(concurrency)
@@ -586,11 +621,17 @@ func (s *VulnerabilityService) ScanAllImages(ctx context.Context, envID string,
if gctx.Err() != nil {
return gctx.Err()
}
+ if !s.settingsService.IsFeatureEnabled(gctx, features.VulnerabilityManagement) {
+ featureStopped.Store(true)
+ return nil
+ }
switch s.scanSingleImage(gctx, containerPool, target.imageID, target.imageName, scannerVersion, envID, user, notificationSummary) {
case scanStatusSuccess:
scannedCount.Add(1)
case scanStatusFailed:
failedCount.Add(1)
+ case scanStatusSkipped:
+ featureStopped.Store(true)
}
return nil
})
@@ -602,6 +643,9 @@ func (s *VulnerabilityService) ScanAllImages(ctx context.Context, envID string,
return scanned, failed, err
}
+ if featureStopped.Load() {
+ return scanned, failed, errors.WrapIff(common.ErrFeatureDisabled, "remaining scans stopped because feature %s was disabled", features.VulnerabilityManagement)
+ }
s.sendScheduledVulnerabilitySummaryInternal(ctx, scanned, notificationSummary)
return scanned, failed, nil
diff --git a/backend/internal/vulnerability/vulnerability_trivy.go b/backend/internal/vulnerability/vulnerability_trivy.go
index 0527b2de7..fe1eedbd3 100644
--- a/backend/internal/vulnerability/vulnerability_trivy.go
+++ b/backend/internal/vulnerability/vulnerability_trivy.go
@@ -2,6 +2,7 @@ package vulnerability
import (
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/types/v2/features"
"context"
"fmt"
@@ -36,19 +37,56 @@ type trivyRuntimeSecurityInternal struct {
privileged bool
}
-func (s *VulnerabilityService) acquireTrivyScanSlotInternal(ctx context.Context) (int, func(), error) {
- limit := s.getTrivyConcurrentScanContainersInternal()
- slotCh := s.getTrivyScanSlotChannelInternal(limit)
- if slotCh == nil {
- return 0, func() {}, nil
+// A nil release without an error means the scan must wait in the queue.
+func (s *VulnerabilityService) acquireTrivyScanSlotInternal(ctx context.Context, imageID string, wait bool) (slotID int, release func(), err error) {
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ return 0, nil, err
+ }
+ var unlock func()
+ if imageID != "" {
+ var locked bool
+ unlock, locked = s.scanLocks.TryLock(imageID)
+ if !locked {
+ if !wait {
+ return 0, nil, nil
+ }
+ unlock = s.scanLocks.Lock(imageID)
+ }
}
+ defer func() {
+ if release == nil && unlock != nil {
+ unlock()
+ }
+ }()
- select {
- case slotID := <-slotCh:
- return slotID, func() { slotCh <- slotID }, nil
- case <-ctx.Done():
- return 0, nil, ctx.Err()
+ slotCh := s.getTrivyScanSlotChannelInternal(s.getTrivyConcurrentScanContainersInternal())
+ if wait {
+ select {
+ case slotID = <-slotCh:
+ case <-ctx.Done():
+ return 0, nil, ctx.Err()
+ }
+ } else {
+ select {
+ case slotID = <-slotCh:
+ default:
+ return 0, nil, nil
+ }
+ }
+ if err := ctx.Err(); err != nil {
+ slotCh <- slotID
+ return 0, nil, err
}
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ slotCh <- slotID
+ return 0, nil, err
+ }
+ return slotID, func() {
+ slotCh <- slotID
+ if unlock != nil {
+ unlock()
+ }
+ }, nil
}
func (s *VulnerabilityService) getTrivyConcurrentScanContainersInternal() int {
@@ -127,9 +165,13 @@ type scanResultStatus int
const (
scanStatusSuccess scanResultStatus = iota
scanStatusFailed
+ scanStatusSkipped
)
func (s *VulnerabilityService) setupTrivyBatchContainersInternal(ctx context.Context, count int) ([]string, func(), error) {
+ if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
+ return nil, nil, err
+ }
dockerClient, err := s.dockerService.GetClient(ctx)
if err != nil {
return nil, nil, errors.WrapIf(err, "failed to connect to Docker")
@@ -179,6 +221,9 @@ func (s *VulnerabilityService) scanSingleImage(
result, duration, scanErr := s.runScheduledImageScanInternal(ctx, containerPool, imageName, imageID, scannerVersion)
if scanErr != nil {
+ if errors.Is(scanErr, common.ErrFeatureDisabled) {
+ return scanStatusSkipped
+ }
s.saveScheduledFailedScanInternal(ctx, envID, imageID, imageName, user, duration, scanErr)
return scanStatusFailed
}
@@ -685,7 +730,6 @@ func (s *VulnerabilityService) ensureTrivyCacheVolumeInternal(ctx context.Contex
return trivyCacheVolumeName, nil
}
-// runTrivyScan executes Trivy scan on an image
func (s *VulnerabilityService) getTrivyConfigFiles() (configContent, ignoreContent string) {
if s.settingsService == nil {
return "", ""
@@ -1084,7 +1128,7 @@ func (s *VulnerabilityService) waitForTrivyContainer(
return statusCode, nil
}
-func (s *VulnerabilityService) runTrivyScan(ctx context.Context, scannerImage string, imageName string, imageID string) (*vulnerability.ScanResult, error) {
+func (s *VulnerabilityService) runTrivyScanInternal(ctx context.Context, scannerImage string, imageName string, imageID string, slotID int) (*vulnerability.ScanResult, error) {
slog.DebugContext(ctx,
"running trivy scan",
"imageId", imageID,
@@ -1092,15 +1136,6 @@ func (s *VulnerabilityService) runTrivyScan(ctx context.Context, scannerImage st
"scannerImage", scannerImage,
)
- slotID, releaseSlot, err := s.acquireTrivyScanSlotInternal(ctx)
- if err != nil {
- return nil, err
- }
- defer releaseSlot()
-
- // Use per-image locking to allow concurrent scans of different images
- defer s.scanLocks.Lock(imageID)()
-
dockerClient, err := s.dockerService.GetClient(ctx)
if err != nil {
return nil, errors.WrapIf(err, "failed to connect to Docker")
diff --git a/backend/pkg/scheduler/auto_patch_job.go b/backend/pkg/scheduler/auto_patch_job.go
index fbf20d2ad..e77346952 100644
--- a/backend/pkg/scheduler/auto_patch_job.go
+++ b/backend/pkg/scheduler/auto_patch_job.go
@@ -4,6 +4,9 @@ import (
"context"
"log/slog"
+ "emperror.dev/errors"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+
schedulertypes "github.com/getarcaneapp/arcane/types/v2/scheduler"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
@@ -40,7 +43,7 @@ func (j *AutoPatchJob) Name() string {
}
func (j *AutoPatchJob) ShouldSchedule(ctx context.Context) bool {
- return j.settingsService.GetBoolSetting(ctx, "imageAutoPatchEnabled", false)
+ return j.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) && j.settingsService.GetBoolSetting(ctx, "imageAutoPatchEnabled", false)
}
// Schedule returns the cron expression for the job. Defaults to daily at 3 AM.
@@ -60,7 +63,7 @@ func (j *AutoPatchJob) Schedule(ctx context.Context) string {
}
func (j *AutoPatchJob) Run(ctx context.Context) (schedulertypes.Outcome, error) {
- if !j.settingsService.GetBoolSetting(ctx, "imageAutoPatchEnabled", false) {
+ if !j.ShouldSchedule(ctx) {
slog.DebugContext(ctx, "scheduled image patching disabled; skipping run")
return schedulertypes.Outcome{Status: schedulertypes.Skipped}, nil
}
@@ -68,6 +71,13 @@ func (j *AutoPatchJob) Run(ctx context.Context) (schedulertypes.Outcome, error)
slog.InfoContext(ctx, "scheduled image patching started")
patched, skipped, err := j.imagePatchService.PatchFlaggedImages(ctx, types.LocalDockerEnvironmentID, autoPatchSystemUser)
+ if errors.Is(err, common.ErrFeatureDisabled) {
+ status := schedulertypes.Skipped
+ if patched > 0 {
+ status = schedulertypes.Partial
+ }
+ return schedulertypes.Outcome{Status: status, Message: err.Error()}, nil
+ }
if err != nil {
slog.ErrorContext(ctx, "scheduled image patching failed", "error", err)
if patched > 0 {
diff --git a/backend/pkg/scheduler/vulnerability_feature_test.go b/backend/pkg/scheduler/vulnerability_feature_test.go
new file mode 100644
index 000000000..674c7b962
--- /dev/null
+++ b/backend/pkg/scheduler/vulnerability_feature_test.go
@@ -0,0 +1,50 @@
+package scheduler
+
+import (
+ "testing"
+
+ "github.com/getarcaneapp/arcane/types/v2/features"
+ schedulertypes "github.com/getarcaneapp/arcane/types/v2/scheduler"
+ "github.com/stretchr/testify/require"
+)
+
+func TestVulnerabilityFeatureGatesScheduledScansAndPatches(t *testing.T) {
+ tests := []struct {
+ name string
+ scheduleEnabled bool
+ featureEnabled bool
+ reenable bool
+ wantScheduled bool
+ }{
+ {name: "schedules disabled", featureEnabled: true},
+ {name: "schedules enabled", scheduleEnabled: true, featureEnabled: true, wantScheduled: true},
+ {name: "feature disabled", scheduleEnabled: true},
+ {name: "both disabled"},
+ {name: "feature re-enabled", scheduleEnabled: true, reenable: true, wantScheduled: true},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ settingsSvc := setupScheduledPruneSettingsServiceInternal(t)
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), "vulnerabilityScanEnabled", tt.scheduleEnabled))
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), "imageAutoPatchEnabled", tt.scheduleEnabled))
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, tt.featureEnabled))
+ if tt.reenable {
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, true))
+ }
+ jobs := []interface {
+ schedulertypes.Job
+ schedulertypes.ConditionalJob
+ }{NewVulnerabilityScanJob(nil, settingsSvc), NewAutoPatchJob(nil, settingsSvc)}
+ for _, job := range jobs {
+ t.Run(job.Name(), func(t *testing.T) {
+ require.Equal(t, tt.wantScheduled, job.ShouldSchedule(t.Context()))
+ if !tt.wantScheduled {
+ outcome, err := job.Run(t.Context())
+ require.NoError(t, err)
+ require.Equal(t, schedulertypes.Skipped, outcome.Status)
+ }
+ })
+ }
+ })
+ }
+}
diff --git a/backend/pkg/scheduler/vulnerability_scan_job.go b/backend/pkg/scheduler/vulnerability_scan_job.go
index 4b1c008f8..6c4f3af1b 100644
--- a/backend/pkg/scheduler/vulnerability_scan_job.go
+++ b/backend/pkg/scheduler/vulnerability_scan_job.go
@@ -1,7 +1,9 @@
package scheduler
import (
+ "emperror.dev/errors"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/types/v2/features"
schedulertypes "github.com/getarcaneapp/arcane/types/v2/scheduler"
"context"
@@ -40,7 +42,7 @@ func (j *VulnerabilityScanJob) Name() string {
}
func (j *VulnerabilityScanJob) ShouldSchedule(ctx context.Context) bool {
- return j.settingsService.GetBoolSetting(ctx, "vulnerabilityScanEnabled", false)
+ return j.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) && j.settingsService.GetBoolSetting(ctx, "vulnerabilityScanEnabled", false)
}
// Schedule returns the cron expression for the job. Defaults to daily at midnight.
@@ -60,8 +62,7 @@ func (j *VulnerabilityScanJob) Schedule(ctx context.Context) string {
}
func (j *VulnerabilityScanJob) Run(ctx context.Context) (schedulertypes.Outcome, error) {
- enabled := j.settingsService.GetBoolSetting(ctx, "vulnerabilityScanEnabled", false)
- if !enabled {
+ if !j.ShouldSchedule(ctx) {
slog.DebugContext(ctx, "scheduled vulnerability scan disabled; skipping run")
return schedulertypes.Outcome{Status: schedulertypes.Skipped}, nil
}
@@ -78,6 +79,13 @@ func (j *VulnerabilityScanJob) Run(ctx context.Context) (schedulertypes.Outcome,
}
scanned, failed, err := j.vulnerabilityService.ScanAllImages(ctx, types.LocalDockerEnvironmentID, vulnerabilityScanSystemUser, false)
+ if errors.Is(err, common.ErrFeatureDisabled) {
+ status := schedulertypes.Skipped
+ if scanned > 0 {
+ status = schedulertypes.Partial
+ }
+ return schedulertypes.Outcome{Status: status, Message: err.Error()}, nil
+ }
if err != nil {
slog.ErrorContext(ctx, "scheduled vulnerability scan failed", "error", err)
return schedulertypes.Outcome{}, err
diff --git a/backend/pkg/utils/handlerutil/feature.go b/backend/pkg/utils/handlerutil/feature.go
new file mode 100644
index 000000000..828bf6330
--- /dev/null
+++ b/backend/pkg/utils/handlerutil/feature.go
@@ -0,0 +1,20 @@
+package handlerutil
+
+import (
+ "fmt"
+ "net/http"
+
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+)
+
+// FeatureDisabledError identifies a disabled runtime feature in problem details.
+func FeatureDisabledError(id features.ID) *features.DisabledError {
+ return &features.DisabledError{
+ Status: http.StatusForbidden,
+ Title: http.StatusText(http.StatusForbidden),
+ Detail: fmt.Sprintf("feature %s is disabled", id),
+ Code: string(common.APIErrorCodeFeatureDisabled),
+ Feature: id,
+ }
+}
diff --git a/backend/pkg/utils/handlerutil/feature_test.go b/backend/pkg/utils/handlerutil/feature_test.go
new file mode 100644
index 000000000..da0b34d2a
--- /dev/null
+++ b/backend/pkg/utils/handlerutil/feature_test.go
@@ -0,0 +1,35 @@
+package handlerutil
+
+import (
+ "encoding/json"
+ "net/http"
+ "testing"
+
+ "github.com/danielgtaylor/huma/v2"
+ "github.com/getarcaneapp/arcane/types/v2/features"
+ "github.com/stretchr/testify/require"
+)
+
+func TestFeatureDisabledError(t *testing.T) {
+ tests := []struct {
+ name string
+ contentType string
+ wantContentType string
+ }{
+ {name: "JSON problem details", contentType: "application/json", wantContentType: "application/problem+json"},
+ {name: "CBOR problem details", contentType: "application/cbor", wantContentType: "application/problem+cbor"},
+ {name: "other content type preserved", contentType: "text/plain", wantContentType: "text/plain"},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ err := FeatureDisabledError(features.VulnerabilityManagement)
+ var statusError huma.StatusError = err
+ require.Equal(t, http.StatusForbidden, statusError.GetStatus())
+ require.Equal(t, "feature vulnerabilityManagement is disabled", err.Error())
+ require.Equal(t, tt.wantContentType, err.ContentType(tt.contentType))
+ encoded, marshalErr := json.Marshal(err)
+ require.NoError(t, marshalErr)
+ require.JSONEq(t, `{"status":403,"title":"Forbidden","detail":"feature vulnerabilityManagement is disabled","code":"feature_disabled","feature":"vulnerabilityManagement"}`, string(encoded))
+ })
+ }
+}
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index 86dbff90a..05955e36c 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -3544,5 +3544,12 @@
"host_ip_placeholder": "0.0.0.0",
"container_port_placeholder": "80",
"protocol_tcp": "TCP",
- "protocol_udp": "UDP"
+ "protocol_udp": "UDP",
+ "features_title": "Features",
+ "features_vulnerability_management": "Vulnerability management",
+ "features_vulnerability_description": "Enable vulnerability scanning, reports, and scan-based image patching. Turning this off retains saved reports and settings and lets active work finish. Standalone image patching remains available. Turning it back on restores your saved schedules.",
+ "features_vulnerability_disabled": "Vulnerability management is disabled for this environment. Saved reports and settings are retained.",
+ "features_unsupported": "Upgrade this environment’s Arcane agent to manage feature availability. Its existing behavior is unchanged.",
+ "features_unavailable": "Feature settings are unavailable. Check the environment connection and try again.",
+ "features_environment_override": "This feature setting is managed by an environment variable. Change FEATURE_VULNERABILITY_MANAGEMENT_ENABLED on this environment to update it."
}
diff --git a/frontend/src/lib/components/features/feature-disabled.svelte b/frontend/src/lib/components/features/feature-disabled.svelte
new file mode 100644
index 000000000..183954546
--- /dev/null
+++ b/frontend/src/lib/components/features/feature-disabled.svelte
@@ -0,0 +1,28 @@
+<script lang="ts">
+ import { m } from '#lib/paraglide/messages.js';
+ import { hasAnyPermission } from '#lib/utils/auth.js';
+ import { environmentStore } from '#lib/stores/environment.store.svelte.js';
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
+ import { ArcaneButton } from '#lib/components/arcane-button/index.js';
+ import { goto } from '$app/navigation';
+
+ let { environmentId: targetEnvironmentId }: { environmentId?: string } = $props();
+ const environmentId = $derived(targetEnvironmentId ?? environmentStore.selected?.id ?? '0');
+</script>
+
+<div class="flex flex-col items-start gap-4 p-6" role="status">
+ <h1 class="text-xl font-semibold">{m.features_vulnerability_management()}</h1>
+ {#if featureStore.status(environmentId) === 'ready'}
+ <p>{m.features_vulnerability_disabled()}</p>
+ {:else}
+ <p>{m.features_unavailable()}</p>
+ <ArcaneButton action="base" customLabel={m.common_retry()} onclick={() => void featureStore.refresh(environmentId)} />
+ {/if}
+ {#if hasAnyPermission(['settings:read', 'settings:write'], environmentId) && hasAnyPermission(['environments:list', 'environments:read'], '*')}
+ <ArcaneButton
+ action="base"
+ customLabel={m.features_title()}
+ onclick={() => goto(`/environments/${environmentId}?tab=features#features`)}
+ />
+ {/if}
+</div>
diff --git a/frontend/src/lib/components/settings/image-patch-settings.svelte b/frontend/src/lib/components/settings/image-patch-settings.svelte
index 5e0f43bfd..af1668a6c 100644
--- a/frontend/src/lib/components/settings/image-patch-settings.svelte
+++ b/frontend/src/lib/components/settings/image-patch-settings.svelte
@@ -1,4 +1,6 @@
<script lang="ts">
+ import { environmentStore } from '#lib/stores/environment.store.svelte.js';
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import { Switch } from '#lib/components/ui/switch/index.js';
import TextInputWithLabel from '#lib/components/form/text-input-with-label.svelte';
import SettingsRow from '#lib/components/settings/settings-row.svelte';
@@ -23,7 +25,9 @@
[K in keyof ImagePatchFormValues]: FormField<ImagePatchFormValues[K]>;
};
- let { formInputs = $bindable() }: { formInputs: ImagePatchFormInputs } = $props();
+ let { formInputs = $bindable(), environmentId }: { formInputs: ImagePatchFormInputs; environmentId?: string } = $props();
+ const targetEnvironmentId = $derived(environmentId ?? environmentStore.selected?.id ?? '0');
+ const vulnerabilityManagementEnabled = $derived(featureStore.isEnabled('vulnerabilityManagement', targetEnvironmentId));
</script>
<SectionCard
@@ -38,7 +42,11 @@
description={m.security_image_auto_patch_enabled_description()}
layout="inline"
>
- <Switch id="imageAutoPatchEnabledSwitch" bind:checked={formInputs.imageAutoPatchEnabled.value} />
+ <Switch
+ id="imageAutoPatchEnabledSwitch"
+ disabled={!vulnerabilityManagementEnabled}
+ bind:checked={formInputs.imageAutoPatchEnabled.value}
+ />
</SettingsRow>
<SettingsRow
diff --git a/frontend/src/lib/components/settings/trivy-security-settings.svelte b/frontend/src/lib/components/settings/trivy-security-settings.svelte
index f96caacd8..c9c6c2e57 100644
--- a/frontend/src/lib/components/settings/trivy-security-settings.svelte
+++ b/frontend/src/lib/components/settings/trivy-security-settings.svelte
@@ -1,4 +1,6 @@
<script lang="ts">
+ import FeatureDisabled from '#lib/components/features/feature-disabled.svelte';
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import { onMount } from 'svelte';
import { createQuery, useQueryClient } from '@tanstack/svelte-query';
import { queryKeys } from '#lib/query/query-keys.js';
@@ -78,6 +80,9 @@
sort: { column: 'name', direction: 'asc' }
};
const targetEnvironmentId = $derived(environmentId ?? environmentStore.selected?.id);
+ const vulnerabilityManagementEnabled = $derived(
+ !!targetEnvironmentId && featureStore.isEnabled('vulnerabilityManagement', targetEnvironmentId)
+ );
const networksQuery = createQuery(() => {
const requestedEnvironmentId = targetEnvironmentId;
userStore.current;
@@ -87,7 +92,8 @@
await environmentStore.ready;
return networkService.getNetworksForEnvironment(requestedEnvironmentId!, networkRequest);
},
- enabled: !!requestedEnvironmentId && hasPermission('networks:read', requestedEnvironmentId)
+ enabled:
+ vulnerabilityManagementEnabled && !!requestedEnvironmentId && hasPermission('networks:read', requestedEnvironmentId)
};
});
const customTrivyNetworkOptions = $derived(
@@ -145,171 +151,175 @@
});
</script>
-<SectionCard
- variant="transparent"
- title={m.security_vulnerability_scanning_heading()}
- icon={SecurityIcon}
- class="flex flex-col"
- contentClass="divide-y divide-border/40 lg:p-6 lg:pt-0 [&>*]:py-5 [&>*:first-child]:pt-0 [&>*:last-child]:pb-0"
->
- <div class="max-w-xl">
- <SelectWithLabel
- id="trivyDbRegistry"
- name="trivyDbRegistry"
- bind:value={formInputs.trivyDbRegistry.value}
- label={m.trivy_db_registry_label()}
- description={m.trivy_db_registry_description()}
- options={arcaneImageRegistryOptions()}
- onValueChange={(v) => (formInputs.trivyDbRegistry.value = v as 'ghcr.io' | 'docker.io')}
- />
- <ul class="mt-2 space-y-0.5 font-mono text-xs text-muted-foreground">
- {#each arcaneTrivyDbImages(formInputs.trivyDbRegistry.value) as image (image)}
- <li>{image}</li>
- {/each}
- </ul>
- </div>
-
- <SettingsRow
- label={m.security_trivy_ignore_unfixed_label()}
- description={m.security_trivy_ignore_unfixed_description()}
- layout="inline"
- >
- <Switch id="trivyIgnoreUnfixedSwitch" bind:checked={formInputs.trivyIgnoreUnfixed.value} />
- </SettingsRow>
-
- <SettingsRow
- label={m.security_trivy_network_label()}
- description={m.security_trivy_network_description()}
- helpText={m.security_trivy_network_help()}
- contentClass="max-w-xs"
+{#if vulnerabilityManagementEnabled}
+ <SectionCard
+ variant="transparent"
+ title={m.security_vulnerability_scanning_heading()}
+ icon={SecurityIcon}
+ class="flex flex-col"
+ contentClass="divide-y divide-border/40 lg:p-6 lg:pt-0 [&>*]:py-5 [&>*:first-child]:pt-0 [&>*:last-child]:pb-0"
>
- <SearchableSelect
- triggerId="trivyNetwork"
- items={trivyNetworkOptions.map((option) => ({
- value: option.value,
- label: option.label,
- hint: option.description
- }))}
- bind:value={formInputs.trivyNetwork.value}
- onSelect={(value) => (formInputs.trivyNetwork.value = value)}
- placeholder={false}
- class="w-full justify-between"
- />
- {#if formInputs.trivyNetwork.error}
- <p class="mt-2 text-sm text-destructive">{formInputs.trivyNetwork.error}</p>
- {/if}
- </SettingsRow>
+ <div class="max-w-xl">
+ <SelectWithLabel
+ id="trivyDbRegistry"
+ name="trivyDbRegistry"
+ bind:value={formInputs.trivyDbRegistry.value}
+ label={m.trivy_db_registry_label()}
+ description={m.trivy_db_registry_description()}
+ options={arcaneImageRegistryOptions()}
+ onValueChange={(v) => (formInputs.trivyDbRegistry.value = v as 'ghcr.io' | 'docker.io')}
+ />
+ <ul class="mt-2 space-y-0.5 font-mono text-xs text-muted-foreground">
+ {#each arcaneTrivyDbImages(formInputs.trivyDbRegistry.value) as image (image)}
+ <li>{image}</li>
+ {/each}
+ </ul>
+ </div>
- <div class="space-y-4">
<SettingsRow
- label={m.security_trivy_server_enabled_label()}
- description={m.security_trivy_server_enabled_description()}
+ label={m.security_trivy_ignore_unfixed_label()}
+ description={m.security_trivy_ignore_unfixed_description()}
layout="inline"
>
- <Switch id="trivyServerEnabledSwitch" bind:checked={formInputs.trivyServerEnabled.value} />
+ <Switch id="trivyIgnoreUnfixedSwitch" bind:checked={formInputs.trivyIgnoreUnfixed.value} />
</SettingsRow>
- {#if formInputs.trivyServerEnabled.value}
- <div class="space-y-4 border-l-2 border-border/60 pl-5">
- <TextInputWithLabel
- bind:value={formInputs.trivyServerUrl.value}
- error={formInputs.trivyServerUrl.error}
- label={m.security_trivy_server_url_label()}
- description={m.security_trivy_server_url_description()}
- placeholder={m.security_trivy_server_url_placeholder()}
- type="url"
- />
- <TextInputWithLabel
- bind:value={formInputs.trivyServerToken.value}
- error={formInputs.trivyServerToken.error}
- label={m.security_trivy_server_token_label()}
- description={m.security_trivy_server_token_description()}
- type="password"
- />
- <Alert.Root variant="default" class="border-amber-200 bg-amber-50 dark:border-amber-800 dark:bg-amber-950">
- <InfoIcon class="h-4 w-4 text-amber-900 dark:text-amber-100" />
- <Alert.Description class="text-amber-800 dark:text-amber-200">
- {m.security_trivy_server_note()}
- </Alert.Description>
- </Alert.Root>
- </div>
- {/if}
- </div>
-
- <SettingsRow
- label={m.security_trivy_security_opts_label()}
- description={m.security_trivy_security_opts_description()}
- helpText={m.security_trivy_security_opts_help()}
- >
- <Textarea
- bind:value={formInputs.trivySecurityOpts.value}
- aria-label={m.security_trivy_security_opts_label()}
- class="min-h-28 font-mono text-sm"
- placeholder={m.security_trivy_security_opts_placeholder()}
- rows={4}
- />
- {#if formInputs.trivySecurityOpts.error}
- <p class="mt-2 text-sm text-destructive">{formInputs.trivySecurityOpts.error}</p>
- {/if}
- </SettingsRow>
- <SettingsRow
- label={m.security_trivy_privileged_label()}
- description={m.security_trivy_privileged_description()}
- layout="inline"
- >
- <Switch id="trivyPrivilegedSwitch" bind:checked={formInputs.trivyPrivileged.value} />
- </SettingsRow>
- {#if formInputs.trivyPrivileged.value}
- <Alert.Root variant="default" class="border-amber-200 bg-amber-50 dark:border-amber-800 dark:bg-amber-950">
- <InfoIcon class="h-4 w-4 text-amber-900 dark:text-amber-100" />
- <Alert.Description class="text-amber-800 dark:text-amber-200">
- {m.security_trivy_privileged_note()}
- </Alert.Description>
- </Alert.Root>
- {/if}
-
- <div class="space-y-4">
<SettingsRow
- label={m.security_trivy_resource_limits_label()}
- description={m.security_trivy_resource_limits_description()}
- layout="inline"
+ label={m.security_trivy_network_label()}
+ description={m.security_trivy_network_description()}
+ helpText={m.security_trivy_network_help()}
+ contentClass="max-w-xs"
>
- <Switch
- id="trivyResourceLimitsEnabledSwitch"
- bind:checked={formInputs.trivyResourceLimitsEnabled.value}
- onCheckedChange={handleTrivyResourceLimitsChange}
+ <SearchableSelect
+ triggerId="trivyNetwork"
+ items={trivyNetworkOptions.map((option) => ({
+ value: option.value,
+ label: option.label,
+ hint: option.description
+ }))}
+ bind:value={formInputs.trivyNetwork.value}
+ onSelect={(value) => (formInputs.trivyNetwork.value = value)}
+ placeholder={false}
+ class="w-full justify-between"
/>
+ {#if formInputs.trivyNetwork.error}
+ <p class="mt-2 text-sm text-destructive">{formInputs.trivyNetwork.error}</p>
+ {/if}
</SettingsRow>
- {#if formInputs.trivyResourceLimitsEnabled.value}
- <div class="space-y-4 border-l-2 border-border/60 pl-5">
- <div class="grid gap-4 sm:grid-cols-2">
- <TextInputWithLabel
- bind:value={formInputs.trivyCpuLimit.value}
- error={formInputs.trivyCpuLimit.error}
- disabled={!formInputs.trivyResourceLimitsEnabled.value}
- label={m.security_trivy_cpu_limit_label()}
- helpText={m.security_trivy_cpu_limit_help()}
- type="number"
- />
+
+ <div class="space-y-4">
+ <SettingsRow
+ label={m.security_trivy_server_enabled_label()}
+ description={m.security_trivy_server_enabled_description()}
+ layout="inline"
+ >
+ <Switch id="trivyServerEnabledSwitch" bind:checked={formInputs.trivyServerEnabled.value} />
+ </SettingsRow>
+ {#if formInputs.trivyServerEnabled.value}
+ <div class="space-y-4 border-l-2 border-border/60 pl-5">
<TextInputWithLabel
- bind:value={formInputs.trivyMemoryLimitMb.value}
- error={formInputs.trivyMemoryLimitMb.error}
- disabled={!formInputs.trivyResourceLimitsEnabled.value}
- label={m.security_trivy_memory_limit_label()}
- reserveHelpTextSpace={true}
- type="number"
+ bind:value={formInputs.trivyServerUrl.value}
+ error={formInputs.trivyServerUrl.error}
+ label={m.security_trivy_server_url_label()}
+ description={m.security_trivy_server_url_description()}
+ placeholder={m.security_trivy_server_url_placeholder()}
+ type="url"
/>
- </div>
- <div class="max-w-xs">
<TextInputWithLabel
- bind:value={formInputs.trivyConcurrentScanContainers.value}
- error={formInputs.trivyConcurrentScanContainers.error}
- label={m.security_trivy_concurrent_scan_containers_label()}
- helpText={m.security_trivy_concurrent_scan_containers_help()}
- type="number"
+ bind:value={formInputs.trivyServerToken.value}
+ error={formInputs.trivyServerToken.error}
+ label={m.security_trivy_server_token_label()}
+ description={m.security_trivy_server_token_description()}
+ type="password"
/>
+ <Alert.Root variant="default" class="border-amber-200 bg-amber-50 dark:border-amber-800 dark:bg-amber-950">
+ <InfoIcon class="h-4 w-4 text-amber-900 dark:text-amber-100" />
+ <Alert.Description class="text-amber-800 dark:text-amber-200">
+ {m.security_trivy_server_note()}
+ </Alert.Description>
+ </Alert.Root>
</div>
- </div>
+ {/if}
+ </div>
+
+ <SettingsRow
+ label={m.security_trivy_security_opts_label()}
+ description={m.security_trivy_security_opts_description()}
+ helpText={m.security_trivy_security_opts_help()}
+ >
+ <Textarea
+ bind:value={formInputs.trivySecurityOpts.value}
+ aria-label={m.security_trivy_security_opts_label()}
+ class="min-h-28 font-mono text-sm"
+ placeholder={m.security_trivy_security_opts_placeholder()}
+ rows={4}
+ />
+ {#if formInputs.trivySecurityOpts.error}
+ <p class="mt-2 text-sm text-destructive">{formInputs.trivySecurityOpts.error}</p>
+ {/if}
+ </SettingsRow>
+
+ <SettingsRow
+ label={m.security_trivy_privileged_label()}
+ description={m.security_trivy_privileged_description()}
+ layout="inline"
+ >
+ <Switch id="trivyPrivilegedSwitch" bind:checked={formInputs.trivyPrivileged.value} />
+ </SettingsRow>
+ {#if formInputs.trivyPrivileged.value}
+ <Alert.Root variant="default" class="border-amber-200 bg-amber-50 dark:border-amber-800 dark:bg-amber-950">
+ <InfoIcon class="h-4 w-4 text-amber-900 dark:text-amber-100" />
+ <Alert.Description class="text-amber-800 dark:text-amber-200">
+ {m.security_trivy_privileged_note()}
+ </Alert.Description>
+ </Alert.Root>
{/if}
- </div>
-</SectionCard>
+
+ <div class="space-y-4">
+ <SettingsRow
+ label={m.security_trivy_resource_limits_label()}
+ description={m.security_trivy_resource_limits_description()}
+ layout="inline"
+ >
+ <Switch
+ id="trivyResourceLimitsEnabledSwitch"
+ bind:checked={formInputs.trivyResourceLimitsEnabled.value}
+ onCheckedChange={handleTrivyResourceLimitsChange}
+ />
+ </SettingsRow>
+ {#if formInputs.trivyResourceLimitsEnabled.value}
+ <div class="space-y-4 border-l-2 border-border/60 pl-5">
+ <div class="grid gap-4 sm:grid-cols-2">
+ <TextInputWithLabel
+ bind:value={formInputs.trivyCpuLimit.value}
+ error={formInputs.trivyCpuLimit.error}
+ disabled={!formInputs.trivyResourceLimitsEnabled.value}
+ label={m.security_trivy_cpu_limit_label()}
+ helpText={m.security_trivy_cpu_limit_help()}
+ type="number"
+ />
+ <TextInputWithLabel
+ bind:value={formInputs.trivyMemoryLimitMb.value}
+ error={formInputs.trivyMemoryLimitMb.error}
+ disabled={!formInputs.trivyResourceLimitsEnabled.value}
+ label={m.security_trivy_memory_limit_label()}
+ reserveHelpTextSpace={true}
+ type="number"
+ />
+ </div>
+ <div class="max-w-xs">
+ <TextInputWithLabel
+ bind:value={formInputs.trivyConcurrentScanContainers.value}
+ error={formInputs.trivyConcurrentScanContainers.error}
+ label={m.security_trivy_concurrent_scan_containers_label()}
+ helpText={m.security_trivy_concurrent_scan_containers_help()}
+ type="number"
+ />
+ </div>
+ </div>
+ {/if}
+ </div>
+ </SectionCard>
+{:else}
+ <FeatureDisabled environmentId={targetEnvironmentId} />
+{/if}
diff --git a/frontend/src/lib/components/vulnerability/vulnerability-scan-item.svelte b/frontend/src/lib/components/vulnerability/vulnerability-scan-item.svelte
index 59db8c57d..8c3a1fb1f 100644
--- a/frontend/src/lib/components/vulnerability/vulnerability-scan-item.svelte
+++ b/frontend/src/lib/components/vulnerability/vulnerability-scan-item.svelte
@@ -1,4 +1,5 @@
<script lang="ts">
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import { tryCatch } from '#lib/utils/try-catch.js';
import * as ArcaneTooltip from '#lib/components/arcane-tooltip/index.js';
@@ -29,7 +30,8 @@
let lastScanRequestedAt = $state<string | null>(null);
let destroyed = false;
const scanMutation = createMutation(() => ({
- mutationFn: (requestedImageId: string) => vulnerabilityService.scanImage(requestedImageId)
+ mutationFn: ({ requestedImageId, environmentId }: { requestedImageId: string; environmentId: string }) =>
+ vulnerabilityService.scanImage(requestedImageId, environmentId)
}));
const isScanning = $derived(scanMutation.isPending);
@@ -122,12 +124,19 @@
if (isScanning) return;
const requestedImageId = imageId;
const environmentId = await environmentStore.getCurrentEnvironmentId();
+ if (!featureStore.isEnabled('vulnerabilityManagement', environmentId)) return;
try {
const operationResult1 = await tryCatch(
(async () => {
- const result = await scanMutation.mutateAsync(requestedImageId);
- if (destroyed || requestedImageId !== imageId || environmentId !== environmentStore.selected?.id) return;
+ const result = await scanMutation.mutateAsync({ requestedImageId, environmentId });
+ if (
+ destroyed ||
+ !featureStore.isEnabled('vulnerabilityManagement', environmentId) ||
+ requestedImageId !== imageId ||
+ environmentId !== environmentStore.selected?.id
+ )
+ return;
if (result) {
lastScanRequestedAt = result.scanTime || nowInstantString();
const summary: VulnerabilityScanSummary = {
diff --git a/frontend/src/lib/components/vulnerability/vulnerability-scan-panel.svelte b/frontend/src/lib/components/vulnerability/vulnerability-scan-panel.svelte
index 6d95a2d85..232d2df5f 100644
--- a/frontend/src/lib/components/vulnerability/vulnerability-scan-panel.svelte
+++ b/frontend/src/lib/components/vulnerability/vulnerability-scan-panel.svelte
@@ -1,4 +1,5 @@
<script lang="ts">
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import ArcaneTable from '#lib/components/arcane-table/arcane-table.svelte';
import UniversalMobileCard from '#lib/components/arcane-table/cards/universal-mobile-card.svelte';
import CveCell from '#lib/components/vulnerability/cve-cell.svelte';
@@ -170,12 +171,16 @@
if (options.sort?.column === 'vulnSeverity') request.sort = { ...options.sort, column: 'severity' };
const offset = ((request.pagination?.page ?? 1) - 1) * (request.pagination?.limit ?? DEFAULT_PAGE_SIZE);
return {
- queryKey: [...queryKeys.vulnerabilities.imageRows(imageId, request), environmentId, scan?.scanTime],
- enabled: !!imageId && scan?.status === 'completed' && (resolvedSummary?.total ?? 0) > 0,
+ queryKey: [...queryKeys.vulnerabilities.imageRows(environmentId, imageId, request), scan?.scanTime],
+ enabled:
+ featureStore.isEnabled('vulnerabilityManagement', environmentId) &&
+ !!imageId &&
+ scan?.status === 'completed' &&
+ (resolvedSummary?.total ?? 0) > 0,
queryFn: async ({ signal }) => {
await environmentStore.ready;
signal.throwIfAborted();
- return vulnerabilityService.getImageVulnerabilities(imageId, request);
+ return vulnerabilityService.getImageVulnerabilities(imageId, request, environmentId);
},
select: (response: Paginated<VulnType>): Paginated<VulnerabilityRow> => ({
...response,
@@ -193,7 +198,12 @@
async function refreshVulnerabilityTable(options: SearchPaginationSortRequest) {
vulnerabilityRequestOptions = options;
await tick();
- if (scan?.imageId && scan.status === 'completed') await vulnerabilityQuery.refetch({ throwOnError: true });
+ if (
+ featureStore.isEnabled('vulnerabilityManagement', environmentStore.selected?.id ?? '0') &&
+ scan?.imageId &&
+ scan.status === 'completed'
+ )
+ await vulnerabilityQuery.refetch({ throwOnError: true });
return vulnerabilityItems;
}
</script>
diff --git a/frontend/src/lib/config/features.ts b/frontend/src/lib/config/features.ts
new file mode 100644
index 000000000..d89a961d0
--- /dev/null
+++ b/frontend/src/lib/config/features.ts
@@ -0,0 +1,9 @@
+import type { FeatureDefinition } from '#lib/types/features.js';
+
+export const featureDefinitions = [
+ {
+ id: 'vulnerabilityManagement',
+ settingKey: 'featureVulnerabilityManagementEnabled',
+ defaultEnabled: true
+ }
+] as const satisfies readonly FeatureDefinition[];
diff --git a/frontend/src/lib/config/navigation-config.ts b/frontend/src/lib/config/navigation-config.ts
index 4972094bb..b90244bd3 100644
--- a/frontend/src/lib/config/navigation-config.ts
+++ b/frontend/src/lib/config/navigation-config.ts
@@ -32,6 +32,8 @@ import { m } from '#lib/paraglide/messages.js';
import type { ShortcutKey } from '#lib/utils/navigation.js';
import type { PermissionsManifest, User } from '#lib/types/auth.js';
import { canReachAccessSurface } from '#lib/utils/access-policy.js';
+import type { FeatureID } from '#lib/types/features.js';
+import { featureStore } from '#lib/stores/features.store.svelte.js';
export type NavigationItem = {
title: string;
@@ -45,6 +47,7 @@ export type NavigationItem = {
*/
accessSurfaceId?: string;
adminOnly?: boolean;
+ requiredFeature?: FeatureID;
};
export type NavigationSections = {
@@ -73,6 +76,7 @@ export const navigationItems: NavigationSections = {
{
title: m.security(),
url: '/security',
+ requiredFeature: 'vulnerabilityManagement',
icon: ShieldAlertIcon,
accessSurfaceId: 'route.images.vulnerabilities'
},
@@ -320,6 +324,7 @@ function canSeeItem(
currentEnvId: string | undefined,
accessManifest: PermissionsManifest | null | undefined
): boolean {
+ if (item.requiredFeature && !featureStore.isEnabled(item.requiredFeature, currentEnvId ?? '0')) return false;
if (item.adminOnly && !user.isGlobalAdmin) return false;
if (!item.accessSurfaceId) return true;
if (!accessManifest?.accessSurfaces?.length) return true;
diff --git a/frontend/src/lib/query/query-keys.ts b/frontend/src/lib/query/query-keys.ts
index 56ca791a9..51bc52e0f 100644
--- a/frontend/src/lib/query/query-keys.ts
+++ b/frontend/src/lib/query/query-keys.ts
@@ -178,8 +178,8 @@ export const queryKeys = {
scanResult: (environmentId: string, imageId: string) => ['vulnerabilities', 'scan-result', environmentId, imageId] as const,
allByEnvironment: (environmentId: string, request: SearchPaginationSortRequest) =>
['vulnerabilities', 'all', environmentId, stableSerialize(request)] as const,
- imageRows: (imageId: string, request: SearchPaginationSortRequest) =>
- ['vulnerabilities', 'image', imageId, stableSerialize(request)] as const
+ imageRows: (environmentId: string, imageId: string, request: SearchPaginationSortRequest) =>
+ ['vulnerabilities', 'image', environmentId, imageId, stableSerialize(request)] as const
},
buildWorkspace: {
all: ['build-workspace'] as const,
diff --git a/frontend/src/lib/services/api-service.ts b/frontend/src/lib/services/api-service.ts
index 9fe8d8248..9cbe22d39 100644
--- a/frontend/src/lib/services/api-service.ts
+++ b/frontend/src/lib/services/api-service.ts
@@ -89,6 +89,9 @@ export function extractServerMessage(data: unknown, includeErrors = false): stri
const inner = asRecordInternal(innerValue);
if (!inner) return undefined;
+ if (inner['code'] === 'feature_disabled' && inner['feature'] === 'vulnerabilityManagement') {
+ return m.features_vulnerability_disabled();
+ }
const problemType = nonEmptyStringInternal(inner['type']);
const localizedMessage = problemType ? problemMessageFactoriesInternal[problemType] : undefined;
diff --git a/frontend/src/lib/services/auth-service.ts b/frontend/src/lib/services/auth-service.ts
index a4bb2cbec..9526286fe 100644
--- a/frontend/src/lib/services/auth-service.ts
+++ b/frontend/src/lib/services/auth-service.ts
@@ -9,6 +9,7 @@ import type { QueryClient } from '@tanstack/svelte-query';
import { activityStore } from '#lib/stores/activity.store.svelte.js';
import { dashboardStore } from '#lib/stores/dashboard.store.svelte.js';
import { environmentStatusStore } from '#lib/stores/environment-status.store.svelte.js';
+import { featureStore } from '#lib/stores/features.store.svelte.js';
import { getEffectiveLandingPage } from '#lib/utils/navigation.js';
import { parseInstant } from '#lib/utils/formatting.js';
import { Temporal } from 'temporal-polyfill';
@@ -225,6 +226,7 @@ class AuthService extends BaseAPIService {
resetAuthenticatedState(queryClient: QueryClient, options?: { restartMountedStores?: boolean }): void {
queryClient.clear();
+ featureStore.clear();
const restartActivityStore = activityStore.stop({ resetState: true });
const restartDashboardStore = dashboardStore.stop({ resetState: true });
const restartEnvironmentStatusStore = environmentStatusStore.stop();
diff --git a/frontend/src/lib/services/settings-service.ts b/frontend/src/lib/services/settings-service.ts
index aa752022b..75d7deb62 100644
--- a/frontend/src/lib/services/settings-service.ts
+++ b/frontend/src/lib/services/settings-service.ts
@@ -1,6 +1,7 @@
import BaseAPIService from './api-service';
import type { Settings, OidcStatusInfo } from '#lib/types/settings.js';
import { environmentStore } from '#lib/stores/environment.store.svelte.js';
+import userStore from '#lib/stores/user-store.svelte.js';
import { isLocalSetting, extractLocalSettings, extractEnvironmentSettings } from '#lib/utils/settings.svelte.js';
type KeyValuePair = { key: string; value: string };
@@ -24,7 +25,9 @@ class SettingsService extends BaseAPIService {
// - UI settings from environment 0 (main instance)
// - Environment-specific settings from current environment
const [mainSettings, envSettings] = await Promise.all([
- this.api.get('/environments/0/settings'),
+ this.api.get(
+ userStore.hasPermission('settings:read', '0') ? '/environments/0/settings' : '/environments/0/settings/public'
+ ),
this.api.get(`/environments/${environmentId}/settings`)
]);
@@ -45,11 +48,20 @@ class SettingsService extends BaseAPIService {
return this.normalize(res.data);
}
- async getPublicSettings(): Promise<Settings> {
- const res = await this.api.get(`/environments/0/settings/public`);
+ async getPublicSettingsForEnvironment(environmentId: string, signal?: AbortSignal): Promise<Settings> {
+ const res = await this.api.get(`/environments/${environmentId}/settings/public`, { signal });
return this.normalize(res.data);
}
+ async getPublicSettings(environmentId = '0'): Promise<Settings> {
+ if (environmentId === '0') return this.getPublicSettingsForEnvironment('0');
+ const [mainSettings, environmentSettings] = await Promise.all([
+ this.getPublicSettingsForEnvironment('0'),
+ this.getPublicSettingsForEnvironment(environmentId)
+ ]);
+ return { ...extractEnvironmentSettings(environmentSettings), ...extractLocalSettings(mainSettings) } as Settings;
+ }
+
async updateSettings(settings: Partial<Settings>) {
// Wait for environment store to be initialized before updating settings
await environmentStore.ready;
@@ -92,7 +104,8 @@ class SettingsService extends BaseAPIService {
}
// Reload and return merged settings
- return this.getSettings();
+ if (!userStore.hasPermission('settings:read', envId)) return this.getPublicSettings(envId);
+ return this.getSettingsForEnvironmentMerged(envId);
}
async getOidcStatus(): Promise<OidcStatusInfo> {
diff --git a/frontend/src/lib/services/vulnerability-service.ts b/frontend/src/lib/services/vulnerability-service.ts
index 7084cf9af..66a73705d 100644
--- a/frontend/src/lib/services/vulnerability-service.ts
+++ b/frontend/src/lib/services/vulnerability-service.ts
@@ -23,24 +23,28 @@ class VulnerabilityService extends BaseAPIService {
/**
* Scan an image for vulnerabilities
*/
- async scanImage(imageId: string): Promise<VulnerabilityScanResult> {
- const envId = await environmentStore.getCurrentEnvironmentId();
+ async scanImage(imageId: string, environmentId?: string): Promise<VulnerabilityScanResult> {
+ const envId = await this.resolveEnvironmentId(environmentId);
return this.handleResponse(this.api.post(`/environments/${envId}/images/${imageId}/vulnerabilities/scan`));
}
/**
* Get the full vulnerability scan result for an image
*/
- async getScanResult(imageId: string): Promise<VulnerabilityScanResult> {
- const envId = await environmentStore.getCurrentEnvironmentId();
+ async getScanResult(imageId: string, environmentId?: string): Promise<VulnerabilityScanResult> {
+ const envId = await this.resolveEnvironmentId(environmentId);
return this.handleResponse(this.api.get(`/environments/${envId}/images/${imageId}/vulnerabilities`));
}
/**
* Get a paginated list of vulnerabilities for an image
*/
- async getImageVulnerabilities(imageId: string, options?: SearchPaginationSortRequest): Promise<Paginated<Vulnerability>> {
- const envId = await environmentStore.getCurrentEnvironmentId();
+ async getImageVulnerabilities(
+ imageId: string,
+ options?: SearchPaginationSortRequest,
+ environmentId?: string
+ ): Promise<Paginated<Vulnerability>> {
+ const envId = await this.resolveEnvironmentId(environmentId);
const params = transformPaginationParams(options);
const res = await this.api.get(`/environments/${envId}/images/${imageId}/vulnerabilities/list`, { params });
return res.data;
@@ -49,16 +53,16 @@ class VulnerabilityService extends BaseAPIService {
/**
* Get just the vulnerability summary for an image (for list views)
*/
- async getScanSummary(imageId: string): Promise<VulnerabilityScanSummary> {
- const envId = await environmentStore.getCurrentEnvironmentId();
+ async getScanSummary(imageId: string, environmentId?: string): Promise<VulnerabilityScanSummary> {
+ const envId = await this.resolveEnvironmentId(environmentId);
return this.handleResponse(this.api.get(`/environments/${envId}/images/${imageId}/vulnerabilities/summary`));
}
/**
* Get vulnerability scan summaries for multiple images (batch)
*/
- async getScanSummaries(imageIds: string[]): Promise<ScanSummariesResponse> {
- const envId = await environmentStore.getCurrentEnvironmentId();
+ async getScanSummaries(imageIds: string[], environmentId?: string): Promise<ScanSummariesResponse> {
+ const envId = await this.resolveEnvironmentId(environmentId);
const payload: ScanSummariesRequest = { imageIds };
return this.handleResponse(this.api.post(`/environments/${envId}/images/vulnerabilities/summaries`, payload));
}
@@ -66,8 +70,8 @@ class VulnerabilityService extends BaseAPIService {
/**
* Get the scanner status (whether Trivy is available)
*/
- async getScannerStatus(): Promise<ScannerStatus> {
- const envId = await environmentStore.getCurrentEnvironmentId();
+ async getScannerStatus(environmentId?: string): Promise<ScannerStatus> {
+ const envId = await this.resolveEnvironmentId(environmentId);
return this.handleResponse(this.api.get(`/environments/${envId}/vulnerabilities/scanner-status`));
}
@@ -126,24 +130,27 @@ class VulnerabilityService extends BaseAPIService {
/**
* Ignore a vulnerability
*/
- async ignoreVulnerability(payload: IgnoreVulnerabilityPayload): Promise<IgnoredVulnerability> {
- const envId = await environmentStore.getCurrentEnvironmentId();
+ async ignoreVulnerability(payload: IgnoreVulnerabilityPayload, environmentId?: string): Promise<IgnoredVulnerability> {
+ const envId = await this.resolveEnvironmentId(environmentId);
return this.handleResponse(this.api.post(`/environments/${envId}/vulnerabilities/ignore`, payload));
}
/**
* Unignore a vulnerability
*/
- async unignoreVulnerability(ignoreId: string): Promise<void> {
- const envId = await environmentStore.getCurrentEnvironmentId();
+ async unignoreVulnerability(ignoreId: string, environmentId?: string): Promise<void> {
+ const envId = await this.resolveEnvironmentId(environmentId);
await this.handleResponse(this.api.delete(`/environments/${envId}/vulnerabilities/ignore/${ignoreId}`));
}
/**
* Get a list of ignored vulnerabilities
*/
- async getIgnoredVulnerabilities(options?: SearchPaginationSortRequest): Promise<Paginated<IgnoredVulnerability>> {
- const envId = await environmentStore.getCurrentEnvironmentId();
+ async getIgnoredVulnerabilities(
+ options?: SearchPaginationSortRequest,
+ environmentId?: string
+ ): Promise<Paginated<IgnoredVulnerability>> {
+ const envId = await this.resolveEnvironmentId(environmentId);
const params = transformPaginationParams(options);
const res = await this.api.get(`/environments/${envId}/vulnerabilities/ignored`, { params });
return res.data;
diff --git a/frontend/src/lib/stores/config-store.svelte.ts b/frontend/src/lib/stores/config-store.svelte.ts
index 2c113ed45..e5824e181 100644
--- a/frontend/src/lib/stores/config-store.svelte.ts
+++ b/frontend/src/lib/stores/config-store.svelte.ts
@@ -1,14 +1,18 @@
import { settingsService } from '#lib/services/settings-service.js';
import type { Settings } from '#lib/types/settings.js';
import { untrack } from 'svelte';
+import { environmentStore } from '#lib/stores/environment.store.svelte.js';
+import userStore from '#lib/stores/user-store.svelte.js';
let current = $state.raw<Settings>();
const listeners = new Set<(settings: Settings | undefined) => void>();
const reload = async () => {
- const settings = await settingsService.getSettings();
-
- set(settings);
+ const environmentId = await environmentStore.getCurrentEnvironmentId();
+ const settings = userStore.hasPermission('settings:read', environmentId)
+ ? await settingsService.getSettingsForEnvironmentMerged(environmentId)
+ : await settingsService.getPublicSettings(environmentId);
+ if (environmentId === environmentStore.selected?.id) set(settings);
};
const set = (settings: Settings) => {
diff --git a/frontend/src/lib/stores/features.store.svelte.ts b/frontend/src/lib/stores/features.store.svelte.ts
new file mode 100644
index 000000000..cdb526464
--- /dev/null
+++ b/frontend/src/lib/stores/features.store.svelte.ts
@@ -0,0 +1,82 @@
+import type { QueryClient } from '@tanstack/svelte-query';
+import { settingsService } from '#lib/services/settings-service.js';
+import type { EnvironmentFeatures, FeatureID } from '#lib/types/features.js';
+import { isFeatureEnabled, isVulnerabilityQuery, resolveFeatures } from '#lib/utils/features.js';
+
+let environments = $state.raw<Record<string, EnvironmentFeatures>>({});
+const requests = new Map<string, Promise<void>>();
+const controllers = new Map<string, AbortController>();
+let queryClient: QueryClient | undefined;
+
+async function clearVulnerabilityQueries(environmentId: string): Promise<void> {
+ if (!queryClient) return;
+ const filters = { predicate: (query: { queryKey: readonly unknown[] }) => isVulnerabilityQuery(query.queryKey, environmentId) };
+ await queryClient.cancelQueries(filters);
+ queryClient.removeQueries(filters);
+}
+
+async function markUnavailable(environmentId: string): Promise<void> {
+ controllers.get(environmentId)?.abort();
+ controllers.delete(environmentId);
+ requests.delete(environmentId);
+ environments = { ...environments, [environmentId]: { status: 'unavailable', features: {} } };
+ await clearVulnerabilityQueries(environmentId);
+}
+
+async function load(environmentId: string, force = false): Promise<void> {
+ if (!force) {
+ const pending = requests.get(environmentId);
+ if (pending) return pending;
+ if (environments[environmentId]?.status === 'ready') return;
+ }
+ controllers.get(environmentId)?.abort();
+ const controller = new AbortController();
+ controllers.set(environmentId, controller);
+ if (!environments[environmentId]) {
+ environments = { ...environments, [environmentId]: { status: 'loading', features: {} } };
+ }
+ const request = (async () => {
+ try {
+ const settings = await settingsService.getPublicSettingsForEnvironment(environmentId, controller.signal);
+ if (controller.signal.aborted) return;
+ const state = resolveFeatures(settings);
+ environments = { ...environments, [environmentId]: state };
+ if (!isFeatureEnabled(state, 'vulnerabilityManagement')) await clearVulnerabilityQueries(environmentId);
+ } catch {
+ if (controller.signal.aborted) return;
+ await markUnavailable(environmentId);
+ } finally {
+ if (controllers.get(environmentId) === controller) {
+ requests.delete(environmentId);
+ controllers.delete(environmentId);
+ }
+ }
+ })();
+ requests.set(environmentId, request);
+ await request;
+ while (controller.signal.aborted) {
+ const replacement = requests.get(environmentId);
+ if (!replacement || replacement === request) break;
+ await replacement;
+ }
+}
+
+export const featureStore = {
+ load,
+ markUnavailable,
+ refresh: (environmentId: string) => load(environmentId, true),
+ refreshKnown: () => Promise.all(Object.keys(environments).map((id) => load(id, true))),
+ status: (environmentId: string) => environments[environmentId]?.status ?? 'loading',
+ isEnabled: (id: FeatureID, environmentId: string) => isFeatureEnabled(environments[environmentId], id),
+ isSupported: (id: FeatureID, environmentId: string) =>
+ environments[environmentId]?.status === 'ready' && environments[environmentId]?.features[id]?.supported === true,
+ connect(client: QueryClient) {
+ queryClient = client;
+ },
+ clear() {
+ for (const controller of controllers.values()) controller.abort();
+ controllers.clear();
+ requests.clear();
+ environments = {};
+ }
+};
diff --git a/frontend/src/lib/types/features.ts b/frontend/src/lib/types/features.ts
new file mode 100644
index 000000000..b025b68e0
--- /dev/null
+++ b/frontend/src/lib/types/features.ts
@@ -0,0 +1,13 @@
+export type FeatureID = 'vulnerabilityManagement';
+
+export type FeatureDefinition = {
+ id: FeatureID;
+ settingKey: 'featureVulnerabilityManagementEnabled';
+ defaultEnabled: boolean;
+};
+
+export type FeatureState = { enabled: boolean; supported: boolean };
+export type EnvironmentFeatures = {
+ status: 'loading' | 'ready' | 'unavailable';
+ features: Partial<Record<FeatureID, FeatureState>>;
+};
diff --git a/frontend/src/lib/types/settings.ts b/frontend/src/lib/types/settings.ts
index 78d5a1159..ef5537e2b 100644
--- a/frontend/src/lib/types/settings.ts
+++ b/frontend/src/lib/types/settings.ts
@@ -41,6 +41,7 @@ export type Settings = {
pruneBuildCacheMode?: 'none' | 'unused' | 'all' | 'olderThan';
pruneBuildCacheUntil?: string;
vulnerabilityScanEnabled?: boolean;
+ featureVulnerabilityManagementEnabled?: boolean;
vulnerabilityScanInterval?: number;
autoHealEnabled?: boolean;
autoHealExcludedContainers?: string;
diff --git a/frontend/src/lib/utils/features.ts b/frontend/src/lib/utils/features.ts
new file mode 100644
index 000000000..4f44852c1
--- /dev/null
+++ b/frontend/src/lib/utils/features.ts
@@ -0,0 +1,23 @@
+import { featureDefinitions } from '#lib/config/features.js';
+import type { EnvironmentFeatures, FeatureID } from '#lib/types/features.js';
+import type { Settings } from '#lib/types/settings.js';
+
+export function resolveFeatures(settings: Partial<Settings>): EnvironmentFeatures {
+ const features: EnvironmentFeatures['features'] = {};
+ for (const feature of featureDefinitions) {
+ const value = settings[feature.settingKey];
+ features[feature.id] = {
+ enabled: typeof value === 'boolean' ? value : feature.defaultEnabled,
+ supported: typeof value === 'boolean'
+ };
+ }
+ return { status: 'ready', features };
+}
+
+export function isFeatureEnabled(state: EnvironmentFeatures | undefined, id: FeatureID): boolean {
+ return state?.status === 'ready' && state.features[id]?.enabled === true;
+}
+
+export function isVulnerabilityQuery(queryKey: readonly unknown[], environmentId: string): boolean {
+ return queryKey[0] === 'vulnerabilities' && queryKey[2] === environmentId;
+}
diff --git a/frontend/src/lib/utils/settings.svelte.ts b/frontend/src/lib/utils/settings.svelte.ts
index cbe1aef89..c1744c4cf 100644
--- a/frontend/src/lib/utils/settings.svelte.ts
+++ b/frontend/src/lib/utils/settings.svelte.ts
@@ -8,6 +8,7 @@ const LOCAL_SETTING_KEYS = new Set([
'authPasswordPolicy',
'authOidcConfig',
'oidcEnabled',
+ 'oidcAutoRedirectToProvider',
'oidcMergeAccounts',
'oidcSkipTlsVerify',
'oidcAutoRedirectToProvider',
diff --git a/frontend/src/routes/(app)/+layout.svelte b/frontend/src/routes/(app)/+layout.svelte
index 0dc0f6f81..92f3dbf4c 100644
--- a/frontend/src/routes/(app)/+layout.svelte
+++ b/frontend/src/routes/(app)/+layout.svelte
@@ -1,5 +1,6 @@
<script lang="ts">
import type { LayoutProps } from './$types';
+ import { untrack } from 'svelte';
import { page } from '$app/state';
import { goto, afterNavigate } from '$app/navigation';
import { getAuthRedirectPath } from '#lib/utils/auth.js';
@@ -13,6 +14,8 @@
import { getEffectiveLandingPage, getEffectiveNavigationSettings, setMobileNavigation } from '#lib/utils/navigation.js';
import { browser } from '$app/env';
import { environmentStore } from '#lib/stores/environment.store.svelte.js';
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
+ import { isEnvironmentOnline } from '#lib/utils/docker.js';
import { environmentStatusStore } from '#lib/stores/environment-status.store.svelte.js';
import {
navigationItems,
@@ -68,6 +71,19 @@
return flattenNavigationItems(items).filter((item) => item.shortcut?.length);
});
+ let previousConnections = new Map<string, boolean>();
+ $effect(() => {
+ const connections = new Map(
+ environmentStore.available.map((environment) => [environment.id, isEnvironmentOnline(environment)])
+ );
+ untrack(() => {
+ for (const [environmentId, online] of connections) {
+ if (online && previousConnections.get(environmentId) === false) void featureStore.refresh(environmentId);
+ }
+ previousConnections = connections;
+ });
+ });
+
$effect(() => {
if (!user) {
return;
@@ -123,7 +139,11 @@
}
</script>
-<svelte:window onkeydown={handleNavigationShortcut} />
+<svelte:window
+ onkeydown={handleNavigationShortcut}
+ onfocus={() => void featureStore.refreshKnown()}
+ ononline={() => void featureStore.refreshKnown()}
+/>
<Sidebar.Provider class={isMobile.current ? 'h-auto min-h-dvh' : undefined}>
{#if !isMobile.current}
diff --git a/frontend/src/routes/(app)/dashboard/dashboard-all-environments-view.svelte b/frontend/src/routes/(app)/dashboard/dashboard-all-environments-view.svelte
index 10dfb55cb..f28744c3b 100644
--- a/frontend/src/routes/(app)/dashboard/dashboard-all-environments-view.svelte
+++ b/frontend/src/routes/(app)/dashboard/dashboard-all-environments-view.svelte
@@ -1,4 +1,5 @@
<script lang="ts">
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import { goto, refreshAll } from '$app/navigation';
import { onDestroy, onMount, untrack } from 'svelte';
import { toast } from 'svelte-sonner';
@@ -269,7 +270,13 @@
containers: snapshot.containers.counts ?? { runningContainers: 0, stoppedContainers: 0, totalContainers: 0 },
imageUsageCounts: snapshot.imageUsageCounts,
volumeUsageCounts: snapshot.volumeUsageCounts,
- actionItems: snapshot.actionItems,
+ actionItems: {
+ ...snapshot.actionItems,
+ items: snapshot.actionItems.items.filter(
+ (item) =>
+ item.kind !== 'actionable_vulnerabilities' || featureStore.isEnabled('vulnerabilityManagement', environment.id)
+ )
+ },
settings: snapshot.settings,
versionInfo: snapshot.versionInfo,
snapshotState: 'ready',
@@ -319,6 +326,7 @@
untrack(() => {
for (const environment of environmentsToLoad) {
ensureEnvironmentLiveStats(environment);
+ void featureStore.load(environment.id);
}
});
});
diff --git a/frontend/src/routes/(app)/dashboard/dashboard-environments-table.svelte b/frontend/src/routes/(app)/dashboard/dashboard-environments-table.svelte
index dc78297c4..58cca0971 100644
--- a/frontend/src/routes/(app)/dashboard/dashboard-environments-table.svelte
+++ b/frontend/src/routes/(app)/dashboard/dashboard-environments-table.svelte
@@ -23,6 +23,7 @@
</script>
<script lang="ts">
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import * as Table from '#lib/components/ui/table/index.js';
import { Badge } from '#lib/components/ui/badge/index.js';
import { Skeleton } from '#lib/components/ui/skeleton/index.js';
@@ -35,6 +36,7 @@
import { cn } from '#lib/utils.js';
let { rows }: { rows: EnvironmentTableRow[] } = $props();
+ const showVulnerabilities = $derived(rows.some((row) => featureStore.isEnabled('vulnerabilityManagement', row.environment.id)));
</script>
{#snippet actionCount(count: number, href: string, icon: IconType, tone: 'amber' | 'red')}
@@ -73,7 +75,7 @@
<Table.Head>{m.containers()}</Table.Head>
<Table.Head>{m.images()}</Table.Head>
<Table.Head>{m.updates()}</Table.Head>
- <Table.Head>{m.vuln_title()}</Table.Head>
+ {#if showVulnerabilities}<Table.Head>{m.vuln_title()}</Table.Head>{/if}
<Table.Head class="text-right">{m.cpu_usage()}</Table.Head>
<Table.Head class="text-right">{m.memory_usage()}</Table.Head>
<Table.Head class="text-right">{m.dashboard_meter_disk()}</Table.Head>
@@ -105,14 +107,18 @@
</span>
</Table.Cell>
{#if row.loading}
- <Table.Cell colspan={7}><Skeleton class="h-4 w-full max-w-md" /></Table.Cell>
+ <Table.Cell colspan={showVulnerabilities ? 7 : 6}><Skeleton class="h-4 w-full max-w-md" /></Table.Cell>
{:else}
<Table.Cell class="tabular-nums">{row.running}/{row.total}</Table.Cell>
<Table.Cell class="tabular-nums">{row.images}</Table.Cell>
<Table.Cell>{@render actionCount(row.updates, '/updates', UpdateIcon, 'amber')}</Table.Cell>
- <Table.Cell>
- {@render actionCount(row.vulnerabilities, '/security', ShieldAlertIcon, 'red')}
- </Table.Cell>
+ {#if showVulnerabilities}
+ <Table.Cell>
+ {#if featureStore.isEnabled('vulnerabilityManagement', row.environment.id)}
+ {@render actionCount(row.vulnerabilities, '/security', ShieldAlertIcon, 'red')}
+ {/if}
+ </Table.Cell>
+ {/if}
<Table.Cell class="text-right">{@render metric(row.cpu, 'cpu')}</Table.Cell>
<Table.Cell class="text-right">{@render metric(row.memory, 'memory')}</Table.Cell>
<Table.Cell class="text-right">{@render metric(row.disk, 'disk')}</Table.Cell>
diff --git a/frontend/src/routes/(app)/environments/[id]/+page.svelte b/frontend/src/routes/(app)/environments/[id]/+page.svelte
index ada0eb0b1..831a1da2d 100644
--- a/frontend/src/routes/(app)/environments/[id]/+page.svelte
+++ b/frontend/src/routes/(app)/environments/[id]/+page.svelte
@@ -1,4 +1,8 @@
<script lang="ts">
+ import type { Settings } from '#lib/types/settings.js';
+ import SectionCard from '#lib/components/section-card.svelte';
+ import LabeledSwitch from '#lib/components/form/labeled-switch.svelte';
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import { tryCatch } from '#lib/utils/try-catch.js';
import { onMount } from 'svelte';
@@ -50,7 +54,8 @@
VolumesIcon,
ScanIcon,
ShieldCheckIcon,
- CodeIcon
+ CodeIcon,
+ SettingsIcon
} from '#lib/icons/index.js';
let { data } = $props();
@@ -93,7 +98,9 @@
const isLoadingVersion = $derived(versionQuery.isFetching);
let isCurrentlyStandby = $derived(currentStatus === 'standby');
- let showSettingsTabs = $derived(runtimeEnvironment.enabled && isCurrentlyOnline && settings !== null);
+ let showSettingsTabs = $derived(
+ runtimeEnvironment.enabled && isCurrentlyOnline && settings !== null && hasPermission('settings:read', environment.id)
+ );
let hasMTLSAssets = $derived(Boolean(runtimeEnvironment.edgeMTLSCertificate));
let canPairEnvironments = $derived(hasPermission('environments:pair'));
let showMTLSDownloads = $derived(
@@ -198,6 +205,7 @@
icon: ConnectionIcon
});
}
+ items.push({ value: 'features', label: m.features_title(), icon: SettingsIcon });
if (showSettingsTabs) {
items.push(
@@ -239,12 +247,18 @@
});
const activeTab = $derived(urlTab.value);
+ const vulnerabilityManagementEnabled = $derived(featureStore.isEnabled('vulnerabilityManagement', environment.id));
let securitySubTab = $state('trivy');
- const securityTabItems: TabItem[] = [
- { value: 'trivy', label: m.security_vulnerability_scanning_heading(), icon: ScanIcon },
+ const activeSecuritySubTab = $derived(
+ !vulnerabilityManagementEnabled && securitySubTab === 'trivy' ? 'patching' : securitySubTab
+ );
+ const securityTabItems: TabItem[] = $derived([
+ ...(vulnerabilityManagementEnabled
+ ? [{ value: 'trivy', label: m.security_vulnerability_scanning_heading(), icon: ScanIcon }]
+ : []),
{ value: 'patching', label: m.security_image_patching_heading(), icon: ShieldCheckIcon },
{ value: 'lifecycle', label: m.security_lifecycle_hooks_heading(), icon: CodeIcon }
- ];
+ ]);
$effect(() => {
// Don't bounce away when gitops is the only tab (offline/disabled environment) — the
@@ -294,6 +308,7 @@
pruneNetworkUntil: settings?.pruneNetworkUntil ?? '',
pruneBuildCacheMode: settings?.pruneBuildCacheMode ?? 'none',
pruneBuildCacheUntil: settings?.pruneBuildCacheUntil ?? '',
+ featureVulnerabilityManagementEnabled: settings?.featureVulnerabilityManagementEnabled ?? true,
vulnerabilityScanEnabled: settings?.vulnerabilityScanEnabled ?? false,
toolsImageRegistry: settings?.toolsImageRegistry ?? 'ghcr.io',
updateCheckRegistry: settings?.updateCheckRegistry ?? 'auto',
@@ -325,16 +340,38 @@
// Custom save handler for environment-specific settings
async function saveEnvironmentSettings(formData: EnvironmentFormValues) {
- // Update environment basic info
- await environmentManagementService.update(environment.id, {
- name: formData.name,
- enabled: formData.enabled,
- apiUrl: formData.apiUrl
- });
+ const environmentId = environment.id;
+ const featureChanged =
+ formData.featureVulnerabilityManagementEnabled !== currentSettings.featureVulnerabilityManagementEnabled;
+ if (
+ featureChanged &&
+ (!hasPermission('settings:write', environmentId) || !featureStore.isSupported('vulnerabilityManagement', environmentId))
+ ) {
+ throw new Error(m.features_unavailable());
+ }
+ if (
+ formData.name !== environment.name ||
+ formData.enabled !== environment.enabled ||
+ formData.apiUrl !== environment.apiUrl
+ ) {
+ await environmentManagementService.update(environmentId, {
+ name: formData.name,
+ enabled: formData.enabled,
+ apiUrl: formData.apiUrl
+ });
+ }
+ const parsedCurrentSettings = formSchema.safeParse(currentSettings);
+ const savedFormValues = parsedCurrentSettings.success ? parsedCurrentSettings.data : currentSettings;
+ const otherSettingsChanged = (Object.keys(formData) as (keyof EnvironmentFormValues)[]).some(
+ (key) =>
+ !['name', 'enabled', 'apiUrl', 'featureVulnerabilityManagementEnabled'].includes(key) &&
+ formData[key] !== savedFormValues[key]
+ );
+ let updates: Partial<Settings> = {};
// Update environment settings if they exist
- if (settings) {
- await settingsService.updateSettingsForEnvironment(environment.id, {
+ if (settings && otherSettingsChanged) {
+ updates = {
pollingEnabled: formData.pollingEnabled,
imageEventWatcherEnabled: formData.imageEventWatcherEnabled,
autoUpdate: formData.autoUpdate,
@@ -388,7 +425,16 @@
autoHealExcludedContainers: formData.autoHealExcludedContainers,
autoHealMaxRestarts: formData.autoHealMaxRestarts,
autoHealRestartWindow: formData.autoHealRestartWindow
- });
+ };
+ }
+ if (featureChanged) updates.featureVulnerabilityManagementEnabled = formData.featureVulnerabilityManagementEnabled;
+ if (Object.keys(updates).length > 0) await settingsService.updateSettingsForEnvironment(environmentId, updates);
+ if (featureChanged) {
+ await featureStore.refresh(environmentId);
+ if (featureStore.status(environmentId) !== 'ready') throw new Error(m.features_unavailable());
+ if (featureStore.isEnabled('vulnerabilityManagement', environmentId) !== formData.featureVulnerabilityManagementEnabled) {
+ throw new Error(m.features_environment_override());
+ }
}
await refreshEnvironment();
@@ -471,6 +517,7 @@
(async () => {
isRefreshing = true;
statusOverride = null;
+ await featureStore.refresh(environment.id);
if (environment.id !== '0' && isCurrentlyOnline) await versionQuery.refetch();
await refreshAll();
})()
@@ -766,6 +813,33 @@
<TabBar items={tabItems} value={activeTab} onValueChange={handleTabChange} />
</div>
+ <Tabs.Content value="features">
+ <section id="features">
+ <SectionCard title={m.features_title()} icon={SettingsIcon} variant="transparent">
+ {#if featureStore.status(environment.id) === 'ready'}
+ <LabeledSwitch
+ id="vulnerability-management"
+ bind:checked={formInputs.featureVulnerabilityManagementEnabled.value}
+ label={m.features_vulnerability_management()}
+ description={m.features_vulnerability_description()}
+ error={formInputs.featureVulnerabilityManagementEnabled.error}
+ disabled={!isCurrentlyOnline ||
+ !settings ||
+ settings.uiConfigDisabled ||
+ !hasPermission('settings:write', environment.id) ||
+ !featureStore.isSupported('vulnerabilityManagement', environment.id)}
+ />
+ {#if !featureStore.isSupported('vulnerabilityManagement', environment.id)}
+ <p role="status" class="mt-4 text-sm text-muted-foreground">{m.features_unsupported()}</p>
+ {/if}
+ {:else}
+ <p role="status">{m.features_unavailable()}</p>
+ <ArcaneButton action="base" customLabel={m.common_retry()} onclick={refreshEnvironment} />
+ {/if}
+ </SectionCard>
+ </section>
+ </Tabs.Content>
+
{#if runtimeEnvironment.isEdge}
<Tabs.Content value="connection">
<ConnectionEdgeTab
@@ -788,11 +862,11 @@
</Tabs.Content>
<Tabs.Content value="security">
- <Tabs.Root bind:value={securitySubTab} class="w-full">
+ <Tabs.Root value={activeSecuritySubTab} class="w-full">
<div class="mb-4">
<TabBar
items={securityTabItems}
- value={securitySubTab}
+ value={activeSecuritySubTab}
onValueChange={(value) => {
securitySubTab = value;
}}
@@ -802,7 +876,7 @@
<TrivySecuritySettings bind:formInputs environmentId={environment.id} />
</Tabs.Content>
<Tabs.Content value="patching">
- <ImagePatchSettings bind:formInputs />
+ <ImagePatchSettings bind:formInputs environmentId={environment.id} />
</Tabs.Content>
<Tabs.Content value="lifecycle">
<LifecycleSecuritySettings bind:formInputs />
diff --git a/frontend/src/routes/(app)/environments/[id]/+page.ts b/frontend/src/routes/(app)/environments/[id]/+page.ts
index cbdaf83fe..d795eeeb8 100644
--- a/frontend/src/routes/(app)/environments/[id]/+page.ts
+++ b/frontend/src/routes/(app)/environments/[id]/+page.ts
@@ -1,11 +1,14 @@
+import { featureStore } from '#lib/stores/features.store.svelte.js';
import { tryCatch } from '#lib/utils/try-catch.js';
import { environmentManagementService } from '#lib/services/env-mgmt-service.js';
import { settingsService } from '#lib/services/settings-service.js';
import { queryKeys } from '#lib/query/query-keys.js';
+import { userHasPermission } from '#lib/utils/auth.js';
+import { isEnvironmentOnline } from '#lib/utils/docker.js';
import type { PageLoad } from './$types';
export const load: PageLoad = async ({ params, parent }) => {
- const { queryClient } = await parent();
+ const { queryClient, user } = await parent();
const operationResult = await tryCatch(
(async () => {
@@ -13,13 +16,21 @@ export const load: PageLoad = async ({ params, parent }) => {
queryKey: queryKeys.environments.detail(params.id),
queryFn: () => environmentManagementService.get(params.id)
});
+ if (!environment.enabled || !isEnvironmentOnline(environment)) {
+ await featureStore.markUnavailable(params.id);
+ return { environment, settings: null };
+ }
+ await featureStore.load(params.id);
let settings = null;
const operationResult = await tryCatch(
(async () =>
queryClient.query({
queryKey: queryKeys.environments.settings(params.id),
- queryFn: () => settingsService.getSettingsForEnvironment(params.id)
+ queryFn: () =>
+ userHasPermission(user, 'settings:read', params.id)
+ ? settingsService.getSettingsForEnvironment(params.id)
+ : settingsService.getPublicSettingsForEnvironment(params.id)
}))()
);
if (operationResult.error !== null) {
diff --git a/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte b/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte
index 7a8cda5cf..fcf3d2acb 100644
--- a/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte
+++ b/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte
@@ -1,4 +1,5 @@
<script lang="ts">
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import { queryKeys } from '#lib/query/query-keys.js';
import { createQuery } from '@tanstack/svelte-query';
import { SvelteSet } from 'svelte/reactivity';
@@ -26,6 +27,7 @@
let { formInputs = $bindable(), environmentId }: JobsTabProps = $props();
+ const vulnerabilityManagementEnabled = $derived(featureStore.isEnabled('vulnerabilityManagement', environmentId));
const jobsQuery = createQuery(() => ({
queryKey: queryKeys.jobs.list(environmentId),
queryFn: async () => {
@@ -143,6 +145,7 @@
}
function getEnabledOverride(job: JobStatus): boolean | undefined {
+ if (!vulnerabilityManagementEnabled && (job.id === 'vulnerability-scan' || job.id === 'auto-patch')) return false;
switch (job.id) {
case 'scheduled-prune':
return formInputs.scheduledPruneEnabled.value;
@@ -301,7 +304,11 @@
{:else if job.id === 'scheduled-prune'}
<Switch aria-label={job.name} bind:checked={formInputs.scheduledPruneEnabled.value} />
{:else if job.id === 'vulnerability-scan'}
- <Switch aria-label={job.name} bind:checked={formInputs.vulnerabilityScanEnabled.value} />
+ <Switch
+ aria-label={job.name}
+ bind:checked={formInputs.vulnerabilityScanEnabled.value}
+ disabled={!vulnerabilityManagementEnabled}
+ />
{:else if job.id === 'auto-heal'}
<Switch aria-label={job.name} bind:checked={formInputs.autoHealEnabled.value} />
{/if}
diff --git a/frontend/src/routes/(app)/environments/[id]/components/environment-form-schema.ts b/frontend/src/routes/(app)/environments/[id]/components/environment-form-schema.ts
index 20f4a235e..09c2b0c3d 100644
--- a/frontend/src/routes/(app)/environments/[id]/components/environment-form-schema.ts
+++ b/frontend/src/routes/(app)/environments/[id]/components/environment-form-schema.ts
@@ -32,6 +32,7 @@ export const environmentFormSchema = z
pruneNetworkUntil: z.string(),
pruneBuildCacheMode: z.enum(['none', 'unused', 'all', 'olderThan']),
pruneBuildCacheUntil: z.string(),
+ featureVulnerabilityManagementEnabled: z.boolean(),
vulnerabilityScanEnabled: z.boolean(),
toolsImageRegistry: z.enum(['ghcr.io', 'docker.io']),
updateCheckRegistry: z.enum(['auto', 'ghcr.io', 'docker.io']),
diff --git a/frontend/src/routes/(app)/images/+page.ts b/frontend/src/routes/(app)/images/+page.ts
index ec8006c73..66a52f20c 100644
--- a/frontend/src/routes/(app)/images/+page.ts
+++ b/frontend/src/routes/(app)/images/+page.ts
@@ -1,3 +1,4 @@
+import { featureStore } from '#lib/stores/features.store.svelte.js';
import { tryCatch } from '#lib/utils/try-catch.js';
import { imageService } from '#lib/services/image-service.js';
import { settingsService } from '#lib/services/settings-service.js';
@@ -15,6 +16,7 @@ export const load: PageLoad = async ({ parent }) => {
column: 'created',
direction: 'desc'
});
+ await featureStore.load(envId);
let images;
let settings;
let imageUsageCounts;
diff --git a/frontend/src/routes/(app)/images/[imageId]/+page.svelte b/frontend/src/routes/(app)/images/[imageId]/+page.svelte
index 61f118d48..7358f6a17 100644
--- a/frontend/src/routes/(app)/images/[imageId]/+page.svelte
+++ b/frontend/src/routes/(app)/images/[imageId]/+page.svelte
@@ -1,4 +1,5 @@
<script lang="ts">
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import * as Tabs from '#lib/components/ui/tabs/index.js';
import { goto } from '$app/navigation';
import { Badge } from '#lib/components/ui/badge/index.js';
@@ -49,11 +50,14 @@
let { data } = $props();
let { image } = $derived(data);
+ const currentEnvId = $derived(environmentStore.selected?.id || '0');
+ const vulnerabilityManagementEnabled = $derived(featureStore.isEnabled('vulnerabilityManagement', currentEnvId));
+
const tabItems: TabItem[] = $derived([
{ value: 'overview', label: m.common_overview(), icon: ImagesIcon },
{ value: 'history', label: m.images_history_title(), icon: LayersIcon },
{ value: 'attestations', label: m.images_attestations_title(), icon: InspectIcon },
- { value: 'vulnerabilities', label: m.vuln_title(), icon: ShieldCheckIcon }
+ ...(vulnerabilityManagementEnabled ? [{ value: 'vulnerabilities', label: m.vuln_title(), icon: ShieldCheckIcon }] : [])
]);
const urlTab = useUrlTab({
validTabs: () => tabItems.map((tab) => tab.value),
@@ -61,10 +65,12 @@
});
const activeTab = $derived(urlTab.value);
- const currentEnvId = $derived(environmentStore.selected?.id || '0');
+ $effect(() => {
+ if (!vulnerabilityManagementEnabled) stopPolling();
+ });
// fallow-ignore-next-line code-duplication -- permission $derived declarations; script-level, no shared render surface
const canDeleteImage = $derived(hasPermission('images:delete', currentEnvId));
- const canScanImage = $derived(hasPermission('vulnerabilities:scan', currentEnvId));
+ const canScanImage = $derived(vulnerabilityManagementEnabled && hasPermission('vulnerabilities:scan', currentEnvId));
const canPatchImage = $derived(hasPermission('images:patch', currentEnvId));
const canTagImage = $derived(hasPermission('images:tag', currentEnvId));
const canReadImage = $derived(hasPermission('images:read', currentEnvId));
@@ -86,15 +92,16 @@
userStore.current;
return {
queryKey: queryKeys.vulnerabilities.scanResult(environmentId, imageId ?? ''),
- queryFn: async () => {
+ queryFn: async ({ signal }) => {
await environmentStore.ready;
- return vulnerabilityService.getScanResult(imageId!);
+ signal.throwIfAborted();
+ return vulnerabilityService.getScanResult(imageId!, environmentId);
},
- enabled: !!imageId && hasPermission('vulnerabilities:read', environmentId),
+ enabled: vulnerabilityManagementEnabled && !!imageId && hasPermission('vulnerabilities:read', environmentId),
retry: false
};
});
- const vulnerabilityScan = $derived(scanQuery.data ?? null);
+ const vulnerabilityScan = $derived(vulnerabilityManagementEnabled ? (scanQuery.data ?? null) : null);
const scanInProgress = $derived(isVulnerabilityScanInProgress(vulnerabilityScan?.status));
let stopScanPolling: (() => void) | null = null;
let pollingScope = '';
@@ -106,7 +113,7 @@
let destroyed = false;
async function handleScanImage() {
- if (!image?.id || isLoading.scanning) return;
+ if (!canScanImage || !image?.id || isLoading.scanning) return;
const environmentId = currentEnvId;
const requestedImageId = image.id;
const requestedKey = scanQueryKey;
@@ -115,9 +122,10 @@
const operationResult = await tryCatch(
(async () => {
await queryClient.cancelQueries({ queryKey: requestedKey });
- const result = await vulnerabilityService.scanImage(requestedImageId);
+ const result = await vulnerabilityService.scanImage(requestedImageId, environmentId);
+ if (destroyed || !vulnerabilityManagementEnabled || environmentId !== currentEnvId || requestedImageId !== image.id)
+ return;
queryClient.setQueryData(requestedKey, result);
- if (destroyed || environmentId !== currentEnvId || requestedImageId !== image.id) return;
scanRequest = { scope: `${environmentId}:${requestedImageId}`, time: result.scanTime || nowInstantString() };
if (isVulnerabilityScanInProgress(result.status)) {
toastVulnerabilityScanStatus(result, { includeStarted: true });
@@ -164,80 +172,95 @@
}
function beginScanPolling(showToast: boolean) {
- if (!image?.id || stopScanPolling) return;
+ if (!vulnerabilityManagementEnabled || !image?.id || stopScanPolling) return;
const environmentId = currentEnvId;
const requestedImageId = image.id;
const requestedKey = scanQueryKey;
pollingScope = `${environmentId}:${requestedImageId}`;
- const cancel = startVulnerabilityScanPolling(requestedImageId, (id) => vulnerabilityService.getScanSummary(id), {
- onUpdate: (summary) => {
- if (destroyed || environmentId !== currentEnvId || requestedImageId !== image.id) return;
- queryClient.setQueryData(requestedKey, {
- ...(vulnerabilityScan ?? {}),
- imageId: summary.imageId,
- scanTime: summary.scanTime,
- status: summary.status,
- scanPhase: summary.scanPhase,
- summary: summary.summary,
- error: summary.error
- } as VulnerabilityScanResult);
- },
- onComplete: async (summary) => {
- if (destroyed || environmentId !== currentEnvId || requestedImageId !== image.id) return;
- let resolvedSummary = summary;
- const operationResult = await tryCatch(
- (async () =>
- stabilizeFailedVulnerabilitySummary(summary.imageId, summary, (id) => vulnerabilityService.getScanSummary(id), {
- scanRequestedAt: lastScanRequestedAt ?? vulnerabilityScan?.scanTime
- }))()
- );
- if (operationResult.error !== null) {
- // Keep original summary when stabilization check fails.
- } else {
- resolvedSummary = operationResult.data;
- }
-
- if (destroyed || environmentId !== currentEnvId || requestedImageId !== image.id) return;
- if (isVulnerabilityScanInProgress(resolvedSummary.status)) {
+ const cancel = startVulnerabilityScanPolling(
+ requestedImageId,
+ (id) => vulnerabilityService.getScanSummary(id, environmentId),
+ {
+ onUpdate: (summary) => {
+ if (destroyed || !vulnerabilityManagementEnabled || environmentId !== currentEnvId || requestedImageId !== image.id)
+ return;
queryClient.setQueryData(requestedKey, {
...(vulnerabilityScan ?? {}),
- imageId: resolvedSummary.imageId,
- scanTime: resolvedSummary.scanTime,
- status: resolvedSummary.status,
- scanPhase: resolvedSummary.scanPhase,
- summary: resolvedSummary.summary,
- error: resolvedSummary.error
+ imageId: summary.imageId,
+ scanTime: summary.scanTime,
+ status: summary.status,
+ scanPhase: summary.scanPhase,
+ summary: summary.summary,
+ error: summary.error
} as VulnerabilityScanResult);
- stopPolling();
- beginScanPolling(false);
- return;
- }
+ },
+ onComplete: async (summary) => {
+ if (destroyed || !vulnerabilityManagementEnabled || environmentId !== currentEnvId || requestedImageId !== image.id)
+ return;
+ let resolvedSummary = summary;
+ const operationResult = await tryCatch(
+ (async () =>
+ stabilizeFailedVulnerabilitySummary(
+ summary.imageId,
+ summary,
+ (id) => vulnerabilityService.getScanSummary(id, environmentId),
+ {
+ scanRequestedAt: lastScanRequestedAt ?? vulnerabilityScan?.scanTime
+ }
+ ))()
+ );
+ if (operationResult.error !== null) {
+ // Keep original summary when stabilization check fails.
+ } else {
+ resolvedSummary = operationResult.data;
+ }
- stopPolling();
- const operationResult2 = await tryCatch((async () => vulnerabilityService.getScanResult(resolvedSummary.imageId))());
- if (destroyed || environmentId !== currentEnvId || requestedImageId !== image.id) return;
- if (operationResult2.error !== null) {
- const error = operationResult2.error;
+ if (destroyed || !vulnerabilityManagementEnabled || environmentId !== currentEnvId || requestedImageId !== image.id)
+ return;
+ if (isVulnerabilityScanInProgress(resolvedSummary.status)) {
+ queryClient.setQueryData(requestedKey, {
+ ...(vulnerabilityScan ?? {}),
+ imageId: resolvedSummary.imageId,
+ scanTime: resolvedSummary.scanTime,
+ status: resolvedSummary.status,
+ scanPhase: resolvedSummary.scanPhase,
+ summary: resolvedSummary.summary,
+ error: resolvedSummary.error
+ } as VulnerabilityScanResult);
+ stopPolling();
+ beginScanPolling(false);
+ return;
+ }
- console.error('Failed to load scan result:', error);
- queryClient.setQueryData(requestedKey, {
- ...(vulnerabilityScan ?? {}),
- imageId: resolvedSummary.imageId,
- scanTime: resolvedSummary.scanTime,
- status: resolvedSummary.status,
- scanPhase: resolvedSummary.scanPhase,
- summary: resolvedSummary.summary,
- error: resolvedSummary.error
- } as VulnerabilityScanResult);
- } else {
- queryClient.setQueryData(requestedKey, operationResult2.data);
- }
- if (showToast) {
- toastVulnerabilityScanStatus(resolvedSummary);
- }
- },
- onError: () => {}
- });
+ stopPolling();
+ const operationResult2 = await tryCatch(
+ (async () => vulnerabilityService.getScanResult(resolvedSummary.imageId, environmentId))()
+ );
+ if (destroyed || !vulnerabilityManagementEnabled || environmentId !== currentEnvId || requestedImageId !== image.id)
+ return;
+ if (operationResult2.error !== null) {
+ const error = operationResult2.error;
+
+ console.error('Failed to load scan result:', error);
+ queryClient.setQueryData(requestedKey, {
+ ...(vulnerabilityScan ?? {}),
+ imageId: resolvedSummary.imageId,
+ scanTime: resolvedSummary.scanTime,
+ status: resolvedSummary.status,
+ scanPhase: resolvedSummary.scanPhase,
+ summary: resolvedSummary.summary,
+ error: resolvedSummary.error
+ } as VulnerabilityScanResult);
+ } else {
+ queryClient.setQueryData(requestedKey, operationResult2.data);
+ }
+ if (showToast) {
+ toastVulnerabilityScanStatus(resolvedSummary);
+ }
+ },
+ onError: () => {}
+ }
+ );
stopScanPolling = cancel;
}
@@ -474,9 +497,11 @@
<Tabs.Content value="attestations">
<ImageAttestationsPanel {image} />
</Tabs.Content>
- <Tabs.Content value="vulnerabilities">
- <VulnerabilityScanPanel scan={vulnerabilityScan} isScanning={isLoading.scanning} onScan={handleScanImage} />
- </Tabs.Content>
+ {#if vulnerabilityManagementEnabled}
+ <Tabs.Content value="vulnerabilities">
+ <VulnerabilityScanPanel scan={vulnerabilityScan} isScanning={isLoading.scanning} onScan={handleScanImage} />
+ </Tabs.Content>
+ {/if}
</Tabs.Root>
{:else}
<div class="py-12 text-center">
diff --git a/frontend/src/routes/(app)/images/[imageId]/+page.ts b/frontend/src/routes/(app)/images/[imageId]/+page.ts
index 2bf687e29..23701d990 100644
--- a/frontend/src/routes/(app)/images/[imageId]/+page.ts
+++ b/frontend/src/routes/(app)/images/[imageId]/+page.ts
@@ -1,3 +1,4 @@
+import { featureStore } from '#lib/stores/features.store.svelte.js';
import { tryCatch } from '#lib/utils/try-catch.js';
import { imageService } from '#lib/services/image-service.js';
import { environmentStore } from '#lib/stores/environment.store.svelte.js';
@@ -16,6 +17,7 @@ export const load: PageLoad = async ({ params, parent }): Promise<ImageDetailDat
const { queryClient } = await parent();
const envId = await environmentStore.getCurrentEnvironmentId();
+ await featureStore.load(envId);
const { imageId } = params;
const operationResult = await tryCatch(
diff --git a/frontend/src/routes/(app)/images/image-table.svelte b/frontend/src/routes/(app)/images/image-table.svelte
index 03b61082e..bbf6c0c74 100644
--- a/frontend/src/routes/(app)/images/image-table.svelte
+++ b/frontend/src/routes/(app)/images/image-table.svelte
@@ -1,4 +1,5 @@
<script lang="ts">
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import ArcaneTable from '#lib/components/arcane-table/arcane-table.svelte';
import * as DropdownMenu from '#lib/components/ui/dropdown-menu/index.js';
import RowActionsMenu from '#lib/components/arcane-table/row-actions-menu.svelte';
@@ -73,6 +74,10 @@
});
const currentEnvId = $derived(environmentStore.selected?.id || '0');
+ const vulnerabilityManagementEnabled = $derived(featureStore.isEnabled('vulnerabilityManagement', currentEnvId));
+ $effect(() => {
+ if (!vulnerabilityManagementEnabled) stopBatchScanPolling();
+ });
// Track the user store: hasPermission reads it non-reactively, so without
// this the deriveds would cache pre-hydration falses forever.
const canDeleteImage = $derived.by(() => {
@@ -85,7 +90,7 @@
});
const canScanImage = $derived.by(() => {
userStore.current;
- return hasPermission('vulnerabilities:scan', currentEnvId);
+ return vulnerabilityManagementEnabled && hasPermission('vulnerabilities:scan', currentEnvId);
});
const canTagImage = $derived.by(() => {
userStore.current;
@@ -192,9 +197,10 @@
}
async function handleInlineVulnerabilityScan(imageId: string) {
+ if (!canScanImage) return;
const requestedEnvId = currentEnvId;
- const result = await tryCatch(vulnerabilityService.scanImage(imageId));
- if (destroyed || requestedEnvId !== currentEnvId) return;
+ const result = await tryCatch(vulnerabilityService.scanImage(imageId, currentEnvId));
+ if (destroyed || !vulnerabilityManagementEnabled || requestedEnvId !== currentEnvId) return;
await handleApiResultWithCallbacks({
result,
message: m.vuln_scan_failed(),
@@ -286,6 +292,7 @@
}
function getScanningImageIds(): string[] {
+ if (!vulnerabilityManagementEnabled) return [];
return (images.data ?? [])
.filter((item) => isVulnerabilityScanInProgress(item.vulnerabilityScan?.status))
.map((item) => item.id);
@@ -308,8 +315,8 @@
try {
const operationResult = await tryCatch(
(async () => {
- const response = await vulnerabilityService.getScanSummaries(imageIds);
- if (destroyed || requestedEnvId !== currentEnvId) return;
+ const response = await vulnerabilityService.getScanSummaries(imageIds, requestedEnvId);
+ if (destroyed || !vulnerabilityManagementEnabled || requestedEnvId !== currentEnvId) return;
const summaries = response?.summaries ?? {};
if (Object.keys(summaries).length > 0 && images.data?.length) {
@@ -387,7 +394,7 @@
stopBatchScanPolling();
});
- const columns = [
+ const allColumns = [
{ accessorKey: 'id', title: m.common_id(), hidden: true },
{ accessorKey: 'repo', title: m.resource_repository_cap(), sortable: true, cell: RepoCell },
{ accessorKey: 'repoTags', title: m.common_tags(), cell: TagCell },
@@ -442,7 +449,9 @@
{ accessorKey: 'created', title: m.common_created(), sortable: true, cellComponent: UnixCreatedCell }
] satisfies ColumnSpec<ImageSummaryDto>[];
- const mobileFields = [
+ const columns = $derived(allColumns.filter((column) => vulnerabilityManagementEnabled || column.id !== 'vulnerabilities'));
+
+ const allMobileFields = [
{ id: 'id', label: m.common_id(), defaultVisible: false },
{ id: 'repoTags', label: m.common_tags(), defaultVisible: true },
{ id: 'inUse', label: m.common_status(), defaultVisible: true },
@@ -453,6 +462,10 @@
{ id: 'created', label: m.common_created(), defaultVisible: true }
];
+ const mobileFields = $derived(
+ allMobileFields.filter((field) => vulnerabilityManagementEnabled || field.id !== 'vulnerabilities')
+ );
+
const bulkActions = $derived.by<BulkAction[]>(() => [
{
id: 'remove',
@@ -621,13 +634,15 @@
{/snippet}
{#snippet VulnerabilitiesCell({ item }: { item: ImageSummaryDto })}
- <div class="flex items-center justify-center">
- <VulnerabilityScanItem
- scanSummary={item.vulnerabilityScan}
- imageId={item.id}
- onScanned={(newSummary) => handleVulnerabilityScanChanged(item.id, newSummary)}
- />
- </div>
+ {#if vulnerabilityManagementEnabled}
+ <div class="flex items-center justify-center">
+ <VulnerabilityScanItem
+ scanSummary={item.vulnerabilityScan}
+ imageId={item.id}
+ onScanned={(newSummary) => handleVulnerabilityScanChanged(item.id, newSummary)}
+ />
+ </div>
+ {/if}
{/snippet}
{#snippet MobileTagsValue(item: ImageSummaryDto)}
diff --git a/frontend/src/routes/(app)/security/+page.svelte b/frontend/src/routes/(app)/security/+page.svelte
index c31222b44..f4b63b65e 100644
--- a/frontend/src/routes/(app)/security/+page.svelte
+++ b/frontend/src/routes/(app)/security/+page.svelte
@@ -1,4 +1,6 @@
<script lang="ts">
+ import FeatureDisabled from '#lib/components/features/feature-disabled.svelte';
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import { tryCatch } from '#lib/utils/try-catch.js';
import { ResourcePageLayout, type ActionButton } from '#lib/layouts/index.js';
@@ -9,7 +11,7 @@
import { useEnvironmentRefresh } from '#lib/hooks/use-environment-refresh.svelte.js';
import type { EnvironmentVulnerabilitySummary, VulnerabilityWithImage } from '#lib/types/environment.js';
import type { Paginated, SearchPaginationSortRequest } from '#lib/types/shared.js';
- import { onMount, onDestroy } from 'svelte';
+ import { onMount, onDestroy, untrack } from 'svelte';
import SecurityVulnerabilityTable from './security-vulnerability-table.svelte';
import SecurityPatchTable from './security-patch-table.svelte';
import type { ImagePatchTargetDto } from '#lib/types/docker.js';
@@ -24,8 +26,9 @@
import { useUrlTab } from '#lib/hooks/use-url-tab.svelte.js';
let { data } = $props();
+ let displayedEnvId = $derived(data.envId);
- let summary = $derived<EnvironmentVulnerabilitySummary>(data.summary);
+ let summary = $derived<EnvironmentVulnerabilitySummary | null>(data.summary);
type VulnerabilityRow = VulnerabilityWithImage & { id: string };
let vulnerabilities = $derived<Paginated<VulnerabilityRow>>(data.vulnerabilities);
@@ -72,10 +75,12 @@
});
let patchRequestOptions = $derived<SearchPaginationSortRequest>(data.patchRequestOptions);
async function loadPatches() {
+ if (!vulnerabilityManagementEnabled) return;
+ const requestedEnvId = currentEnvId;
const operationResult = await tryCatch(
(async () => {
const response = await imageService.listPatchTargets(patchRequestOptions);
- if (destroyed) return;
+ if (destroyed || !vulnerabilityManagementEnabled || requestedEnvId !== currentEnvId) return;
patchTargets = { ...response, data: (response.data ?? []).map((t) => ({ ...t, id: t.imageId })) };
})()
);
@@ -114,23 +119,39 @@
});
async function refreshAll() {
+ const requestedEnvId = currentEnvId;
+ if (displayedEnvId !== requestedEnvId) {
+ summary = null;
+ vulnerabilities = { data: [], pagination: { totalPages: 0, totalItems: 0, currentPage: 1, itemsPerPage: 20 } };
+ patchTargets = { data: [], pagination: { totalPages: 0, totalItems: 0, currentPage: 1, itemsPerPage: 20 } };
+ displayedEnvId = requestedEnvId;
+ }
+ await featureStore.refresh(requestedEnvId);
+ if (requestedEnvId !== currentEnvId || !vulnerabilityManagementEnabled) return;
const requestForApi = mapVulnerabilityRequest(withIgnoredFilter(requestOptions, showIgnored));
await parallelRefresh(
{
summary: {
- fetch: () => vulnerabilityService.getEnvironmentSummary(),
- onSuccess: (data) => (summary = data),
+ fetch: () => vulnerabilityService.getEnvironmentSummaryForEnvironment(requestedEnvId),
+ onSuccess: (data) => {
+ if (!destroyed && vulnerabilityManagementEnabled && requestedEnvId === currentEnvId) summary = data;
+ },
errorMessage: m.common_refresh_failed({ resource: m.security() })
},
vulnerabilities: {
- fetch: () => vulnerabilityService.getAllVulnerabilities(requestForApi),
- onSuccess: (data) => (vulnerabilities = mapVulnerabilityPage(data, requestOptions)),
+ fetch: () => vulnerabilityService.getAllVulnerabilitiesForEnvironment(requestedEnvId, requestForApi),
+ onSuccess: (data) => {
+ if (!destroyed && vulnerabilityManagementEnabled && requestedEnvId === currentEnvId)
+ vulnerabilities = mapVulnerabilityPage(data, requestOptions);
+ },
errorMessage: m.common_refresh_failed({ resource: m.vuln_title() })
},
patches: {
fetch: () => imageService.listPatchTargets(patchRequestOptions),
- onSuccess: (data) =>
- (patchTargets = { ...data, data: (data.data ?? []).map((t: ImagePatchTargetDto) => ({ ...t, id: t.imageId })) }),
+ onSuccess: (data) => {
+ if (!destroyed && vulnerabilityManagementEnabled && requestedEnvId === currentEnvId)
+ patchTargets = { ...data, data: (data.data ?? []).map((t: ImagePatchTargetDto) => ({ ...t, id: t.imageId })) };
+ },
errorMessage: m.common_refresh_failed({ resource: m.patches() })
}
},
@@ -156,7 +177,7 @@
stopScanPolling();
const tick = async () => {
- if (destroyed) return;
+ if (destroyed || !vulnerabilityManagementEnabled) return;
if (attempts >= MAX_ATTEMPTS) {
stopScanPolling();
return;
@@ -169,7 +190,7 @@
}
await refreshAll();
- if (destroyed) return;
+ if (destroyed || !vulnerabilityManagementEnabled) return;
const currentScanned = summary?.scannedImages ?? 0;
const currentTotal = summary?.totalImages ?? targetTotal;
@@ -235,8 +256,9 @@
});
async function scanAllImages() {
- if (isLoading.scanningAll) return;
+ if (!vulnerabilityManagementEnabled || isLoading.scanningAll) return;
+ const requestedEnvId = currentEnvId;
isLoading.scanningAll = true;
scanProgress = { current: 0, total: 0 };
@@ -262,13 +284,14 @@
let failed = 0;
for (let i = 0; i < images.length; i += BATCH_SIZE) {
+ if (destroyed || !vulnerabilityManagementEnabled || requestedEnvId !== currentEnvId) return;
const batch = images.slice(i, i + BATCH_SIZE);
await Promise.all(
batch.map(async (image) => {
const operationResult = await tryCatch(
(async () => {
- const result = await vulnerabilityService.scanImage(image.id);
+ const result = await vulnerabilityService.scanImage(image.id, requestedEnvId);
if (result.status === 'completed' || result.status === 'scanning' || result.status === 'pending') {
succeeded++;
} else {
@@ -313,7 +336,21 @@
}
const currentEnvId = $derived(environmentStore.selected?.id || '0');
- const canScanVuln = $derived(hasPermission('vulnerabilities:scan', currentEnvId));
+ const vulnerabilityManagementEnabled = $derived(featureStore.isEnabled('vulnerabilityManagement', currentEnvId));
+ let wasFeatureEnabled = true;
+ $effect(() => {
+ const enabled = vulnerabilityManagementEnabled;
+ if (!enabled) {
+ stopScanPolling();
+ summary = null;
+ vulnerabilities = { data: [], pagination: { totalPages: 0, totalItems: 0, currentPage: 1, itemsPerPage: 20 } };
+ patchTargets = { data: [], pagination: { totalPages: 0, totalItems: 0, currentPage: 1, itemsPerPage: 20 } };
+ } else if (!wasFeatureEnabled) {
+ untrack(() => void refreshAll());
+ }
+ wasFeatureEnabled = enabled;
+ });
+ const canScanVuln = $derived(vulnerabilityManagementEnabled && hasPermission('vulnerabilities:scan', currentEnvId));
const actionButtons: ActionButton[] = $derived.by(() => {
const buttons: ActionButton[] = [];
@@ -340,50 +377,63 @@
});
</script>
-<ResourcePageLayout title={m.security()} subtitle={m.security_subtitle()} {actionButtons}>
+<ResourcePageLayout
+ title={m.security()}
+ subtitle={m.security_subtitle()}
+ actionButtons={vulnerabilityManagementEnabled ? actionButtons : []}
+>
{#snippet mainContent()}
- <div class="space-y-6">
- <div class="rounded-lg border border-border/40 bg-muted/20 px-4 py-3">
- <div class="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
- <div class="flex items-baseline gap-4 text-xs text-muted-foreground">
- <span
- >{m.security_images_scanned()}:
- <span class="font-medium text-foreground tabular-nums">{imagesScannedLabel}</span></span
- >
- <span
- >{m.security_total_vulnerabilities()}:
- <span class="font-medium text-foreground tabular-nums">{summaryCounts.total}</span></span
- >
- </div>
- {#if severityItems.length > 0}
- <div class="flex flex-wrap items-center gap-x-4 gap-y-1.5">
- {#each severityItems as item (item.key)}
- <div class="flex items-center gap-1.5">
- <span class="{item.dotClass} h-1.5 w-1.5 shrink-0 rounded-full" aria-hidden="true"></span>
- <span class="text-xs text-muted-foreground">
- <span class="font-semibold text-foreground tabular-nums">{item.value}</span>
- <span class="ml-0.5">{item.label}</span>
- </span>
- </div>
- {/each}
+ {#if !vulnerabilityManagementEnabled}
+ <FeatureDisabled />
+ {:else}
+ <div class="space-y-6">
+ <div class="rounded-lg border border-border/40 bg-muted/20 px-4 py-3">
+ <div class="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+ <div class="flex items-baseline gap-4 text-xs text-muted-foreground">
+ <span
+ >{m.security_images_scanned()}:
+ <span class="font-medium text-foreground tabular-nums">{imagesScannedLabel}</span></span
+ >
+ <span
+ >{m.security_total_vulnerabilities()}:
+ <span class="font-medium text-foreground tabular-nums">{summaryCounts.total}</span></span
+ >
</div>
- {/if}
+ {#if severityItems.length > 0}
+ <div class="flex flex-wrap items-center gap-x-4 gap-y-1.5">
+ {#each severityItems as item (item.key)}
+ <div class="flex items-center gap-1.5">
+ <span class="{item.dotClass} h-1.5 w-1.5 shrink-0 rounded-full" aria-hidden="true"></span>
+ <span class="text-xs text-muted-foreground">
+ <span class="font-semibold text-foreground tabular-nums">{item.value}</span>
+ <span class="ml-0.5">{item.label}</span>
+ </span>
+ </div>
+ {/each}
+ </div>
+ {/if}
+ </div>
</div>
- </div>
- <Tabs.Root value={activeTab}>
- <TabBar items={securityTabItems} value={activeTab} onValueChange={handleTabChange} />
- <Tabs.Content value="vulnerabilities" class="mt-4">
- <div class="rounded-xl border border-border/60">
- <SecurityVulnerabilityTable bind:vulnerabilities bind:requestOptions {showIgnored} onToggleIgnored={toggleIgnored} />
- </div>
- </Tabs.Content>
- <Tabs.Content value="patches" class="mt-4">
- <div class="rounded-xl border border-border/60">
- <SecurityPatchTable bind:targets={patchTargets} bind:requestOptions={patchRequestOptions} />
- </div>
- </Tabs.Content>
- </Tabs.Root>
- </div>
+ <Tabs.Root value={activeTab}>
+ <TabBar items={securityTabItems} value={activeTab} onValueChange={handleTabChange} />
+ <Tabs.Content value="vulnerabilities" class="mt-4">
+ <div class="rounded-xl border border-border/60">
+ <SecurityVulnerabilityTable
+ bind:vulnerabilities
+ bind:requestOptions
+ {showIgnored}
+ onToggleIgnored={toggleIgnored}
+ />
+ </div>
+ </Tabs.Content>
+ <Tabs.Content value="patches" class="mt-4">
+ <div class="rounded-xl border border-border/60">
+ <SecurityPatchTable bind:targets={patchTargets} bind:requestOptions={patchRequestOptions} />
+ </div>
+ </Tabs.Content>
+ </Tabs.Root>
+ </div>
+ {/if}
{/snippet}
</ResourcePageLayout>
diff --git a/frontend/src/routes/(app)/security/+page.ts b/frontend/src/routes/(app)/security/+page.ts
index 43702877d..5ad9fc44c 100644
--- a/frontend/src/routes/(app)/security/+page.ts
+++ b/frontend/src/routes/(app)/security/+page.ts
@@ -1,3 +1,4 @@
+import { featureStore } from '#lib/stores/features.store.svelte.js';
import { tryCatch } from '#lib/utils/try-catch.js';
import { vulnerabilityService } from '#lib/services/vulnerability-service.js';
import { environmentStore } from '#lib/stores/environment.store.svelte.js';
@@ -34,6 +35,18 @@ export const load: PageLoad = async ({ parent }) => {
}
} satisfies SearchPaginationSortRequest);
+ await featureStore.load(envId);
+ if (!featureStore.isEnabled('vulnerabilityManagement', envId)) {
+ return {
+ envId,
+ featureDisabled: true,
+ summary: null,
+ vulnerabilities: { data: [], pagination: { totalPages: 0, totalItems: 0, currentPage: 1, itemsPerPage: 20 } },
+ vulnerabilityRequestOptions,
+ patchRequestOptions
+ };
+ }
+
const requestForApi = mapVulnerabilityRequest(vulnerabilityRequestOptions);
let summary;
@@ -60,6 +73,8 @@ export const load: PageLoad = async ({ parent }) => {
}
return {
+ envId,
+ featureDisabled: false,
summary,
vulnerabilities: mapVulnerabilityPage(vulnerabilities, vulnerabilityRequestOptions),
vulnerabilityRequestOptions,
diff --git a/frontend/src/routes/(app)/security/security-patch-table.svelte b/frontend/src/routes/(app)/security/security-patch-table.svelte
index cba902606..86986f069 100644
--- a/frontend/src/routes/(app)/security/security-patch-table.svelte
+++ b/frontend/src/routes/(app)/security/security-patch-table.svelte
@@ -1,4 +1,5 @@
<script lang="ts">
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import { tryCatch } from '#lib/utils/try-catch.js';
import ArcaneTable from '#lib/components/arcane-table/arcane-table.svelte';
@@ -35,17 +36,21 @@
// this the derived would cache a pre-hydration false forever.
const canPatchImage = $derived.by(() => {
userStore.current;
- return hasPermission('images:patch', currentEnvId);
+ return featureStore.isEnabled('vulnerabilityManagement', currentEnvId) && hasPermission('images:patch', currentEnvId);
});
async function refreshPatchTargets(options: SearchPaginationSortRequest) {
+ if (!featureStore.isEnabled('vulnerabilityManagement', currentEnvId)) return targets;
+ const requestedEnvId = currentEnvId;
const response = await imageService.listPatchTargets(options);
+ if (!featureStore.isEnabled('vulnerabilityManagement', currentEnvId) || requestedEnvId !== currentEnvId) return targets;
const mapped = { ...response, data: (response.data ?? []).map((t) => ({ ...t, id: t.imageId })) };
targets = mapped;
return mapped;
}
async function handlePatchImage(item: PatchTargetRow) {
+ if (!canPatchImage) return;
const operationResult = await tryCatch(
(async () => {
// The fixable counts come from the stored scan, so patch from that report.
diff --git a/frontend/src/routes/(app)/security/security-vulnerability-table.svelte b/frontend/src/routes/(app)/security/security-vulnerability-table.svelte
index ae05bf58c..3a25b7fee 100644
--- a/frontend/src/routes/(app)/security/security-vulnerability-table.svelte
+++ b/frontend/src/routes/(app)/security/security-vulnerability-table.svelte
@@ -1,4 +1,5 @@
<script lang="ts">
+ import { featureStore } from '#lib/stores/features.store.svelte.js';
import { tryCatch } from '#lib/utils/try-catch.js';
import ArcaneTable from '#lib/components/arcane-table/arcane-table.svelte';
@@ -48,7 +49,8 @@
let imageNameFilterOptions = $state<string[]>([]);
const currentEnvId = $derived(environmentStore.selected?.id || '0');
- const canManageVuln = $derived(hasPermission('vulnerabilities:manage', currentEnvId));
+ const vulnerabilityManagementEnabled = $derived(featureStore.isEnabled('vulnerabilityManagement', currentEnvId));
+ const canManageVuln = $derived(vulnerabilityManagementEnabled && hasPermission('vulnerabilities:manage', currentEnvId));
// The table rebuilds requestOptions from its own filter state on every
// refresh, so the switch is injected per request instead of stored there.
@@ -58,11 +60,13 @@
}
async function handleUnignoreVulnerability(item: VulnerabilityRow) {
+ if (!canManageVuln) return;
+ const requestedEnvId = currentEnvId;
const ignoreId = item.ignoreId;
if (!ignoreId) return;
const operationResult = await tryCatch(
(async () => {
- await vulnerabilityService.unignoreVulnerability(ignoreId);
+ await vulnerabilityService.unignoreVulnerability(ignoreId, requestedEnvId);
toast.success(m.vuln_unignore_success());
await refreshVulnerabilityTable(requestOptions);
})()
@@ -80,6 +84,8 @@
}
async function refreshImageNameFilterOptions(options?: SearchPaginationSortRequest): Promise<string[]> {
+ if (!vulnerabilityManagementEnabled) return [];
+ const requestedEnvId = currentEnvId;
const severity = resolveSeverityFilter(options);
const request: SearchPaginationSortRequest = {
filters: severity ? { severity } : undefined
@@ -87,8 +93,8 @@
const operationResult = await tryCatch(
(async () => {
- const optionsResponse = await vulnerabilityService.getAllVulnerabilityImageOptions(request);
- imageNameFilterOptions = optionsResponse;
+ const optionsResponse = await vulnerabilityService.getAllVulnerabilityImageOptionsForEnvironment(requestedEnvId, request);
+ if (vulnerabilityManagementEnabled && requestedEnvId === currentEnvId) imageNameFilterOptions = optionsResponse;
return optionsResponse;
})()
);
@@ -103,12 +109,15 @@
}
async function refreshVulnerabilityTable(options: SearchPaginationSortRequest) {
+ if (!vulnerabilityManagementEnabled) return vulnerabilities;
+ const requestedEnvId = currentEnvId;
const request = mapVulnerabilityRequest(withIgnoredFilter(options));
const [response, optionsResponse] = await Promise.all([
- vulnerabilityService.getAllVulnerabilities(request),
+ vulnerabilityService.getAllVulnerabilitiesForEnvironment(requestedEnvId, request),
refreshImageNameFilterOptions(request)
]);
+ if (!vulnerabilityManagementEnabled || requestedEnvId !== currentEnvId) return vulnerabilities;
const mapped = mapVulnerabilityPage(response, request);
vulnerabilities = mapped;
@@ -120,6 +129,8 @@
}
async function handleIgnoreVulnerability(item: VulnerabilityRow) {
+ if (!canManageVuln) return;
+ const requestedEnvId = currentEnvId;
console.log('Ignoring vulnerability:', {
imageId: item.imageId,
vulnerabilityId: item.vulnerabilityId,
@@ -135,7 +146,7 @@
installedVersion: item.installedVersion || ''
};
console.log('Sending payload:', payload);
- await vulnerabilityService.ignoreVulnerability(payload);
+ await vulnerabilityService.ignoreVulnerability(payload, requestedEnvId);
toast.success(m.vuln_ignore_success({ cve: item.vulnerabilityId }));
// Refresh the table to remove the ignored vulnerability
await refreshVulnerabilityTable(requestOptions);
diff --git a/frontend/src/routes/+layout.svelte b/frontend/src/routes/+layout.svelte
index f7afe9a48..d63899751 100644
--- a/frontend/src/routes/+layout.svelte
+++ b/frontend/src/routes/+layout.svelte
@@ -60,7 +60,7 @@
<QueryClientProvider client={data.queryClient}>
<div class={cn('flex min-h-dvh flex-col', 'bg-transparent')}>
- {#if !settings && data.user}
+ {#if !settings && data.user && page.route.id !== '/(app)/environments/[id]'}
<Error message={m.error_occurred()} showButton={true} />
{:else}
<Tooltip.Provider>
diff --git a/frontend/src/routes/+layout.ts b/frontend/src/routes/+layout.ts
index 2807ad0d9..819969851 100644
--- a/frontend/src/routes/+layout.ts
+++ b/frontend/src/routes/+layout.ts
@@ -6,6 +6,7 @@ import { swarmService } from '#lib/services/swarm-service.js';
import { userService } from '#lib/services/user-service.js';
import versionService from '#lib/services/version-service.js';
import settingsStore from '#lib/stores/config-store.svelte.js';
+import { featureStore } from '#lib/stores/features.store.svelte.js';
import { environmentStore } from '#lib/stores/environment.store.svelte.js';
import userStore from '#lib/stores/user-store.svelte.js';
import { type AppVersionInformation } from '#lib/types/settings.js';
@@ -71,6 +72,11 @@ export const load: LayoutLoad = async ({ url }) => {
authService.resetAuthenticatedState(queryClient, { restartMountedStores: user !== null });
}
authenticatedUserId = nextAuthenticatedUserId;
+ if (user) {
+ await userStore.setUser(user);
+ } else {
+ userStore.clearUser();
+ }
let settings = null;
let swarmEnabled = false;
@@ -99,16 +105,24 @@ export const load: LayoutLoad = async ({ url }) => {
const settingsRequest = userHasPermission(user, 'settings:read')
? tryCatch(settingsService.getSettings()).then(async (result) => {
if (!result.error) return result.data;
- const publicSettings = await tryCatch(settingsService.getPublicSettings());
+ const publicSettings = await tryCatch(settingsService.getPublicSettings(environmentStore.selected?.id ?? '0'));
return publicSettings.error ? null : publicSettings.data;
})
- : tryCatch(settingsService.getPublicSettings()).then((result) => (result.error ? null : result.data));
+ : tryCatch(settingsService.getPublicSettings(environmentStore.selected?.id ?? '0')).then((result) =>
+ result.error ? null : result.data
+ );
+ featureStore.connect(queryClient);
+ const featuresRequest = featureStore.refresh(await environmentStore.getCurrentEnvironmentId());
const [loadedSettings, loadedSwarmStatus, loadedPermissionsManifest] = await Promise.all([
settingsRequest,
tryCatch(swarmService.getSwarmStatus()).then((result) => (result.error ? null : result.data)),
permissionsManifestRequest
]);
- settings = loadedSettings;
+ // Keep recovery/settings pages reachable while a selected agent is offline.
+ settings =
+ loadedSettings ??
+ (await tryCatch(settingsService.getPublicSettings()).then((result) => (result.error ? null : result.data)));
+ await featuresRequest;
swarmEnabled = loadedSwarmStatus?.enabled === true;
permissionsManifest = loadedPermissionsManifest;
permissionsManifestLoadFailed = loadedPermissionsManifest === null;
@@ -120,12 +134,6 @@ export const load: LayoutLoad = async ({ url }) => {
settings = await tryCatch(settingsService.getPublicSettings()).then((result) => (result.error ? null : result.data));
}
- if (user) {
- await userStore.setUser(user);
- } else {
- userStore.clearUser();
- }
-
if (settings) {
settingsStore.set(settings);
}
diff --git a/tests/spec/edge-agent.spec.ts b/tests/spec/edge-agent.spec.ts
index 0ae69967f..06c82d04a 100644
--- a/tests/spec/edge-agent.spec.ts
+++ b/tests/spec/edge-agent.spec.ts
@@ -71,6 +71,17 @@ test.describe('Edge Agent Environment', () => {
test('should create an edge agent environment and show deployment snippets', async ({ page }) => {
const environmentName = `edge-agent-${Date.now().toString().slice(-6)}`;
let createdEnvironmentId: string | null = null;
+ const agentSettingsRequests: string[] = [];
+ page.on('request', (request) => {
+ if (!createdEnvironmentId) return;
+ const pathname = new URL(request.url()).pathname;
+ if (
+ pathname === `/api/environments/${createdEnvironmentId}/settings` ||
+ pathname === `/api/environments/${createdEnvironmentId}/settings/public`
+ ) {
+ agentSettingsRequests.push(pathname);
+ }
+ });
await page.route('**/api/environments', async (route) => {
if (route.request().method() === 'POST') {
@@ -138,6 +149,10 @@ test.describe('Edge Agent Environment', () => {
await expect(page.getByTitle('API URL', { exact: true })).toHaveText(/edge:\/\/edge-agent-/);
await expect(page.getByText('Edge', { exact: true }).first()).toBeVisible();
await expect(page.getByText('Live Tunnel', { exact: true })).toBeVisible();
+ await expect(
+ page.getByRole('tab', { name: 'Connection & Edge', exact: true })
+ ).toHaveAttribute('data-state', 'active');
+ expect(agentSettingsRequests).toEqual([]);
} finally {
if (createdEnvironmentId) {
await page.request.delete(`/api/environments/${createdEnvironmentId}`);
diff --git a/tests/spec/environment-settings.spec.ts b/tests/spec/environment-settings.spec.ts
index 42ed726fd..eb86d89df 100644
--- a/tests/spec/environment-settings.spec.ts
+++ b/tests/spec/environment-settings.spec.ts
@@ -129,14 +129,18 @@ test.describe('Environment Settings UI', () => {
await expect(dockerTab).toHaveAttribute('data-state', 'active');
await page.goto(`/environments/${LOCAL_ENV_ID}?source=e2e&tab=invalid#tab-state`);
- await expect.poll(() => new URL(page.url()).searchParams.get('tab')).toBe('storage');
+ await expect.poll(() => new URL(page.url()).searchParams.get('tab')).toBe('features');
const canonicalUrl = new URL(page.url());
expect(canonicalUrl.searchParams.get('source')).toBe('e2e');
expect(canonicalUrl.hash).toBe('#tab-state');
- await expect(page.getByRole('tab', { name: 'Storage & Limits', exact: true })).toHaveAttribute(
+ await expect(page.getByRole('tab', { name: 'Features', exact: true })).toHaveAttribute(
'data-state',
'active'
);
+ await expect(page.getByRole('heading', { name: 'Features', exact: true })).toBeVisible();
+ await expect(
+ page.getByRole('switch', { name: 'Vulnerability management', exact: true })
+ ).toBeVisible();
});
test('should update and save environment details', async ({ page }) => {
diff --git a/tests/spec/security.spec.ts b/tests/spec/security.spec.ts
index 572b3c420..c67657f37 100644
--- a/tests/spec/security.spec.ts
+++ b/tests/spec/security.spec.ts
@@ -297,3 +297,72 @@ test.describe('Security Page', () => {
await expect(remoteRow.getByText('Running', { exact: true })).toBeVisible();
});
});
+
+test.describe('Disabled vulnerability management', () => {
+ test.beforeEach(async ({ page }) => {
+ await page.route(/\/api\/environments\/[^/]+\/settings\/public$/, async (route) => {
+ await route.fulfill({
+ json: [{ key: 'featureVulnerabilityManagementEnabled', value: 'false' }]
+ });
+ });
+ });
+
+ for (const path of [ROUTES.page, ROUTES.legacyVulnerabilities]) {
+ test(`blocks vulnerability data requests from ${path}`, async ({ page }) => {
+ const vulnerabilityRequests: string[] = [];
+ page.on('request', (request) => {
+ if (
+ /\/api\/environments\/[^/]+\/(?:images\/[^/]+\/)?vulnerabilities(?:\/|$)/.test(
+ new URL(request.url()).pathname
+ )
+ ) {
+ vulnerabilityRequests.push(request.url());
+ }
+ });
+
+ await page.goto(path);
+ await expect(
+ page.getByText(
+ 'Vulnerability management is disabled for this environment. Saved reports and settings are retained.',
+ { exact: true }
+ )
+ ).toBeVisible();
+ await expect(page.getByRole('tab', { name: 'Vulnerabilities', exact: true })).toHaveCount(0);
+ await expect(page.getByRole('button', { name: 'Scan all images', exact: true })).toHaveCount(
+ 0
+ );
+ await expect(page.getByRole('button', { name: 'Features', exact: true })).toBeVisible();
+ expect(vulnerabilityRequests).toEqual([]);
+ });
+ }
+
+ test('hides image vulnerability controls and keeps standalone patching', async ({ page }) => {
+ await page.route(/\/api\/environments\/0\/images(?:\?.*)?$/, async (route) => {
+ await route.fulfill({
+ json: paginated([
+ {
+ id: 'disabled-feature-image',
+ repo: 'example/feature-test',
+ tag: 'latest',
+ repoTags: ['example/feature-test:latest'],
+ repoDigests: ['example/feature-test@sha256:1234'],
+ size: 1024,
+ created: 1700000000,
+ inUse: false,
+ vulnerabilityScan: { status: 'completed', summary: { total: 9, critical: 9 } }
+ }
+ ])
+ });
+ });
+
+ await page.goto('/images');
+ const row = page.getByRole('row').filter({ hasText: 'example/feature-test' });
+ await expect(row).toBeVisible();
+ await expect(
+ page.getByRole('columnheader', { name: 'Vulnerabilities', exact: true })
+ ).toHaveCount(0);
+ const menu = await openRowActionsMenu(page, row);
+ await expect(menu.getByRole('menuitem', { name: 'Scan', exact: true })).toHaveCount(0);
+ await expect(menu.getByRole('menuitem', { name: 'Patch', exact: true })).toBeVisible();
+ });
+});
diff --git a/types/features/error.go b/types/features/error.go
new file mode 100644
index 000000000..6c5395277
--- /dev/null
+++ b/types/features/error.go
@@ -0,0 +1,28 @@
+package features
+
+// DisabledError describes an unavailable runtime feature using problem details.
+type DisabledError struct {
+ Status int `json:"status"`
+ Title string `json:"title"`
+ Detail string `json:"detail"`
+ Code string `json:"code"`
+ Feature ID `json:"feature"`
+}
+
+// Error returns the reason the feature operation was rejected.
+func (e *DisabledError) Error() string { return e.Detail }
+
+// GetStatus supplies the HTTP response status to Huma.
+func (e *DisabledError) GetStatus() int { return e.Status }
+
+// ContentType selects the problem-details media type for JSON and CBOR responses.
+func (e *DisabledError) ContentType(contentType string) string {
+ switch contentType {
+ case "application/json":
+ return "application/problem+json"
+ case "application/cbor":
+ return "application/problem+cbor"
+ default:
+ return contentType
+ }
+}
diff --git a/types/features/features.go b/types/features/features.go
new file mode 100644
index 000000000..f59cd9359
--- /dev/null
+++ b/types/features/features.go
@@ -0,0 +1,37 @@
+// Package features defines runtime features and their settings contracts.
+package features
+
+// ID identifies a feature independently of permissions and build options.
+type ID string
+
+// VulnerabilityManagement identifies scanning, reports, and scan-based patching.
+const VulnerabilityManagement ID = "vulnerabilityManagement"
+
+// VulnerabilityManagementSettingKey is the persisted toggle for vulnerability management.
+const VulnerabilityManagementSettingKey = "featureVulnerabilityManagementEnabled"
+
+// Definition connects a runtime feature to its persisted setting and default.
+type Definition struct {
+ ID ID
+ SettingKey string
+ DefaultEnabled bool
+}
+
+var registryInternal = [...]Definition{
+ {ID: VulnerabilityManagement, SettingKey: VulnerabilityManagementSettingKey, DefaultEnabled: true},
+}
+
+// All returns the supported runtime features.
+func All() []Definition {
+ return append([]Definition{}, registryInternal[:]...)
+}
+
+// Lookup returns the definition of a supported runtime feature.
+func Lookup(id ID) (Definition, bool) {
+ for _, definition := range registryInternal {
+ if definition.ID == id {
+ return definition, true
+ }
+ }
+ return Definition{}, false
+}
diff --git a/types/features/features_test.go b/types/features/features_test.go
new file mode 100644
index 000000000..a3ec690cf
--- /dev/null
+++ b/types/features/features_test.go
@@ -0,0 +1,36 @@
+package features_test
+
+import (
+ "testing"
+
+ "github.com/getarcaneapp/arcane/types/v2/features"
+)
+
+func TestRegistry(t *testing.T) {
+ tests := []struct {
+ name string
+ id features.ID
+ mutateCopy bool
+ wantFound bool
+ want features.Definition
+ }{
+ {name: "known feature", id: features.VulnerabilityManagement, wantFound: true, want: features.Definition{ID: features.VulnerabilityManagement, SettingKey: "featureVulnerabilityManagementEnabled", DefaultEnabled: true}},
+ {name: "returned definitions are independent", id: features.VulnerabilityManagement, mutateCopy: true, wantFound: true, want: features.Definition{ID: features.VulnerabilityManagement, SettingKey: "featureVulnerabilityManagementEnabled", DefaultEnabled: true}},
+ {name: "unknown feature", id: features.ID("unknown")},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if tt.mutateCopy {
+ all := features.All()
+ if len(all) == 0 {
+ t.Fatal("registry is empty")
+ }
+ all[0].DefaultEnabled = false
+ }
+ definition, found := features.Lookup(tt.id)
+ if found != tt.wantFound || definition != tt.want {
+ t.Fatalf("Lookup(%q) = %+v, %t; want %+v, %t", tt.id, definition, found, tt.want, tt.wantFound)
+ }
+ })
+ }
+}
diff --git a/types/settings/settings.go b/types/settings/settings.go
index 48a203fe5..b1a42e08b 100644
--- a/types/settings/settings.go
+++ b/types/settings/settings.go
@@ -186,6 +186,9 @@ type Update struct {
// Required: false
PruneBuildCacheUntil *string `json:"pruneBuildCacheUntil,omitzero"`
+ // FeatureVulnerabilityManagementEnabled controls vulnerability management for this environment.
+ FeatureVulnerabilityManagementEnabled *string `json:"featureVulnerabilityManagementEnabled,omitzero" enum:"true,false"`
+
// VulnerabilityScanEnabled indicates if scheduled vulnerability scanning is enabled.
//
// Required: false