Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: use docker daemon backed trust store for registry operations (#2042)
Kyle Mendell8b7e6f81a1a4
diff --git a/backend/go.mod b/backend/go.modindex c649c2e36..bd9dee1f9 100644--- a/backend/go.mod+++ b/backend/go.mod@@ -13,7 +13,6 @@ require (github.com/depot/depot-go v0.5.2github.com/docker/cli v29.2.1+incompatiblegithub.com/docker/compose/v5 v5.1.0- github.com/docker/distribution v2.8.3+incompatiblegithub.com/docker/docker v28.5.2+incompatiblegithub.com/fsnotify/fsnotify v1.9.0github.com/getarcaneapp/arcane/types v1.15.3@@ -37,6 +36,7 @@ require (github.com/moby/moby/client v0.3.0github.com/moby/patternmatcher v0.6.0github.com/nicholas-fedor/shoutrrr v0.13.2+ github.com/opencontainers/go-digest v1.0.0github.com/opencontainers/image-spec v1.1.1github.com/orandin/slog-gorm v1.4.0github.com/robfig/cron/v3 v3.0.1@@ -161,7 +161,6 @@ require (github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirectgithub.com/morikuni/aec v1.1.0 // indirectgithub.com/ncruces/go-strftime v0.1.9 // indirect- github.com/opencontainers/go-digest v1.0.0 // indirectgithub.com/pelletier/go-toml v1.9.5 // indirectgithub.com/pelletier/go-toml/v2 v2.2.4 // indirectgithub.com/pjbgf/sha1cd v0.3.2 // indirectdiff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.goindex a426ce004..a6ed5ae26 100644--- a/backend/internal/bootstrap/services_bootstrap.go+++ b/backend/internal/bootstrap/services_bootstrap.go@@ -65,7 +65,9 @@ func initializeServices(ctx context.Context, db *database.DB, cfg *config.ConfigdockerClient := services.NewDockerClientService(db, cfg, svcs.Settings)svcs.Docker = dockerClientsvcs.User = services.NewUserService(db)- svcs.ContainerRegistry = services.NewContainerRegistryService(db)+ svcs.ContainerRegistry = services.NewContainerRegistryService(db, func(ctx context.Context) (services.RegistryDaemonClient, error) {+ return dockerClient.GetClient(ctx)+ })svcs.Notification = services.NewNotificationService(db, cfg)svcs.Apprise = services.NewAppriseService(db, cfg)svcs.Vulnerability = services.NewVulnerabilityService(db, svcs.Docker, svcs.Event, svcs.Settings, svcs.Notification)diff --git a/backend/internal/huma/handlers/container_registries.go b/backend/internal/huma/handlers/container_registries.goindex f9cd56c6c..2f21276f8 100644--- a/backend/internal/huma/handlers/container_registries.go+++ b/backend/internal/huma/handlers/container_registries.go@@ -2,8 +2,8 @@ package handlersimport ("context"- "fmt""log/slog"+ "strings""github.com/danielgtaylor/huma/v2""github.com/getarcaneapp/arcane/backend/internal/common"@@ -11,7 +11,6 @@ import ("github.com/getarcaneapp/arcane/backend/internal/services""github.com/getarcaneapp/arcane/backend/internal/utils/crypto""github.com/getarcaneapp/arcane/backend/internal/utils/mapper"- "github.com/getarcaneapp/arcane/backend/internal/utils/registry""github.com/getarcaneapp/arcane/types/base""github.com/getarcaneapp/arcane/types/containerregistry")@@ -364,16 +363,20 @@ func (h *ContainerRegistryHandler) TestRegistry(ctx context.Context, input *Testreturn nil, huma.Error500InternalServerError((&common.TokenDecryptionError{Err: err}).Error())}- testResult, testErr := h.performRegistryTest(ctx, reg, decryptedToken)- if testErr != nil {- return nil, huma.Error400BadRequest((&common.RegistryTestError{Err: testErr}).Error())+ if err := h.registryService.TestRegistry(ctx, reg.URL, reg.Username, decryptedToken); err != nil {+ return nil, huma.Error400BadRequest((&common.RegistryTestError{Err: err}).Error())+ }++ msg := "Authentication succeeded"+ if strings.TrimSpace(reg.Username) == "" && strings.TrimSpace(decryptedToken) == "" {+ msg = "Registry saved (no credentials to test)"}return &TestContainerRegistryOutput{Body: base.ApiResponse[base.MessageResponse]{Success: true,Data: base.MessageResponse{- Message: testResult["message"].(string),+ Message: msg,},},}, nil@@ -408,32 +411,6 @@ func (h *ContainerRegistryHandler) SyncRegistries(ctx context.Context, input *Sy// Helper Methods// ============================================================================-func (h *ContainerRegistryHandler) performRegistryTest(ctx context.Context, registryModel *models.ContainerRegistry, decryptedToken string) (map[string]any, error) {- var creds *registry.Credentials- if registryModel.Username != "" && decryptedToken != "" {- creds = ®istry.Credentials{- Username: registryModel.Username,- Token: decryptedToken,- }- }-- testResult, err := registry.TestRegistryConnection(ctx, registryModel.URL, creds)- if err != nil {- return nil, err- }-- if !testResult.AuthSuccess {- if len(testResult.Errors) > 0 {- return nil, fmt.Errorf("%s", testResult.Errors[0])- }- return nil, fmt.Errorf("invalid credentials")- }-- return map[string]any{- "message": "Authentication succeeded",- }, nil-}-func (h *ContainerRegistryHandler) triggerRemoteRegistrySync(ctx context.Context, reason string) { //nolint:contextcheck // intentionally spawns background syncif h.environmentService == nil {returndiff --git a/backend/internal/services/build_service_test.go b/backend/internal/services/build_service_test.goindex 8a5057e96..b870fe7d9 100644--- a/backend/internal/services/build_service_test.go+++ b/backend/internal/services/build_service_test.go@@ -22,7 +22,7 @@ func TestBuildService_GetRegistryAuthForHost_UsesDatabaseCredentials(t *testing._, db := setupImageServiceAuthTest(t)createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")- svc := &BuildService{registryService: NewContainerRegistryService(db)}+ svc := &BuildService{registryService: NewContainerRegistryService(db, nil)}auth, err := svc.GetRegistryAuthForHost(context.Background(), "registry-1.docker.io")require.NoError(t, err)@@ -38,7 +38,7 @@ func TestBuildService_GetRegistryAuthForImage_UsesHostLookup(t *testing.T) {_, db := setupImageServiceAuthTest(t)createTestPullRegistry(t, db, "https://ghcr.io", "gh-user", "gh-token")- svc := &BuildService{registryService: NewContainerRegistryService(db)}+ svc := &BuildService{registryService: NewContainerRegistryService(db, nil)}auth, err := svc.GetRegistryAuthForImage(context.Background(), "ghcr.io/getarcaneapp/arcane:latest")require.NoError(t, err)@@ -54,7 +54,7 @@ func TestBuildService_GetAllRegistryAuthConfigs_UsesDatabaseCredentials(t *testi_, db := setupImageServiceAuthTest(t)createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")- svc := &BuildService{registryService: NewContainerRegistryService(db)}+ svc := &BuildService{registryService: NewContainerRegistryService(db, nil)}authConfigs, err := svc.GetAllRegistryAuthConfigs(context.Background())require.NoError(t, err)diff --git a/backend/internal/services/container_registry_service.go b/backend/internal/services/container_registry_service.goindex 399757c2e..78ec013c4 100644--- a/backend/internal/services/container_registry_service.go+++ b/backend/internal/services/container_registry_service.go@@ -2,15 +2,14 @@ package servicesimport ("context"- "encoding/json""errors""fmt""log/slog"- "net/http""strings""sync""time"+ cerrdefs "github.com/containerd/errdefs""github.com/getarcaneapp/arcane/backend/internal/database""github.com/getarcaneapp/arcane/backend/internal/models""github.com/getarcaneapp/arcane/backend/internal/utils"@@ -21,41 +20,47 @@ import (utilsregistry "github.com/getarcaneapp/arcane/backend/internal/utils/registry""github.com/getarcaneapp/arcane/types/containerregistry"dockerregistry "github.com/moby/moby/api/types/registry"+ "github.com/moby/moby/client"ref "go.podman.io/image/v5/docker/reference")const (- registryCheckTimeout = 10 * time.Second- registryCacheTTL = 30 * time.Minute+ registryCacheTTL = 30 * time.Minute)-func getHeaderCaseInsensitive(h http.Header, key string) string {- for k, v := range h {- if strings.EqualFold(k, key) && len(v) > 0 {- return v[0]- }- }- return ""+type RegistryDaemonClient interface {+ RegistryLogin(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error)+ DistributionInspect(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error)}-type ContainerRegistryService struct {- db *database.DB- httpClient *http.Client- cache map[string]*cache.Cache[string] // imageRef -> digest cache- cacheMu sync.RWMutex+type registryDaemonGetter func(context.Context) (RegistryDaemonClient, error)++type registryDigestResult struct {+ Digest string+ AuthMethod string+ AuthUsername string+ AuthRegistry string+ UsedCredential bool}-func NewContainerRegistryService(db *database.DB) *ContainerRegistryService {- transport := http.DefaultTransport.(*http.Transport).Clone()- transport.Proxy = http.ProxyFromEnvironment+type resolvedRegistryCredential struct {+ Username string+ Token string+ ServerAddress string+}++type ContainerRegistryService struct {+ db *database.DB+ dockerClient registryDaemonGetter+ cache map[string]*cache.Cache[string] // imageRef -> digest cache+ cacheMu sync.RWMutex+}+func NewContainerRegistryService(db *database.DB, dockerClient registryDaemonGetter) *ContainerRegistryService {return &ContainerRegistryService{- db: db,- httpClient: &http.Client{- Timeout: registryCheckTimeout,- Transport: transport,- },- cache: make(map[string]*cache.Cache[string]),+ db: db,+ dockerClient: dockerClient,+ cache: make(map[string]*cache.Cache[string]),}}@@ -275,16 +280,39 @@ func (s *ContainerRegistryService) GetAllRegistryAuthConfigs(ctx context.Contextreturn authConfigs, nil}+func (s *ContainerRegistryService) TestRegistry(ctx context.Context, registryURL, username, token string) error {+ if strings.TrimSpace(username) == "" && strings.TrimSpace(token) == "" {+ // No credentials configured — skip the credential test.+ return nil+ }++ dockerClient, err := s.getDockerClientInternal(ctx)+ if err != nil {+ return err+ }++ _, err = dockerClient.RegistryLogin(ctx, client.RegistryLoginOptions{+ Username: strings.TrimSpace(username),+ Password: strings.TrimSpace(token),+ ServerAddress: normalizeRegistryServerAddressInternal(registryURL),+ })+ if err != nil {+ return fmt.Errorf("registry login failed: %w", err)+ }++ return nil+}+// GetImageDigest fetches the current digest for an image:tag from the registry// This is used for digest-based update detection for non-semver tagsfunc (s *ContainerRegistryService) GetImageDigest(ctx context.Context, imageRef string) (string, error) {- repository, tag := parseImageReference(imageRef)- if repository == "" || tag == "" {- return "", fmt.Errorf("invalid image reference: %s", imageRef)+ normalizedRef, _, err := normalizeImageReferenceForDistributionInternal(imageRef)+ if err != nil {+ return "", err}// Build a cache key from the full image reference- cacheKey := fmt.Sprintf("%s:%s", repository, tag)+ cacheKey := normalizedRef// Get or create a cache for this specific image references.cacheMu.RLock()@@ -301,7 +329,12 @@ func (s *ContainerRegistryService) GetImageDigest(ctx context.Context, imageRef}digest, err := imageCache.GetOrFetch(ctx, func(ctx context.Context) (string, error) {- return s.fetchDigestFromRegistry(ctx, repository, tag)+ // Pass the original imageRef; inspectImageDigestInternal normalizes internally.+ result, fetchErr := s.inspectImageDigestInternal(ctx, imageRef, nil)+ if fetchErr != nil {+ return "", fetchErr+ }+ return result.Digest, nil})var staleErr *cache.ErrStale@@ -312,157 +345,154 @@ func (s *ContainerRegistryService) GetImageDigest(ctx context.Context, imageRefreturn digest, nil}-// fetchDigestFromRegistry queries the Docker registry API for the image digest-func (s *ContainerRegistryService) fetchDigestFromRegistry(ctx context.Context, repository, tag string) (string, error) {- registryURL, repoPath := parseRegistryAndRepo(repository)- manifestURL := fmt.Sprintf("%s/v2/%s/manifests/%s", registryURL, repoPath, tag)-- reqCtx, cancel := context.WithTimeout(ctx, registryCheckTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(reqCtx, http.MethodHead, manifestURL, nil)+func (s *ContainerRegistryService) inspectImageDigestInternal(ctx context.Context, imageRef string, externalCreds []containerregistry.Credential) (*registryDigestResult, error) {+ normalizedRef, registryHost, err := normalizeImageReferenceForDistributionInternal(imageRef)if err != nil {- return "", fmt.Errorf("create registry request: %w", err)- }-- req.Header.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.list.v2+json")-- // Try to find stored credentials for this registry- creds := s.findCredentialsForRegistry(ctx, registryURL)- if creds != nil {- req.SetBasicAuth(creds.Username, creds.Token)+ return nil, err}- resp, err := s.httpClient.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint+ dockerClient, err := s.getDockerClientInternal(ctx)if err != nil {- return "", fmt.Errorf("registry request failed: %w", err)- }- defer func() { _ = resp.Body.Close() }()-- if resp.StatusCode == http.StatusUnauthorized {- return s.fetchWithTokenAuth(ctx, repository, tag, getHeaderCaseInsensitive(resp.Header, "WWW-Authenticate"), creds)+ return nil, err}- if resp.StatusCode != http.StatusOK {- return "", fmt.Errorf("registry returned status %d", resp.StatusCode)+ inspectResult, err := dockerClient.DistributionInspect(ctx, normalizedRef, client.DistributionInspectOptions{})+ if err == nil {+ digest := strings.TrimSpace(string(inspectResult.Descriptor.Digest))+ if digest == "" {+ return nil, fmt.Errorf("distribution inspect returned empty digest for %s", normalizedRef)+ }+ return ®istryDigestResult{+ Digest: digest,+ AuthMethod: "anonymous",+ AuthRegistry: registryHost,+ }, nil}-- digest := resp.Header.Get("Docker-Content-Digest")- if digest == "" {- digest = strings.Trim(resp.Header.Get("Etag"), "\"")+ if !isUnauthorizedRegistryErrorInternal(err) {+ return ®istryDigestResult{AuthMethod: "anonymous", AuthRegistry: registryHost},+ fmt.Errorf("distribution inspect failed for %s: %w", normalizedRef, err)}- if digest == "" {- return "", fmt.Errorf("no digest found in registry response")+ credentials, credErr := s.getMatchingRegistryCredentialsInternal(ctx, registryHost, externalCreds)+ if credErr != nil {+ return ®istryDigestResult{AuthMethod: "anonymous", AuthRegistry: registryHost}, credErr}- return digest, nil-}--// findCredentialsForRegistry finds stored credentials for a registry URL-func (s *ContainerRegistryService) findCredentialsForRegistry(ctx context.Context, registryURL string) *struct{ Username, Token string } {- registries, err := s.GetEnabledRegistries(ctx)- if err != nil {- return nil- }+ lastErr := err+ var lastCred resolvedRegistryCredential+ for _, credential := range credentials {+ lastCred = credential+ authHeader, encodeErr := utilsregistry.EncodeAuthHeader(credential.Username, credential.Token, credential.ServerAddress)+ if encodeErr != nil {+ return nil, fmt.Errorf("encode registry auth header for %s: %w", registryHost, encodeErr)+ }- for _, reg := range registries {- if utilsregistry.IsRegistryMatch(reg.URL, registryURL) {- token, err := crypto.Decrypt(reg.Token)- if err != nil {- slog.WarnContext(ctx, "Failed to decrypt registry token", "registry", reg.URL, "error", err)- continue+ inspectResult, err = dockerClient.DistributionInspect(ctx, normalizedRef, client.DistributionInspectOptions{+ EncodedRegistryAuth: authHeader,+ })+ if err == nil {+ digest := strings.TrimSpace(string(inspectResult.Descriptor.Digest))+ if digest == "" {+ return nil, fmt.Errorf("distribution inspect returned empty digest for %s", normalizedRef)}- return &struct{ Username, Token string }{Username: reg.Username, Token: token}+ return ®istryDigestResult{+ Digest: digest,+ AuthMethod: "credential",+ AuthUsername: credential.Username,+ AuthRegistry: registryHost,+ UsedCredential: true,+ }, nil+ }+ lastErr = err+ if !isUnauthorizedRegistryErrorInternal(err) {+ return ®istryDigestResult{+ AuthMethod: "credential",+ AuthUsername: credential.Username,+ AuthRegistry: registryHost,+ UsedCredential: true,+ }, fmt.Errorf("distribution inspect failed for %s with credentials: %w", normalizedRef, err)}}- return nil+ partial := ®istryDigestResult{AuthMethod: "anonymous", AuthRegistry: registryHost}+ if lastCred.Username != "" {+ partial.AuthMethod = "credential"+ partial.AuthUsername = lastCred.Username+ partial.UsedCredential = true+ }+ return partial, fmt.Errorf("distribution inspect failed for %s: %w", normalizedRef, lastErr)}-// fetchWithTokenAuth handles token-based authentication for registries-func (s *ContainerRegistryService) fetchWithTokenAuth(ctx context.Context, repository, tag, wwwAuth string, creds *struct{ Username, Token string }) (string, error) {- realm, service := parseWWWAuth(wwwAuth)- if realm == "" {- return "", fmt.Errorf("no auth realm found")+func (s *ContainerRegistryService) getDockerClientInternal(ctx context.Context) (RegistryDaemonClient, error) {+ if s.dockerClient == nil {+ return nil, errors.New("docker client unavailable")}- registryURL, repoPath := parseRegistryAndRepo(repository)-- tokenURL := fmt.Sprintf("%s?service=%s&scope=repository:%s:pull", realm, service, repoPath)-- reqCtx, cancel := context.WithTimeout(ctx, registryCheckTimeout)- defer cancel()-- tokenReq, err := http.NewRequestWithContext(reqCtx, http.MethodGet, tokenURL, nil)+ dockerClient, err := s.dockerClient(ctx)if err != nil {- return "", fmt.Errorf("create token request: %w", err)+ return nil, fmt.Errorf("failed to get docker client: %w", err)}-- if creds != nil {- tokenReq.SetBasicAuth(creds.Username, creds.Token)+ if dockerClient == nil {+ return nil, errors.New("docker client unavailable")}- tokenResp, err := s.httpClient.Do(tokenReq) //nolint:gosec // intentional request to auth realm provided by registry challenge- if err != nil {- return "", fmt.Errorf("token request failed: %w", err)- }- defer func() { _ = tokenResp.Body.Close() }()-- if tokenResp.StatusCode != http.StatusOK {- return "", fmt.Errorf("token request returned status %d", tokenResp.StatusCode)- }+ return dockerClient, nil+}- var tokenData struct {- Token string `json:"token"`- Legacy string `json:"access_token"` //nolint:gosec // JSON compatibility with registry token response schema- }- if err := json.NewDecoder(tokenResp.Body).Decode(&tokenData); err != nil {- return "", fmt.Errorf("decode token response: %w", err)- }+func (s *ContainerRegistryService) getMatchingRegistryCredentialsInternal(ctx context.Context, registryHost string, externalCreds []containerregistry.Credential) ([]resolvedRegistryCredential, error) {+ if len(externalCreds) > 0 {+ credentials := make([]resolvedRegistryCredential, 0, len(externalCreds))+ for _, cred := range externalCreds {+ if !cred.Enabled || strings.TrimSpace(cred.Username) == "" || strings.TrimSpace(cred.Token) == "" {+ continue+ }+ if !utilsregistry.IsRegistryMatch(cred.URL, registryHost) {+ continue+ }- token := tokenData.Token- if token == "" {- token = tokenData.Legacy- }- if token == "" {- return "", fmt.Errorf("no token in response")+ credentials = append(credentials, resolvedRegistryCredential{+ Username: strings.TrimSpace(cred.Username),+ Token: strings.TrimSpace(cred.Token),+ ServerAddress: normalizeRegistryServerAddressInternal(cred.URL),+ })+ }+ return credentials, nil}- // Retry with token- manifestURL := fmt.Sprintf("%s/v2/%s/manifests/%s", registryURL, repoPath, tag)-- reqCtx2, cancel2 := context.WithTimeout(ctx, registryCheckTimeout)- defer cancel2()-- req, err := http.NewRequestWithContext(reqCtx2, http.MethodHead, manifestURL, nil)+ registries, err := s.GetEnabledRegistries(ctx)if err != nil {- return "", fmt.Errorf("create authenticated request: %w", err)+ return nil, fmt.Errorf("failed to load enabled registries: %w", err)}- req.Header.Set("Authorization", "Bearer "+token)- req.Header.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.list.v2+json")-- resp, err := s.httpClient.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint- if err != nil {- return "", fmt.Errorf("authenticated request failed: %w", err)- }- defer func() { _ = resp.Body.Close() }()+ credentials := make([]resolvedRegistryCredential, 0, len(registries))+ for _, reg := range registries {+ if !utilsregistry.IsRegistryMatch(reg.URL, registryHost) {+ continue+ }- if resp.StatusCode != http.StatusOK {- return "", fmt.Errorf("authenticated request returned status %d", resp.StatusCode)- }+ username := strings.TrimSpace(reg.Username)+ if username == "" || reg.Token == "" {+ continue+ }- digest := resp.Header.Get("Docker-Content-Digest")- if digest == "" {- digest = strings.Trim(resp.Header.Get("Etag"), "\"")- }+ token, decryptErr := crypto.Decrypt(reg.Token)+ if decryptErr != nil {+ slog.WarnContext(ctx, "failed to decrypt registry token", "registry", reg.URL, "error", decryptErr)+ continue+ }+ token = strings.TrimSpace(token)+ if token == "" {+ continue+ }- if digest == "" {- return "", fmt.Errorf("no digest found in authenticated response")+ credentials = append(credentials, resolvedRegistryCredential{+ Username: username,+ Token: token,+ ServerAddress: normalizeRegistryServerAddressInternal(reg.URL),+ })}- return digest, nil+ return credentials, nil}// SyncRegistries syncs registries from a manager to this agent instance@@ -578,45 +608,67 @@ func (s *ContainerRegistryService) deleteUnsyncedInternal(ctx context.Context, ereturn nil}-// parseImageReference splits an image reference into repository and tag using distribution/reference-func parseImageReference(imageRef string) (repository, tag string) {- named, err := ref.ParseNormalizedNamed(imageRef)+func normalizeImageReferenceForDistributionInternal(imageRef string) (string, string, error) {+ named, err := ref.ParseNormalizedNamed(strings.TrimSpace(imageRef))if err != nil {- return imageRef, "latest"+ return "", "", fmt.Errorf("invalid image reference %q: %w", imageRef, err)}- tagged, ok := named.(ref.Tagged)- if ok {+ if _, ok := named.(ref.Digested); ok {+ return "", "", fmt.Errorf("digest-pinned references are not supported for distribution inspect: %q", imageRef)+ }++ registryHost := utilsregistry.NormalizeRegistryForComparison(ref.Domain(named))+ repository := ref.Path(named)++ tag := "latest"+ if tagged, ok := named.(ref.NamedTagged); ok {tag = tagged.Tag()- } else {- tag = "latest"}- return named.Name(), tag+ return registryHost + "/" + repository + ":" + tag, registryHost, nil}-// parseRegistryAndRepo splits a repository into registry URL and repo path using distribution/reference-func parseRegistryAndRepo(repository string) (registryURL, repoPath string) {- named, err := ref.ParseNormalizedNamed(repository)- if err != nil {- return "https://" + utilsregistry.DefaultRegistry, "library/" + repository+func normalizeRegistryServerAddressInternal(registryURL string) string {+ normalizedHost := strings.TrimSpace(utilsregistry.NormalizeRegistryForComparison(registryURL))+ if normalizedHost == "" {+ return ""}- domain := ref.Domain(named)- repoPath = ref.Path(named)-- registryURL, err = utilsregistry.GetRegistryAddress(named.Name())- if err != nil {- registryURL = "https://" + domain- } else {- registryURL = "https://" + registryURL+ if normalizedHost == "docker.io" {+ return utilsregistry.NormalizeRegistryURL(registryURL)}- return registryURL, repoPath+ return normalizedHost}-// parseWWWAuth parses the WWW-Authenticate header using the registry client-func parseWWWAuth(header string) (realm, service string) {- c := utilsregistry.NewClient()- return c.ParseAuthChallenge(header)+func isUnauthorizedRegistryErrorInternal(err error) bool {+ if err == nil {+ return false+ }++ // Prefer structured error type check from the Docker SDK / containerd.+ if cerrdefs.IsUnauthorized(err) || cerrdefs.IsPermissionDenied(err) {+ return true+ }++ // Fallback: some Docker daemon versions return plain-text errors without+ // a typed wrapper. These known substrings cover Docker Hub, GHCR, and+ // other common OCI registries as of Docker Engine 27.x.+ errLower := strings.ToLower(err.Error())+ indicators := []string{+ "unauthorized",+ "authentication required",+ "no basic auth credentials",+ "access denied",+ "incorrect username or password",+ }++ for _, indicator := range indicators {+ if strings.Contains(errLower, indicator) {+ return true+ }+ }++ return false}diff --git a/backend/internal/services/container_registry_service_test.go b/backend/internal/services/container_registry_service_test.goindex 9ca07760e..a38c0e2bb 100644--- a/backend/internal/services/container_registry_service_test.go+++ b/backend/internal/services/container_registry_service_test.go@@ -2,18 +2,42 @@ package servicesimport ("context"+ "errors""testing"+ dockerregistry "github.com/moby/moby/api/types/registry"+ "github.com/moby/moby/client"+ "github.com/opencontainers/go-digest"+ ocispec "github.com/opencontainers/image-spec/specs-go/v1""github.com/stretchr/testify/assert""github.com/stretchr/testify/require")+type fakeRegistryDaemonClient struct {+ registryLoginFn func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error)+ distributionInspectFn func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error)+}++func (f *fakeRegistryDaemonClient) RegistryLogin(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {+ if f.registryLoginFn == nil {+ return client.RegistryLoginResult{}, nil+ }+ return f.registryLoginFn(ctx, options)+}++func (f *fakeRegistryDaemonClient) DistributionInspect(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {+ if f.distributionInspectFn == nil {+ return client.DistributionInspectResult{}, nil+ }+ return f.distributionInspectFn(ctx, imageRef, options)+}+func TestContainerRegistryService_GetAllRegistryAuthConfigs_NormalizesHosts(t *testing.T) {_, db := setupImageServiceAuthTest(t)createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")createTestPullRegistry(t, db, "https://GHCR.IO/", "gh-user", "gh-token")- svc := NewContainerRegistryService(db)+ svc := NewContainerRegistryService(db, nil)authConfigs, err := svc.GetAllRegistryAuthConfigs(context.Background())require.NoError(t, err)require.NotNil(t, authConfigs)@@ -40,7 +64,7 @@ func TestContainerRegistryService_GetAllRegistryAuthConfigs_SkipsInvalidEntries(createTestPullRegistry(t, db, "https://ghcr.io", "gh-user", " ")createTestPullRegistry(t, db, "https://registry.example.com", "example-user", "example-token")- svc := NewContainerRegistryService(db)+ svc := NewContainerRegistryService(db, nil)authConfigs, err := svc.GetAllRegistryAuthConfigs(context.Background())require.NoError(t, err)require.NotNil(t, authConfigs)@@ -54,3 +78,115 @@ func TestContainerRegistryService_GetAllRegistryAuthConfigs_SkipsInvalidEntries(assert.Equal(t, "example-token", exampleCfg.Password)assert.Equal(t, "registry.example.com", exampleCfg.ServerAddress)}++func TestContainerRegistryService_TestRegistry_UsesDockerDaemon(t *testing.T) {+ svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {+ return &fakeRegistryDaemonClient{+ registryLoginFn: func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {+ assert.Equal(t, "user", options.Username)+ assert.Equal(t, "token", options.Password)+ assert.Equal(t, "registry.example.com:5443", options.ServerAddress)+ return client.RegistryLoginResult{}, nil+ },+ }, nil+ })++ err := svc.TestRegistry(context.Background(), "https://registry.example.com:5443", "user", "token")+ require.NoError(t, err)+}++func TestContainerRegistryService_TestRegistry_PropagatesDaemonError(t *testing.T) {+ expectedErr := errors.New("tls: failed to verify certificate: x509: certificate signed by unknown authority")+ svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {+ return &fakeRegistryDaemonClient{+ registryLoginFn: func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {+ return client.RegistryLoginResult{}, expectedErr+ },+ }, nil+ })++ err := svc.TestRegistry(context.Background(), "registry.example.com", "user", "token")+ require.Error(t, err)+ assert.ErrorIs(t, err, expectedErr)+}++func TestContainerRegistryService_TestRegistry_SkipsLoginForEmptyCredentials(t *testing.T) {+ svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {+ return &fakeRegistryDaemonClient{+ registryLoginFn: func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {+ t.Fatal("RegistryLogin should not be called with empty credentials")+ return client.RegistryLoginResult{}, nil+ },+ }, nil+ })++ err := svc.TestRegistry(context.Background(), "registry.example.com", "", "")+ require.NoError(t, err)++ err = svc.TestRegistry(context.Background(), "registry.example.com", " ", " ")+ require.NoError(t, err)+}++func TestContainerRegistryService_InspectImageDigest_AnonymousSuccess(t *testing.T) {+ svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {+ return &fakeRegistryDaemonClient{+ distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {+ assert.Equal(t, "registry.example.com:5443/team/app:1.2.3", imageRef)+ assert.Empty(t, options.EncodedRegistryAuth)+ return client.DistributionInspectResult{+ DistributionInspect: dockerregistry.DistributionInspect{+ Descriptor: ocispec.Descriptor{+ Digest: digest.Digest("sha256:feedface"),+ },+ },+ }, nil+ },+ }, nil+ })++ result, err := svc.inspectImageDigestInternal(context.Background(), "registry.example.com:5443/team/app:1.2.3", nil)+ require.NoError(t, err)+ assert.Equal(t, "sha256:feedface", result.Digest)+ assert.Equal(t, "anonymous", result.AuthMethod)+ assert.Equal(t, "registry.example.com:5443", result.AuthRegistry)+}++func TestContainerRegistryService_InspectImageDigest_RetriesWithStoredCredentials(t *testing.T) {+ _, db := setupImageServiceAuthTest(t)+ createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")++ var calls int+ svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {+ return &fakeRegistryDaemonClient{+ distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {+ calls+++ assert.Equal(t, "docker.io/library/nginx:latest", imageRef)+ if calls == 1 {+ assert.Empty(t, options.EncodedRegistryAuth)+ return client.DistributionInspectResult{}, errors.New("unauthorized: authentication required")+ }++ authCfg := decodeRegistryAuth(t, options.EncodedRegistryAuth)+ assert.Equal(t, "docker-user", authCfg.Username)+ assert.Equal(t, "docker-token", authCfg.Password)+ assert.Equal(t, "https://index.docker.io/v1/", authCfg.ServerAddress)++ return client.DistributionInspectResult{+ DistributionInspect: dockerregistry.DistributionInspect{+ Descriptor: ocispec.Descriptor{+ Digest: digest.Digest("sha256:cafebabe"),+ },+ },+ }, nil+ },+ }, nil+ })++ result, err := svc.inspectImageDigestInternal(context.Background(), "registry-1.docker.io/library/nginx:latest", nil)+ require.NoError(t, err)+ assert.Equal(t, 2, calls)+ assert.Equal(t, "sha256:cafebabe", result.Digest)+ assert.Equal(t, "credential", result.AuthMethod)+ assert.Equal(t, "docker-user", result.AuthUsername)+ assert.True(t, result.UsedCredential)+}diff --git a/backend/internal/services/image_service_test.go b/backend/internal/services/image_service_test.goindex 1c67bdd9a..56af7d648 100644--- a/backend/internal/services/image_service_test.go+++ b/backend/internal/services/image_service_test.go@@ -67,7 +67,7 @@ func setupImageServiceAuthTest(t *testing.T) (*ImageService, *database.DB) {dbWrap := &database.DB{DB: db}svc := &ImageService{- registryService: NewContainerRegistryService(dbWrap),+ registryService: NewContainerRegistryService(dbWrap, nil),}return svc, dbWrapdiff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.goindex 730badae2..f8cd60b31 100644--- a/backend/internal/services/image_update_service.go+++ b/backend/internal/services/image_update_service.go@@ -68,9 +68,7 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri}, nil}- registries := s.getRegistriesForImage(ctx, parts.Registry)-- digestResult, snapshot, err := s.checkDigestUpdateWithSnapshotInternal(ctx, parts, registries)+ digestResult, snapshot, err := s.checkDigestUpdateWithSnapshotInternal(ctx, parts)if err != nil {result := &imageupdate.Response{Error: err.Error(),@@ -119,91 +117,32 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef strireturn digestResult, nil}-type authDetails struct {- Method string- Username string- Registry string-}--// Try anonymous first, then each matching registry credential (decrypting token)-// until one returns a token. If auth is not required, returns empty token.-func (s *ImageUpdateService) getRegistryToken(ctx context.Context, regHost, repository string, regs []models.ContainerRegistry) (string, *authDetails, error) {- rc := registry.NewClient()-- slog.DebugContext(ctx, "Checking registry auth", "registry", regHost, "repository", repository)-- authURL, err := rc.CheckAuth(ctx, regHost)- if err != nil {- slog.DebugContext(ctx, "Registry auth check failed", "registry", regHost, "error", err.Error())- return "", nil, fmt.Errorf("failed to check auth: %w", err)- }-- // No auth required- if authURL == "" {- return "", &authDetails{Method: "none", Registry: regHost}, nil- }-- // 1) Try anonymous (works for many public repos)- anonToken, anonErr := rc.GetToken(ctx, authURL, repository, nil)- if anonErr == nil && anonToken != "" {- return anonToken, &authDetails{Method: "anonymous", Registry: regHost}, nil+func (s *ImageUpdateService) checkDigestUpdateWithSnapshotInternal(ctx context.Context, parts *ImageParts) (*imageupdate.Response, *localImageSnapshot, error) {+ if s.registryService == nil {+ return nil, nil, fmt.Errorf("registry service unavailable")}- // 2) Try each matching enabled registry credential- var lastErr error- for i, reg := range regs {- if reg.Username == "" || reg.Token == "" {- continue- }- decrypted, decErr := crypto.Decrypt(reg.Token)- if decErr != nil {- lastErr = decErr- continue- }- creds := ®istry.Credentials{Username: reg.Username, Token: decrypted}- token, err := rc.GetToken(ctx, authURL, repository, creds)- if err == nil && token != "" {- return token, &authDetails{Method: "credential", Username: reg.Username, Registry: regHost}, nil- }- if err != nil {- lastErr = err- } else {- lastErr = fmt.Errorf("empty token (cred idx %d)", i)- }- }-- if lastErr != nil {- return "", nil, fmt.Errorf("failed to get registry token: %w", lastErr)- }- return "", nil, fmt.Errorf("failed to get registry token")-}--func (s *ImageUpdateService) checkDigestUpdateWithSnapshotInternal(ctx context.Context, parts *ImageParts, registries []models.ContainerRegistry) (*imageupdate.Response, *localImageSnapshot, error) {- rc := registry.NewClient()-- token, auth, err := s.getRegistryToken(ctx, parts.Registry, parts.Repository, registries)- if err != nil {- return nil, nil, fmt.Errorf("failed to get registry token: %w", err)- }-- normalizedRepo := s.normalizeRepository(parts.Registry, parts.Repository)-+ imageRef := fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag)start := time.Now()- remoteDigest, _, err := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token)- if err != nil && strings.Contains(strings.ToLower(err.Error()), "unauthorized") {- // Attempt to resolve auth header via registry helpers and retry once- enabledRegs, _ := s.registryService.GetEnabledRegistries(ctx)- authHeader, _, _, resolveErr := registry.ResolveAuthHeaderForRepository(ctx, parts.Registry, normalizedRepo, parts.Tag, enabledRegs)- if resolveErr == nil && authHeader != "" {- remoteDigest, _, err = rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, authHeader)- }- }+ digestResult, err := s.registryService.inspectImageDigestInternal(ctx, imageRef, nil)elapsed := time.Since(start)if err != nil {- return nil, nil, fmt.Errorf("failed to get remote digest: %w", err)+ partial := digestResult // may contain auth metadata even on error+ if partial == nil {+ return nil, nil, fmt.Errorf("failed to get remote digest: %w", err)+ }+ return &imageupdate.Response{+ Error: err.Error(),+ CheckTime: time.Now(),+ ResponseTimeMs: int(elapsed.Milliseconds()),+ AuthMethod: partial.AuthMethod,+ AuthUsername: partial.AuthUsername,+ AuthRegistry: partial.AuthRegistry,+ UsedCredential: partial.UsedCredential,+ }, nil, fmt.Errorf("failed to get remote digest: %w", err)}- snapshot, err := s.inspectLocalImageSnapshotInternal(ctx, fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag))+ snapshot, err := s.inspectLocalImageSnapshotInternal(ctx, imageRef)if err != nil {return nil, nil, fmt.Errorf("failed to get local digest: %w", err)}@@ -211,7 +150,7 @@ func (s *ImageUpdateService) checkDigestUpdateWithSnapshotInternal(ctx context.ClocalDigest := snapshot.PrimaryDigesthasUpdate := truefor _, localDig := range snapshot.AllDigests {- if localDig == remoteDigest {+ if localDig == digestResult.Digest {localDigest = localDighasUpdate = falsebreak@@ -219,23 +158,23 @@ func (s *ImageUpdateService) checkDigestUpdateWithSnapshotInternal(ctx context.C}slog.DebugContext(ctx, "digest comparison",- "imageRef", fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag),+ "imageRef", imageRef,"primaryLocalDigest", localDigest,"allLocalDigests", snapshot.AllDigests,- "remoteDigest", remoteDigest,+ "remoteDigest", digestResult.Digest,"hasUpdate", hasUpdate)return &imageupdate.Response{HasUpdate: hasUpdate,UpdateType: "digest",CurrentDigest: localDigest,- LatestDigest: remoteDigest,+ LatestDigest: digestResult.Digest,CheckTime: time.Now(),ResponseTimeMs: int(elapsed.Milliseconds()),- AuthMethod: auth.Method,- AuthUsername: auth.Username,- AuthRegistry: auth.Registry,- UsedCredential: auth.Method == "credential",+ AuthMethod: digestResult.AuthMethod,+ AuthUsername: digestResult.AuthUsername,+ AuthRegistry: digestResult.AuthRegistry,+ UsedCredential: digestResult.UsedCredential,}, snapshot, nil}@@ -442,36 +381,6 @@ func (s *ImageUpdateService) inspectLocalImageSnapshotInternal(ctx context.Conte}, nil}-// Returns all enabled credentials whose URL matches the image registry domain (normalized)-func (s *ImageUpdateService) getRegistriesForImage(ctx context.Context, regHost string) []models.ContainerRegistry {- normalizedDomain := registry.NormalizeRegistryForComparison(regHost)-- registries, err := s.registryService.GetAllRegistries(ctx)- if err != nil {- slog.DebugContext(ctx, "Failed to load registries for image", "registry", regHost, "error", err.Error())- return nil- }-- var matches []models.ContainerRegistry- for _, reg := range registries {- if !reg.Enabled {- continue- }- normalizedRegURL := registry.NormalizeRegistryForComparison(reg.URL)- if normalizedRegURL == normalizedDomain {- matches = append(matches, reg)- }- }-- slog.DebugContext(ctx, "Matched registry credentials for image", "registry", regHost, "normalizedDomain", normalizedDomain, "matchCount", len(matches))-- for i, reg := range matches {- slog.DebugContext(ctx, "Matched credential", "index", i, "registryURL", reg.URL, "username", reg.Username)- }-- return matches-}-func (s *ImageUpdateService) normalizeRepository(regHost, repo string) string {if regHost == "docker.io" && !strings.Contains(repo, "/") {return "library/" + repo@@ -681,16 +590,6 @@ func (s *ImageUpdateService) MarkUpdatesAsNotified(ctx context.Context, imageIDsUpdate("notification_sent", true).Error}-type batchCred struct {- username string- token string-}--type regAuth struct {- token string- auth *authDetails-}-type batchImage struct {refs []stringcanonicalRef string@@ -733,201 +632,50 @@ func (s *ImageUpdateService) parseAndGroupImagesInternal(imageRefs []string) (mareturn regRepos, results, images}-func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCreds []containerregistry.Credential) (map[string]batchCred, []models.ContainerRegistry) {- var enabledRegs []models.ContainerRegistry- credMap := make(map[string]batchCred)-- if len(externalCreds) > 0 {- enabledRegHosts := make(map[string]struct{})- for _, c := range externalCreds {- if !c.Enabled || c.Username == "" || c.Token == "" {- continue- }- host := registry.NormalizeRegistryForComparison(c.URL)- if host == "" {- continue- }- if _, exists := credMap[host]; !exists {- credMap[host] = batchCred{username: c.Username, token: c.Token}- }- if _, exists := enabledRegHosts[host]; exists {- continue- }- encToken, encErr := crypto.Encrypt(c.Token)- if encErr != nil {- slog.WarnContext(ctx, "Failed to encrypt external registry token", "registryURL", c.URL, "error", encErr.Error())- continue- }- enabledRegs = append(enabledRegs, models.ContainerRegistry{- URL: c.URL,- Username: c.Username,- Token: encToken,- Enabled: c.Enabled,- })- enabledRegHosts[host] = struct{}{}- }- slog.DebugContext(ctx, "Using external credentials for batch check", "credentialCount", len(credMap))- return credMap, enabledRegs- }-- dbRegs, err := s.registryService.GetEnabledRegistries(ctx)- if err != nil {- slog.DebugContext(ctx, "Failed to load enabled registries", "error", err.Error())- return credMap, nil- }- enabledRegs = dbRegs-- for _, r := range dbRegs {- if r.Username == "" || r.Token == "" {- continue- }- host := registry.NormalizeRegistryForComparison(r.URL)- if host == "" {- continue- }- dec, decErr := crypto.Decrypt(r.Token)- if decErr != nil {- slog.DebugContext(ctx, "Decrypt registry token failed", "registryURL", r.URL, "error", decErr.Error())- continue- }- if _, exists := credMap[host]; !exists {- credMap[host] = batchCred{username: r.Username, token: dec}- }- }- return credMap, enabledRegs-}--func (s *ImageUpdateService) buildRegistryAuthMap(ctx context.Context, rc *registry.Client, regRepos map[string]map[string]struct{}, credMap map[string]batchCred) map[string]regAuth {- regAuthMap := make(map[string]regAuth, len(regRepos))-- slog.DebugContext(ctx, "Building registry auth map",- "registryCount", len(regRepos),- "registries", func() []string {- regs := make([]string, 0, len(regRepos))- for r := range regRepos {- regs = append(regs, r)- }- return regs- }(),- "credMapKeys", func() []string {- keys := make([]string, 0, len(credMap))- for k := range credMap {- keys = append(keys, k)- }- return keys- }())-- for regHost, set := range regRepos {- repos := make([]string, 0, len(set))- for r := range set {- repos = append(repos, r)- }-- authURL, err := rc.CheckAuth(ctx, regHost)- if err != nil {- slog.DebugContext(ctx, "Auth probe failed", "registry", regHost, "error", err.Error())- regAuthMap[regHost] = regAuth{token: "", auth: &authDetails{Method: "unknown", Registry: regHost}}- continue- }- // No auth required- if authURL == "" {- regAuthMap[regHost] = regAuth{token: "", auth: &authDetails{Method: "none", Registry: regHost}}- continue- }-- // Credential attempt first (if available)- host := registry.NormalizeRegistryForComparison(regHost)- slog.DebugContext(ctx, "Looking up credentials for registry",- "registry", regHost,- "normalizedHost", host,- "hasCredentials", credMap[host].username != "")- if c, ok := credMap[host]; ok && c.username != "" && c.token != "" {- creds := ®istry.Credentials{Username: c.username, Token: c.token}- if tok, tokErr := rc.GetTokenMulti(ctx, authURL, repos, creds); tokErr == nil && tok != "" {- slog.InfoContext(ctx, "Using credential auth for registry", "registry", regHost, "username", c.username)- regAuthMap[regHost] = regAuth{- token: tok,- auth: &authDetails{Method: "credential", Username: c.username, Registry: regHost},- }- continue- } else {- slog.WarnContext(ctx, "Failed to get token with credentials, falling back to anonymous",- "registry", regHost,- "username", c.username,- "error", func() string {- if tokErr != nil {- return tokErr.Error()- }- return "empty token"- }())- }- }-- // Anonymous multi-scope fallback- if anonToken, anonErr := rc.GetTokenMulti(ctx, authURL, repos, nil); anonErr == nil && anonToken != "" {- slog.DebugContext(ctx, "Using anonymous auth for registry", "registry", regHost)- regAuthMap[regHost] = regAuth{token: anonToken, auth: &authDetails{Method: "anonymous", Registry: regHost}}- continue- }- // Fallback unknown- slog.DebugContext(ctx, "No valid credentials found for registry, using unknown auth", "registry", regHost)- regAuthMap[regHost] = regAuth{token: "", auth: &authDetails{Method: "unknown", Registry: regHost}}+func (s *ImageUpdateService) checkSingleImageInBatchInternal(ctx context.Context, externalCreds []containerregistry.Credential, parts *ImageParts) (*imageupdate.Response, *localImageSnapshot) {+ if s.registryService == nil {+ return &imageupdate.Response{+ Error: "registry service unavailable",+ CheckTime: time.Now(),+ ResponseTimeMs: 0,+ }, nil}- return regAuthMap-}-func (s *ImageUpdateService) checkSingleImageInBatchInternal(- ctx context.Context,- rc *registry.Client,- authMap map[string]regAuth,- enabledRegs []models.ContainerRegistry,- parts *ImageParts,-) (*imageupdate.Response, *localImageSnapshot) {start := time.Now()- authInfo := authMap[parts.Registry]- token := authInfo.token- auth := authInfo.auth- normalizedRepo := s.normalizeRepository(parts.Registry, parts.Repository)-- remoteDigest, _, digestErr := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token)- if digestErr != nil && strings.Contains(strings.ToLower(digestErr.Error()), "unauthorized") {- authHeader, method, username, resolveErr := registry.ResolveAuthHeaderForRepository(ctx, parts.Registry, normalizedRepo, parts.Tag, enabledRegs)- if resolveErr == nil && authHeader != "" {- remoteDigest, _, digestErr = rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, authHeader)- if digestErr == nil {- auth = &authDetails{Method: method, Username: username, Registry: parts.Registry}- }- }- }+ imageRef := fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag)+ digestResult, digestErr := s.registryService.inspectImageDigestInternal(ctx, imageRef, externalCreds)if digestErr != nil {- return &imageupdate.Response{+ resp := &imageupdate.Response{Error: digestErr.Error(),CheckTime: time.Now(),ResponseTimeMs: int(time.Since(start).Milliseconds()),- AuthMethod: auth.Method,- AuthUsername: auth.Username,- AuthRegistry: auth.Registry,- UsedCredential: auth.Method == "credential",- }, nil+ }+ if digestResult != nil {+ resp.AuthMethod = digestResult.AuthMethod+ resp.AuthUsername = digestResult.AuthUsername+ resp.AuthRegistry = digestResult.AuthRegistry+ resp.UsedCredential = digestResult.UsedCredential+ }+ return resp, nil}- snapshot, ldErr := s.inspectLocalImageSnapshotInternal(ctx, fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag))+ snapshot, ldErr := s.inspectLocalImageSnapshotInternal(ctx, imageRef)if ldErr != nil {return &imageupdate.Response{Error: ldErr.Error(),CheckTime: time.Now(),ResponseTimeMs: int(time.Since(start).Milliseconds()),- AuthMethod: auth.Method,- AuthUsername: auth.Username,- AuthRegistry: auth.Registry,- UsedCredential: auth.Method == "credential",+ AuthMethod: digestResult.AuthMethod,+ AuthUsername: digestResult.AuthUsername,+ AuthRegistry: digestResult.AuthRegistry,+ UsedCredential: digestResult.UsedCredential,}, nil}localDigest := snapshot.PrimaryDigesthasDigestUpdate := truefor _, localDig := range snapshot.AllDigests {- if localDig == remoteDigest {+ if localDig == digestResult.Digest {localDigest = localDighasDigestUpdate = falsebreak@@ -938,16 +686,65 @@ func (s *ImageUpdateService) checkSingleImageInBatchInternal(HasUpdate: hasDigestUpdate,UpdateType: "digest",CurrentDigest: localDigest,- LatestDigest: remoteDigest,+ LatestDigest: digestResult.Digest,CheckTime: time.Now(),ResponseTimeMs: int(time.Since(start).Milliseconds()),- AuthMethod: auth.Method,- AuthUsername: auth.Username,- AuthRegistry: auth.Registry,- UsedCredential: auth.Method == "credential",+ AuthMethod: digestResult.AuthMethod,+ AuthUsername: digestResult.AuthUsername,+ AuthRegistry: digestResult.AuthRegistry,+ UsedCredential: digestResult.UsedCredential,}, snapshot}+func (s *ImageUpdateService) resolveBatchCredentialsInternal(ctx context.Context, externalCreds []containerregistry.Credential) []containerregistry.Credential {+ if len(externalCreds) > 0 {+ filtered := make([]containerregistry.Credential, 0, len(externalCreds))+ for _, cred := range externalCreds {+ if !cred.Enabled || strings.TrimSpace(cred.URL) == "" || strings.TrimSpace(cred.Username) == "" || strings.TrimSpace(cred.Token) == "" {+ continue+ }+ filtered = append(filtered, cred)+ }+ return filtered+ }++ if s.registryService == nil {+ return nil+ }++ registries, err := s.registryService.GetEnabledRegistries(ctx)+ if err != nil {+ slog.DebugContext(ctx, "failed to load enabled registries for batch check", "error", err.Error())+ return nil+ }++ credentials := make([]containerregistry.Credential, 0, len(registries))+ for _, reg := range registries {+ if strings.TrimSpace(reg.URL) == "" || strings.TrimSpace(reg.Username) == "" || reg.Token == "" {+ continue+ }++ token, decryptErr := crypto.Decrypt(reg.Token)+ if decryptErr != nil {+ slog.DebugContext(ctx, "failed to decrypt registry token for batch check", "registryURL", reg.URL, "error", decryptErr.Error())+ continue+ }+ token = strings.TrimSpace(token)+ if token == "" {+ continue+ }++ credentials = append(credentials, containerregistry.Credential{+ URL: reg.URL,+ Username: reg.Username,+ Token: token,+ Enabled: reg.Enabled,+ })+ }++ return credentials+}+func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs []string, externalCreds []containerregistry.Credential) (map[string]*imageupdate.Response, error) {startBatch := time.Now()results := make(map[string]*imageupdate.Response, len(imageRefs))@@ -957,16 +754,12 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefsslog.DebugContext(ctx, "Starting batch image update check", "imageCount", len(imageRefs), "externalCredCount", len(externalCreds))- rc := registry.NewClient()-regRepos, initialResults, images := s.parseAndGroupImagesInternal(imageRefs)maps.Copy(results, initialResults)- credMap, enabledRegs := s.buildCredentialMap(ctx, externalCreds)-- slog.DebugContext(ctx, "Built credential map", "credMapSize", len(credMap), "enabledRegsCount", len(enabledRegs))+ resolvedCreds := s.resolveBatchCredentialsInternal(ctx, externalCreds)- regAuthMap := s.buildRegistryAuthMap(ctx, rc, regRepos, credMap)+ slog.DebugContext(ctx, "Resolved batch registry credentials", "credentialCount", len(resolvedCreds), "registryCount", len(regRepos))var mu sync.Mutexg, groupCtx := errgroup.WithContext(ctx)@@ -974,7 +767,7 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefsfor _, img := range images {g.Go(func() error {- res, snapshot := s.checkSingleImageInBatchInternal(groupCtx, rc, regAuthMap, enabledRegs, img.parts)+ res, snapshot := s.checkSingleImageInBatchInternal(groupCtx, resolvedCreds, img.parts)mu.Lock()for _, ref := range img.refs {diff --git a/backend/internal/services/image_update_service_test.go b/backend/internal/services/image_update_service_test.goindex 617846eef..6d6a9eb6d 100644--- a/backend/internal/services/image_update_service_test.go+++ b/backend/internal/services/image_update_service_test.go@@ -6,12 +6,8 @@ import ("testing""time"- "github.com/getarcaneapp/arcane/backend/internal/config""github.com/getarcaneapp/arcane/backend/internal/database""github.com/getarcaneapp/arcane/backend/internal/models"- "github.com/getarcaneapp/arcane/backend/internal/utils/crypto"- utilsregistry "github.com/getarcaneapp/arcane/backend/internal/utils/registry"- "github.com/getarcaneapp/arcane/types/containerregistry""github.com/getarcaneapp/arcane/types/imageupdate"glsqlite "github.com/glebarez/sqlite"dockertypesimage "github.com/moby/moby/api/types/image"@@ -761,70 +757,6 @@ func TestImageUpdateService_ParseAndGroupImages_DedupesNormalizedRefs(t *testingcontainsAll(firstRefSet, "redis:7", "docker.io/library/redis:7")))}-func TestImageUpdateService_BuildCredentialMap_ExternalCredsDedupesEnabledRegistriesByHost(t *testing.T) {- crypto.InitEncryption(&config.Config{- Environment: config.AppEnvironmentTest,- EncryptionKey: "test-encryption-key-for-testing-32bytes-min",- })-- svc := &ImageUpdateService{}- ctx := context.Background()-- externalCreds := []containerregistry.Credential{- {URL: "https://ghcr.io", Username: "first-user", Token: "first-token", Enabled: true},- {URL: "ghcr.io/", Username: "second-user", Token: "second-token", Enabled: true},- {URL: "https://docker.io", Username: "docker-user", Token: "docker-token", Enabled: true},- }-- credMap, enabledRegs := svc.buildCredentialMap(ctx, externalCreds)-- require.Len(t, credMap, 2)- require.Len(t, enabledRegs, 2)-- // Keep first credential per normalized host for token exchange calls.- assert.Equal(t, "first-user", credMap["ghcr.io"].username)- assert.Equal(t, "first-token", credMap["ghcr.io"].token)- assert.Equal(t, "docker-user", credMap["docker.io"].username)- assert.Equal(t, "docker-token", credMap["docker.io"].token)-- // Enabled registry records used for auth fallback should be de-duplicated per host.- enabledByHost := make(map[string]models.ContainerRegistry, len(enabledRegs))- for _, reg := range enabledRegs {- host := utilsregistry.NormalizeRegistryForComparison(reg.URL)- enabledByHost[host] = reg- }- require.Contains(t, enabledByHost, "ghcr.io")- require.Contains(t, enabledByHost, "docker.io")-- assert.Equal(t, "first-user", enabledByHost["ghcr.io"].Username)- assert.NotEmpty(t, enabledByHost["ghcr.io"].Token)- assert.Equal(t, "docker-user", enabledByHost["docker.io"].Username)- assert.NotEmpty(t, enabledByHost["docker.io"].Token)-}--func TestImageUpdateService_BuildCredentialMap_ExternalCredsSkipsInvalidEntries(t *testing.T) {- crypto.InitEncryption(&config.Config{- Environment: config.AppEnvironmentTest,- EncryptionKey: "test-encryption-key-for-testing-32bytes-min",- })-- svc := &ImageUpdateService{}- ctx := context.Background()-- externalCreds := []containerregistry.Credential{- {URL: "https://ghcr.io", Username: "valid-user", Token: "valid-token", Enabled: true},- {URL: "https://ghcr.io", Username: "", Token: "missing-user", Enabled: true},- {URL: "https://ghcr.io", Username: "disabled", Token: "disabled-token", Enabled: false},- {URL: "", Username: "missing-url", Token: "token", Enabled: true},- }-- credMap, enabledRegs := svc.buildCredentialMap(ctx, externalCreds)-- require.Len(t, credMap, 1)- require.Len(t, enabledRegs, 1)- assert.Equal(t, "valid-user", credMap["ghcr.io"].username)-}-func TestDedupeImageRefsFromSummaries_WithLimit(t *testing.T) {summaries := []dockertypesimage.Summary{{RepoTags: []string{"nginx:latest", "nginx:latest", "<none>:<none>"}},diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.goindex 0973b78bd..73a495cc2 100644--- a/backend/internal/services/updater_service.go+++ b/backend/internal/services/updater_service.go@@ -158,15 +158,7 @@ func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (*updateif err != nil {return nil, fmt.Errorf("docker connect: %w", err)}- registryClient := arcRegistry.NewClient()- digestChecker := arcaneupdater.NewDigestChecker(dcli, registryClient)-- enabledRegs := []models.ContainerRegistry{}- if s.registryService != nil {- if regs, rerr := s.registryService.GetEnabledRegistries(ctx); rerr == nil {- enabledRegs = regs- }- }+ digestChecker := arcaneupdater.NewDigestChecker(dcli, s.registryService)// track all old image IDs we saw for pulled updates so we can prune them after restartoldIDSet := map[string]struct{}{}@@ -202,9 +194,7 @@ func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (*update// Digest pre-check: if registry supports it and digests match, avoid pulling entirely.// This also prevents unnecessary restarts when the update record is stale.normNew := s.normalizeRef(p.newRef)- host, repo, tag := s.parseNormalizedRef(normNew)- authHeader, _, _, _ := arcRegistry.ResolveAuthHeaderForRepository(ctx, host, repo, tag, enabledRegs)- check := digestChecker.CheckImageNeedsUpdate(ctx, normNew, authHeader)+ check := digestChecker.CheckImageNeedsUpdate(ctx, normNew)skipPull := falseif check.CheckedViaAPI && check.Error == nil && !check.NeedsUpdate {@@ -533,8 +523,10 @@ func (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerIDreturn out, nil}- // Compare with pulled image to avoid unnecessary restart- checker := arcaneupdater.NewDigestChecker(dcli, arcRegistry.NewClient())+ // Compare with pulled image to avoid unnecessary restart.+ // digestResolver is intentionally nil: CompareWithPulled only inspects local+ // images and does not need remote registry access.+ checker := arcaneupdater.NewDigestChecker(dcli, nil)changed, cmpErr := checker.CompareWithPulled(ctx, inspectBefore.Image, normalizedRef)slog.InfoContext(ctx, "UpdateSingleContainer: digest comparison","containerID", containerID,@@ -1140,7 +1132,8 @@ func (s *UpdaterService) resolveLocalImageIDsForRef(ctx context.Context, ref strreturn nil, err}- checker := arcaneupdater.NewDigestChecker(dcli, arcRegistry.NewClient())+ // digestResolver is intentionally nil: GetImageIDsForRef only inspects local images.+ checker := arcaneupdater.NewDigestChecker(dcli, nil)ids, err := checker.GetImageIDsForRef(ctx, ref)if err != nil {return nil, err@@ -1501,25 +1494,6 @@ func resolvePullableImageRefInternal(summaryImage, inspectConfigImage string, rereturn "", ""}-// parseNormalizedRef expects a normalized ref in the form "host/repository:tag".-func (s *UpdaterService) parseNormalizedRef(ref string) (host, repository, tag string) {- // host/repo:tag- parts := strings.SplitN(ref, "/", 2)- if len(parts) != 2 {- return "", "", ""- }- host = parts[0]- rest := parts[1]- tag = "latest"- if i := strings.LastIndex(rest, ":"); i != -1 && strings.LastIndex(rest, "/") < i {- tag = rest[i+1:]- repository = rest[:i]- } else {- repository = rest- }- return host, repository, tag-}-func (s *UpdaterService) logAutoUpdate(ctx context.Context, sev models.EventSeverity, metadata models.JSON) {phase, _ := metadata["phase"].(string)diff --git a/backend/internal/utils/arcaneupdater/digest.go b/backend/internal/utils/arcaneupdater/digest.goindex 2f104964c..b132f574a 100644--- a/backend/internal/utils/arcaneupdater/digest.go+++ b/backend/internal/utils/arcaneupdater/digest.go@@ -6,22 +6,27 @@ import ("log/slog""strings"- "github.com/getarcaneapp/arcane/backend/internal/utils/registry""github.com/moby/moby/client"ref "go.podman.io/image/v5/docker/reference"++ "github.com/getarcaneapp/arcane/backend/internal/utils/registry")+type remoteDigestResolver interface {+ GetImageDigest(ctx context.Context, imageRef string) (string, error)+}+// DigestChecker provides methods to check if an image needs updating by comparing digeststype DigestChecker struct {dcli *client.Client- registryClient *registry.Client+ digestResolver remoteDigestResolver}// NewDigestChecker creates a new DigestChecker-func NewDigestChecker(dcli *client.Client, registryClient *registry.Client) *DigestChecker {+func NewDigestChecker(dcli *client.Client, digestResolver remoteDigestResolver) *DigestChecker {return &DigestChecker{dcli: dcli,- registryClient: registryClient,+ digestResolver: digestResolver,}}@@ -36,17 +41,12 @@ type CheckResult struct {// CheckImageNeedsUpdate checks if an image has a newer version available without pulling// Returns true if the remote digest differs from the local digest-func (c *DigestChecker) CheckImageNeedsUpdate(ctx context.Context, imageRef string, authToken string) CheckResult {+func (c *DigestChecker) CheckImageNeedsUpdate(ctx context.Context, imageRef string) CheckResult {result := CheckResult{}- // Parse image reference- registryHost, repository, tag := parseImageRef(imageRef)-slog.DebugContext(ctx, "CheckImageNeedsUpdate: checking image","imageRef", imageRef,- "registry", registryHost,- "repository", repository,- "tag", tag)+ "normalizedRef", normalizeRef(imageRef))// Get local digestlocalDigest, err := c.getLocalDigest(ctx, imageRef)@@ -61,10 +61,15 @@ func (c *DigestChecker) CheckImageNeedsUpdate(ctx context.Context, imageRef stri}result.LocalDigest = localDigest- // Get remote digest via HEAD request- remoteDigest, err := c.registryClient.GetLatestDigest(ctx, registryHost, repository, tag, authToken)+ if c.digestResolver == nil {+ result.Error = fmt.Errorf("remote digest resolver unavailable")+ return result+ }++ // Get remote digest via the Docker daemon-backed registry path.+ remoteDigest, err := c.digestResolver.GetImageDigest(ctx, imageRef)if err != nil {- slog.DebugContext(ctx, "CheckImageNeedsUpdate: failed to get remote digest via HEAD",+ slog.DebugContext(ctx, "CheckImageNeedsUpdate: failed to get remote digest","imageRef", imageRef,"error", err)// Can't determine remotely - caller should fall back to pulldiff --git a/backend/internal/utils/registry/auth.go b/backend/internal/utils/registry/auth.godeleted file mode 100644index 48b8004ed..000000000--- a/backend/internal/utils/registry/auth.go+++ /dev/null@@ -1,377 +0,0 @@-package registry--import (- "context"- "encoding/base64"- "encoding/json"- "fmt"- "net/http"- "net/url"- "strings"- "time"-- ref "go.podman.io/image/v5/docker/reference"-- "github.com/getarcaneapp/arcane/backend/internal/models"- "github.com/getarcaneapp/arcane/backend/internal/utils/crypto"-)--type Credentials struct {- Username string- Token string-}--func (c *Client) GetRegistryURL(registry string) string {- registry = strings.TrimSpace(registry)-- if strings.HasPrefix(registry, "http://") || strings.HasPrefix(registry, "https://") {- if parsed, err := url.Parse(registry); err == nil && parsed.Host != "" {- if NormalizeRegistryForComparison(parsed.Host) == "docker.io" {- return "https://index.docker.io"- }- }- return strings.TrimSuffix(registry, "/")- }-- switch NormalizeRegistryForComparison(registry) {- case "docker.io":- return "https://index.docker.io"- default:- return "https://" + NormalizeRegistryForComparison(registry)- }-}--func (c *Client) getServiceName(authURL string) string {- if strings.Contains(authURL, "auth.docker.io") {- return "registry.docker.io"- }- parts := strings.Split(strings.TrimPrefix(authURL, "https://"), "/")- if len(parts) > 0 {- return parts[0]- }- return "registry"-}--func (c *Client) ParseAuthChallenge(header string) (string, string) {- lower := strings.ToLower(header)- if !strings.HasPrefix(lower, "bearer ") {- return "", ""- }- _, after, ok := strings.Cut(header, " ")- if !ok {- return "", ""- }- raw := after- parts := strings.Split(raw, ",")- var realm, service string- for _, p := range parts {- p = strings.TrimSpace(p)- lp := strings.ToLower(p)- switch {- case strings.HasPrefix(lp, "realm="):- realm = strings.Trim(p[len("realm="):], `"`)- case strings.HasPrefix(lp, "service="):- service = strings.Trim(p[len("service="):], `"`)- }- }- return realm, service-}--func (c *Client) CheckAuth(ctx context.Context, registry string) (string, error) {- url := fmt.Sprintf("%s/v2/", c.GetRegistryURL(registry))- ctx, cancel := context.WithTimeout(ctx, 10*time.Second)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)- if err != nil {- return "", err- }- resp, err := c.http.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint- if err != nil {- return "", err- }- defer func() { _ = resp.Body.Close() }()-- if resp.StatusCode == http.StatusUnauthorized {- h := resp.Header.Get("WWW-Authenticate")- if h == "" {- h = resp.Header.Get("Www-Authenticate")- }- if h != "" {- realm, service := c.ParseAuthChallenge(h)- if realm != "" {- if service != "" && !strings.Contains(realm, "service=") {- if strings.Contains(realm, "?") {- return realm + "&service=" + service, nil- }- return realm + "?service=" + service, nil- }- return realm, nil- }- }- }- return "", nil-}--func (c *Client) GetTokenMulti(ctx context.Context, authURL string, repositories []string, creds *Credentials) (string, error) {- parsed, err := url.Parse(authURL)- if err != nil {- return "", fmt.Errorf("invalid auth url: %w", err)- }- q := parsed.Query()- if q.Get("service") == "" {- q.Set("service", c.getServiceName(authURL))- }- for _, repo := range repositories {- q.Add("scope", fmt.Sprintf("repository:%s:pull", repo))- }- parsed.RawQuery = q.Encode()-- ctx, cancel := context.WithTimeout(ctx, 30*time.Second)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, http.MethodGet, parsed.String(), nil)- if err != nil {- return "", err- }- if creds != nil && creds.Username != "" && creds.Token != "" {- req.SetBasicAuth(creds.Username, creds.Token)- }- resp, err := c.http.Do(req) //nolint:gosec // intentional token request to registry auth realm from challenge- if err != nil {- return "", err- }- defer func() { _ = resp.Body.Close() }()- if resp.StatusCode != http.StatusOK {- return "", fmt.Errorf("token request failed with status: %d", resp.StatusCode)- }- var tr struct {- Token string `json:"token"`- }- if err := json.NewDecoder(resp.Body).Decode(&tr); err != nil {- return "", err- }- return tr.Token, nil-}--func (c *Client) GetToken(ctx context.Context, authURL, repository string, creds *Credentials) (string, error) {- return c.GetTokenMulti(ctx, authURL, []string{repository}, creds)-}--// AcquireTokenViaChallenge:-// Parses a WWW-Authenticate Bearer challenge, builds an auth URL,-// tries anonymous multi-scope token, then credential-based.-// Returns (token, method, username, error)-func AcquireTokenViaChallenge(- ctx context.Context,- registryHost string,- repository string,- challengeHeader string,- enabledRegs []models.ContainerRegistry,-) (string, string, string, error) {- // Normalize challenge to start at Bearer- ch := strings.TrimSpace(challengeHeader)- low := strings.ToLower(ch)- if idx := strings.Index(low, "bearer "); idx >= 0 && idx != 0 {- ch = ch[idx:]- }-- // Extract (realm, service)- c := NewClient()- realm, service := c.ParseAuthChallenge(ch)- if realm == "" {- return "", "", "", fmt.Errorf("invalid challenge")- }-- authURL := realm- if service != "" && !strings.Contains(authURL, "service=") {- if strings.Contains(authURL, "?") {- authURL += "&service=" + service- } else {- authURL += "?service=" + service- }- }-- repoNorm := normalizeRepositoryForDockerIO(registryHost, repository)- scopes := []string{repoNorm}-- // Anonymous attempt- if tok, err := c.GetTokenMulti(ctx, authURL, scopes, nil); err == nil && tok != "" {- return tok, "anonymous", "", nil- }-- // Credential attempts- hostNorm := normalizeHost(registryHost)- for _, cr := range enabledRegs {- if !cr.Enabled || cr.Username == "" || cr.Token == "" {- continue- }- if normalizeHost(cr.URL) != hostNorm {- continue- }- dec, err := crypto.Decrypt(cr.Token)- if err != nil {- continue- }- creds := &Credentials{Username: cr.Username, Token: dec}- if tok, err := c.GetTokenMulti(ctx, authURL, scopes, creds); err == nil && tok != "" {- return tok, "credential", cr.Username, nil- }- }-- return "", "", "", fmt.Errorf("token acquisition failed")-}--// Helpers (formerly in check.go)--func normalizeHost(u string) string {- return NormalizeRegistryForComparison(u)-}--func normalizeRepositoryForDockerIO(registryHost, repo string) string {- r := normalizeHost(registryHost)- if r == "docker.io" {- if !strings.Contains(repo, "/") {- return "library/" + repo- }- if strings.Count(repo, "/") == 0 {- return "library/" + repo- }- }- return repo-}--func GetChallengeRequest(ctx context.Context, u url.URL) (*http.Request, error) {- req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)- if err != nil {- return nil, err- }- req.Header.Set("Accept", "*/*")- req.Header.Set("User-Agent", "Arcane")- return req, nil-}--// GetChallengeURL returns https://<host>/v2/ for a given image ref (normalized).-// host is normalized so docker.io => index.docker.io.-func GetChallengeURL(imageRef string) (url.URL, error) {- named, err := ref.ParseNormalizedNamed(imageRef)- if err != nil {- return url.URL{}, err- }- host, err := GetRegistryAddress(named.Name())- if err != nil {- return url.URL{}, err- }- return url.URL{Scheme: "https", Host: host, Path: "/v2/"}, nil-}--// GetAuthHeaderForImage performs the /v2/ challenge for an image and returns a usable Authorization header.-// It supports Basic and Bearer challenges. For Bearer, it reuses AcquireTokenViaChallenge which-// looks up credentials from the database (enabledRegs) when needed.-func GetAuthHeaderForImage(ctx context.Context, imageRef string, enabledRegs []models.ContainerRegistry) (string, error) {- chURL, err := GetChallengeURL(imageRef)- if err != nil {- return "", err- }-- if _, ok := ctx.Deadline(); !ok {- var cancel context.CancelFunc- ctx, cancel = context.WithTimeout(ctx, 5*time.Second)- defer cancel()- }-- req, err := GetChallengeRequest(ctx, chURL)- if err != nil {- return "", err- }-- c := NewClient()- resp, err := c.http.Do(req) //nolint:gosec // intentional /v2/ challenge request to resolved registry host- if err != nil {- return "", err- }- defer func() { _ = resp.Body.Close() }()-- ch := resp.Header.Get(ChallengeHeader)- if ch == "" {- // try alternate case just in case- ch = resp.Header.Get("Www-Authenticate")- }-- // If /v2/ returns 200 or there's no WWW-Authenticate header, the registry is open —- // no auth header required. Return empty header instead of an error.- if resp.StatusCode == http.StatusOK || strings.TrimSpace(ch) == "" {- return "", nil- }-- chLower := strings.ToLower(strings.TrimSpace(ch))-- named, err := ref.ParseNormalizedNamed(imageRef)- if err != nil {- return "", err- }- host, err := GetRegistryAddress(named.Name())- if err != nil {- return "", err- }- repo := ref.Path(named)-- switch {- case strings.HasPrefix(chLower, "basic"):- h := normalizeHost(host)- for _, cr := range enabledRegs {- if !cr.Enabled || cr.Username == "" || cr.Token == "" {- continue- }- if normalizeHost(cr.URL) != h {- continue- }- dec, err := crypto.Decrypt(cr.Token)- if err != nil {- continue- }- ba := []byte(cr.Username + ":" + dec)- return "Basic " + base64.StdEncoding.EncodeToString(ba), nil- }- return "", fmt.Errorf("no credentials available for basic auth at %s", host)-- case strings.HasPrefix(chLower, "bearer"):- token, _, _, err := AcquireTokenViaChallenge(ctx, host, repo, ch, enabledRegs)- if err != nil {- return "", err- }- if token == "" {- return "", fmt.Errorf("empty bearer token")- }- return "Bearer " + token, nil-- default:- return "", fmt.Errorf("unsupported challenge type from registry: %q", ch)- }-}--func ResolveAuthHeaderForRepository(ctx context.Context, host, repository, tag string, enabledRegs []models.ContainerRegistry) (string, string, string, error) {- var imageRef string- if tag != "" {- imageRef = fmt.Sprintf("%s/%s:%s", host, repository, tag)- } else {- imageRef = fmt.Sprintf("%s/%s", host, repository)- }-- hdr, err := GetAuthHeaderForImage(ctx, imageRef, enabledRegs)- if err != nil {- return "", "", "", err- }- if hdr == "" {- return "", "none", "", nil- }- lh := strings.ToLower(strings.TrimSpace(hdr))- switch {- case strings.HasPrefix(lh, "basic "):- return hdr, "basic", "", nil- case strings.HasPrefix(lh, "bearer "):- return hdr, "bearer", "", nil- default:- return hdr, "unknown", "", nil- }-}diff --git a/backend/internal/utils/registry/client.go b/backend/internal/utils/registry/client.godeleted file mode 100644index 385abc182..000000000--- a/backend/internal/utils/registry/client.go+++ /dev/null@@ -1,17 +0,0 @@-package registry--import (- "net/http"-)--// Client provides helper methods for Docker/OCI registries.-type Client struct {- http *http.Client-}--func NewClient() *Client {- transport := http.DefaultTransport.(*http.Transport).Clone()- transport.Proxy = http.ProxyFromEnvironment-- return &Client{http: &http.Client{Transport: transport}}-}diff --git a/backend/internal/utils/registry/digest.go b/backend/internal/utils/registry/digest.godeleted file mode 100644index d838cc9c3..000000000--- a/backend/internal/utils/registry/digest.go+++ /dev/null@@ -1,130 +0,0 @@-package registry--import (- "context"- "fmt"- "log/slog"- "net/http"- "strings"- "time"-)--// buildAuthHeader constructs a proper Authorization header value from a token.-// If token already has a scheme (Bearer/Basic), it's used as-is. Otherwise, Bearer is assumed.-func buildAuthHeader(token string) string {- t := strings.TrimSpace(token)- if t == "" {- return ""- }- lower := strings.ToLower(t)- if strings.HasPrefix(lower, "bearer ") || strings.HasPrefix(lower, "basic ") {- return t- }- return "Bearer " + t-}--// getHeaderCI returns the first header value for the given key, case-insensitively.-func getHeaderCI(h http.Header, key string) string {- for k, v := range h {- if strings.EqualFold(k, key) && len(v) > 0 {- return v[0]- }- }- return ""-}--func extractDigestFromHeaders(h http.Header) string {- d := getHeaderCI(h, ContentDigestHeader)- if d != "" {- return d- }- etag := getHeaderCI(h, "ETag")- if etag != "" {- etag = strings.Trim(etag, `"`)- if strings.HasPrefix(etag, "sha256:") {- return etag- }- }- return ""-}--func (c *Client) GetLatestDigest(ctx context.Context, registry, repository, tag, token string) (string, error) {- url := fmt.Sprintf("%s/v2/%s/manifests/%s", c.GetRegistryURL(registry), repository, tag)- ctx, cancel := context.WithTimeout(ctx, 30*time.Second)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, http.MethodHead, url, nil)- if err != nil {- return "", err- }-- req.Header.Add("Accept", "application/vnd.docker.distribution.manifest.v2+json")- req.Header.Add("Accept", "application/vnd.docker.distribution.manifest.list.v2+json")- req.Header.Add("Accept", "application/vnd.docker.distribution.manifest.v1+json")- req.Header.Add("Accept", "application/vnd.oci.image.index.v1+json")- req.Header.Add("Accept", "application/vnd.oci.image.manifest.v1+json")- req.Header.Set("User-Agent", "Arcane")-- if ah := buildAuthHeader(token); ah != "" {- req.Header.Set("Authorization", ah)- }-- start := time.Now()- resp, err := c.http.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint- if err != nil {- return "", err- }- defer func() { _ = resp.Body.Close() }()-- // If HEAD isn't supported by the registry, fall back to GET and try again.- if resp.StatusCode == http.StatusMethodNotAllowed || resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusForbidden {- slog.DebugContext(ctx, "HEAD not supported or returned unexpected status, retrying with GET", "url", url, "status", resp.StatusCode)- // create GET request- getReq, rerr := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)- if rerr != nil {- return "", rerr- }- getReq.Header = req.Header.Clone()- getResp, derr := c.http.Do(getReq) //nolint:gosec // intentional fallback request to same user-configured registry endpoint- if derr != nil {- return "", derr- }- defer func() { _ = getResp.Body.Close() }()- resp = getResp- }-- elapsed := time.Since(start)- slog.DebugContext(ctx, "manifest request completed", "url", url, "status", resp.StatusCode, "elapsed", elapsed)-- if resp.StatusCode == http.StatusUnauthorized {- h := getHeaderCI(resp.Header, "WWW-Authenticate")- if h != "" {- slog.DebugContext(ctx, "manifest request unauthorized", "www-authenticate", h)- return "", fmt.Errorf("unauthorized: %s", h)- }- return "", fmt.Errorf("manifest request failed with status: 401")- }- if resp.StatusCode != http.StatusOK {- www := getHeaderCI(resp.Header, "WWW-Authenticate")- if www == "" {- www = "not present"- }- slog.DebugContext(ctx, "manifest request unexpected status", "www-authenticate", www)- return "", fmt.Errorf("manifest request failed with status: %d, auth: %q", resp.StatusCode, www)- }-- d := extractDigestFromHeaders(resp.Header)- if d == "" {- return "", fmt.Errorf("no digest header found in response")- }-- slog.DebugContext(ctx, "resolved remote digest", "registry", registry, "repository", repository, "tag", tag, "digest", d, "elapsed", elapsed)-- return d, nil-}--func (c *Client) GetLatestDigestTimed(ctx context.Context, registry, repository, tag, token string) (string, time.Duration, error) {- start := time.Now()- d, err := c.GetLatestDigest(ctx, registry, repository, tag, token)- return d, time.Since(start), err-}diff --git a/backend/internal/utils/registry/ping.go b/backend/internal/utils/registry/ping.godeleted file mode 100644index 611503dd1..000000000--- a/backend/internal/utils/registry/ping.go+++ /dev/null@@ -1,66 +0,0 @@-// Package registry is derived from Moby's registry implementation.-//-// Source: https://github.com/moby/moby/blob/v28.5.2/registry/auth.go-// License: Apache License 2.0-// SPDX-License-Identifier: Apache-2.0-//-// # Simplified Wrapper as Arcane only needs the Ping Function currently-//-// This local copy is vendored to avoid pulling conflicting module variants-// during dependency resolution in this monorepo.-package registry--import (- "context"- "net/http"- "net/url"- "strings"- "time"-- "github.com/docker/distribution/registry/client/auth/challenge"-)--type PingResponseError struct {- Err error-}--func (e PingResponseError) Error() string {- if e.Err == nil {- return "registry ping response error"- }-- return e.Err.Error()-}--func (e PingResponseError) Unwrap() error {- return e.Err-}--// PingV2Registry attempts to ping a v2 registry and on success return a-// challenge manager for the supported authentication types.-// If a response is received but cannot be interpreted, a PingResponseError will be returned.-func PingV2Registry(ctx context.Context, endpoint *url.URL, transport http.RoundTripper) (challenge.Manager, error) {- pingClient := &http.Client{- Transport: transport,- Timeout: 15 * time.Second,- }- endpointStr := strings.TrimRight(endpoint.String(), "/") + "/v2/"- req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpointStr, http.NoBody)- if err != nil {- return nil, err- }- resp, err := pingClient.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint- if err != nil {- return nil, err- }- defer resp.Body.Close()-- challengeManager := challenge.NewSimpleManager()- if err := challengeManager.AddResponse(resp); err != nil {- return nil, PingResponseError{- Err: err,- }- }-- return challengeManager, nil-}diff --git a/backend/internal/utils/registry/registry_test.go b/backend/internal/utils/registry/registry_test.godeleted file mode 100644index ea6481e11..000000000--- a/backend/internal/utils/registry/registry_test.go+++ /dev/null@@ -1,88 +0,0 @@-package registry--import (- "context"- "encoding/json"- "fmt"- "net/http"- "net/http/httptest"- "net/url"- "testing"-)--func TestCheckAuthParsesRealmAndService(t *testing.T) {- t.Parallel()- realm := "https://auth.example/token"- service := "example.org"- srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- if r.URL.Path == "/v2/" {- w.Header().Set("WwW-Authenticate", `Bearer realm="`+realm+`",service="`+service+`"`)- http.Error(w, "unauthorized", http.StatusUnauthorized)- return- }- w.WriteHeader(http.StatusOK)- }))- defer srv.Close()-- c := NewClient()- got, err := c.CheckAuth(context.Background(), srv.URL)- if err != nil {- t.Fatalf("err: %v", err)- }- exp := realm + "?service=" + service- if got != exp {- t.Fatalf("got %q want %q", got, exp)- }-}--func TestGetTokenMultiScopes(t *testing.T) {- t.Parallel()- var scopes []string- var service string- srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- _ = r.ParseForm()- scopes = r.Form["scope"]- service = r.Form.Get("service")- _ = json.NewEncoder(w).Encode(map[string]string{"token": "t123"})- }))- defer srv.Close()-- u, _ := url.Parse(srv.URL)- authURL := fmt.Sprintf("%s/auth?service=test.local", u.String())-- c := NewClient()- tok, err := c.GetTokenMulti(context.Background(), authURL, []string{"library/a", "library/b"}, nil)- if err != nil {- t.Fatalf("err: %v", err)- }- if tok != "t123" {- t.Fatalf("token %q", tok)- }- if len(scopes) != 2 {- t.Fatalf("scopes %v", scopes)- }- if service != "test.local" {- t.Fatalf("service %q", service)- }-}--func TestGetLatestDigestLowerCaseHeader(t *testing.T) {- t.Parallel()- srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- if r.Method != http.MethodHead {- t.Fatalf("expected HEAD, got %s", r.Method)- }- w.Header().Set("docker-content-digest", "sha256:feedface")- w.WriteHeader(http.StatusOK)- }))- defer srv.Close()-- c := NewClient()- d, err := c.GetLatestDigest(context.Background(), srv.URL, "org/repo", "latest", "")- if err != nil {- t.Fatalf("err: %v", err)- }- if d != "sha256:feedface" {- t.Fatalf("digest %q", d)- }-}diff --git a/backend/internal/utils/registry/test_connection.go b/backend/internal/utils/registry/test_connection.godeleted file mode 100644index f76e80fae..000000000--- a/backend/internal/utils/registry/test_connection.go+++ /dev/null@@ -1,228 +0,0 @@-package registry--import (- "context"- "encoding/base64"- "fmt"- "net/http"- "net/url"- "strings"- "time"-- "github.com/docker/distribution/registry/client/auth/challenge"-)--type TestResult struct {- OverallSuccess bool `json:"overall_success"`- PingSuccess bool `json:"ping_success"`- AuthSuccess bool `json:"auth_success"`- CatalogSuccess bool `json:"catalog_success"`- URL string `json:"url"`- Domain string `json:"domain"`- Timestamp time.Time `json:"timestamp"`- Errors []string `json:"errors"`-}--const (- authTimeout = 10 * time.Second- catalogTimeout = 15 * time.Second- registryPing = "/v2/"- registryCatalog = "/v2/_catalog"-)--type registryConnectionTester struct {- client *Client- registry string- result *TestResult- endpoint *url.URL-}--func TestRegistryConnection(ctx context.Context, registryURL string, creds *Credentials) (*TestResult, error) {- tester := ®istryConnectionTester{- client: NewClient(),- registry: normalizeRegistry(registryURL),- result: &TestResult{- URL: registryURL,- Domain: registryURL,- Timestamp: time.Now(),- Errors: []string{},- },- }-- if err := tester.parseEndpoint(); err != nil {- return tester.result, err- }-- challengeManager, err := tester.ping(ctx)- if err != nil {- return tester.result, err- }-- authHeader := tester.performAuth(ctx, challengeManager, creds)- tester.testCatalog(ctx, authHeader)-- tester.result.OverallSuccess = tester.result.PingSuccess && tester.result.AuthSuccess && tester.result.CatalogSuccess- return tester.result, nil-}--func normalizeRegistry(registryURL string) string {- reg := NormalizeRegistryForComparison(registryURL)- if reg == "docker.io" {- return DefaultRegistry- }- return reg-}--func (t *registryConnectionTester) parseEndpoint() error {- registryEndpoint := t.client.GetRegistryURL(t.registry)- endpointURL, err := url.Parse(registryEndpoint)- if err != nil {- t.addErrorf("Invalid registry URL: %v", err)- return err- }-- t.endpoint = endpointURL- return nil-}--func (t *registryConnectionTester) ping(ctx context.Context) (challenge.Manager, error) {- challengeManager, err := PingV2Registry(ctx, t.endpoint, t.client.http.Transport)- if err != nil {- t.addErrorf("Connectivity test failed: %v", err)- return nil, err- }- t.result.PingSuccess = true- return challengeManager, nil-}--func extractAuthURL(challengeManager challenge.Manager, endpointURL *url.URL) string {- if challengeManager == nil {- return ""- }-- challenges, err := challengeManager.GetChallenges(*endpointURL)- if err != nil {- return ""- }-- for _, ch := range challenges {- if !strings.EqualFold(ch.Scheme, "bearer") {- continue- }- realm, ok := ch.Parameters["realm"]- if !ok || strings.TrimSpace(realm) == "" {- continue- }-- authURL, parseErr := url.Parse(realm)- if parseErr != nil {- return ""- }- if service, ok := ch.Parameters["service"]; ok && strings.TrimSpace(service) != "" {- query := authURL.Query()- if query.Get("service") == "" {- query.Set("service", service)- authURL.RawQuery = query.Encode()- }- }- return authURL.String()- }-- return ""-}--func (t *registryConnectionTester) performAuth(ctx context.Context, challengeManager challenge.Manager, creds *Credentials) string {- authURL := extractAuthURL(challengeManager, t.endpoint)- if authURL == "" {- t.result.AuthSuccess = true- return ""- }- if creds == nil {- t.result.AuthSuccess = false- return ""- }-- if authHeader := t.tryBearerAuth(ctx, authURL, creds); authHeader != "" {- t.result.AuthSuccess = true- return authHeader- }-- authHeader, ok := t.tryBasicAuth(ctx, creds)- t.result.AuthSuccess = ok- return authHeader-}--func (t *registryConnectionTester) tryBearerAuth(ctx context.Context, authURL string, creds *Credentials) string {- tok, err := t.client.GetTokenMulti(ctx, authURL, []string{}, creds)- if err == nil && tok != "" {- return "Bearer " + tok- }-- return ""-}--func (t *registryConnectionTester) tryBasicAuth(ctx context.Context, creds *Credentials) (string, bool) {- resp, err := t.doRegistryGet(ctx, registryPing, authTimeout, func(req *http.Request) {- req.SetBasicAuth(creds.Username, creds.Token)- })- if err != nil {- t.addErrorf("Auth request failed: %v", err)- return "", false- }- defer func() { _ = resp.Body.Close() }()-- if resp.StatusCode != http.StatusOK {- t.addErrorf("Auth failed: status %d", resp.StatusCode)- return "", false- }-- ba := []byte(creds.Username + ":" + creds.Token)- return "Basic " + base64.StdEncoding.EncodeToString(ba), true-}--func (t *registryConnectionTester) testCatalog(ctx context.Context, authHeader string) {- resp, err := t.doRegistryGet(ctx, registryCatalog, catalogTimeout, func(req *http.Request) {- if authHeader != "" {- req.Header.Set("Authorization", authHeader)- }- })- if err != nil {- t.addErrorf("Catalog request failed: %v", err)- t.result.CatalogSuccess = false- return- }- defer func() { _ = resp.Body.Close() }()-- t.result.CatalogSuccess = resp.StatusCode == http.StatusOK- if !t.result.CatalogSuccess {- t.addErrorf("Catalog returned status: %d", resp.StatusCode)- }-}--func (t *registryConnectionTester) doRegistryGet(ctx context.Context, path string, timeout time.Duration, setup func(*http.Request)) (*http.Response, error) {- reqCtx, cancel := context.WithTimeout(ctx, timeout)- defer cancel()-- req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, t.registryURL(path), http.NoBody)- if err != nil {- return nil, err- }- if setup != nil {- setup(req)- }-- resp, err := t.client.http.Do(req) //nolint:gosec // intentional request to user-provided registry for connection test- if err != nil {- return nil, err- }-- return resp, nil-}--func (t *registryConnectionTester) registryURL(path string) string {- return strings.TrimRight(t.client.GetRegistryURL(t.registry), "/") + path-}--func (t *registryConnectionTester) addErrorf(format string, args ...any) {- t.result.Errors = append(t.result.Errors, fmt.Sprintf(format, args...))-}diff --git a/backend/internal/utils/validation/email_test.go b/backend/internal/utils/validation/email_test.goindex 57f1ed0ed..96228472e 100644--- a/backend/internal/utils/validation/email_test.go+++ b/backend/internal/utils/validation/email_test.go@@ -13,7 +13,6 @@ func TestIsValidUserEmail_AllowsReportedFormats(t *testing.T) {}for _, email := range validEmails {- email := emailt.Run(email, func(t *testing.T) {t.Parallel()if !IsValidUserEmail(email) {@@ -42,7 +41,6 @@ func TestIsValidUserEmail_RejectsMalformedAddresses(t *testing.T) {}for _, email := range invalidEmails {- email := emailt.Run(email, func(t *testing.T) {t.Parallel()if IsValidUserEmail(email) {diff --git a/backend/pkg/projects/compose_test.go b/backend/pkg/projects/compose_test.goindex 09a860f80..aa60f0215 100644--- a/backend/pkg/projects/compose_test.go+++ b/backend/pkg/projects/compose_test.go@@ -26,5 +26,5 @@ func TestWrapDockerCLIWithInspectCompatibility(t *testing.T) {wrapped := wrapDockerCLIWithInspectCompatibilityInternal(baseCLI)require.NotNil(t, wrapped)require.NotSame(t, baseCLI, wrapped)- require.NotEqual(t, reflect.TypeOf(apiClient), reflect.TypeOf(wrapped.Client()))+ require.NotEqual(t, reflect.TypeFor[*mobyclient.Client](), reflect.TypeOf(wrapped.Client()))}diff --git a/backend/pkg/scheduler/analytics_job_test.go b/backend/pkg/scheduler/analytics_job_test.goindex 1c19473ae..304b1e995 100644--- a/backend/pkg/scheduler/analytics_job_test.go+++ b/backend/pkg/scheduler/analytics_job_test.go@@ -205,12 +205,10 @@ func TestAnalyticsJob_Run_ConcurrentRunsSendOnce(t *testing.T) {start := make(chan struct{})var wg sync.WaitGroupfor range 2 {- wg.Add(1)- go func() {- defer wg.Done()+ wg.Go(func() {<-startjob.Run(ctx)- }()+ })}close(start)diff --git a/cli/go.sum b/cli/go.sumindex 9a5434098..5ac11a2ba 100644--- a/cli/go.sum+++ b/cli/go.sum@@ -155,6 +155,7 @@ go.yaml.in/yaml/v4 v4.0.0-rc.4/go.mod h1:aZqd9kCMsGL7AuUv/m/PvWLdg5sjJsZ4oHDEnfPgolang.org/x/exp v0.0.0-20250911091902-df9299821621 h1:2id6c1/gto0kaHYyrixvknJ8tUK/Qs5IsmBtrc+FtgU=golang.org/x/exp v0.0.0-20250911091902-df9299821621/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk=golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=diff --git a/types/go.sum b/types/go.sumindex c77f51088..477535861 100644--- a/types/go.sum+++ b/types/go.sum@@ -66,6 +66,7 @@ go.opentelemetry.io/otel/trace v1.40.0/go.mod h1:zeAhriXecNGP/s2SEG3+Y8X9ujcJOTqgo.yaml.in/yaml/v4 v4.0.0-rc.4 h1:UP4+v6fFrBIb1l934bDl//mmnoIZEDK0idg1+AIvX5U=go.yaml.in/yaml/v4 v4.0.0-rc.4/go.mod h1:aZqd9kCMsGL7AuUv/m/PvWLdg5sjJsZ4oHDEnfPPfY0=golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=