Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: pass registry credentials to environments (#603)
Kyle Mendelle04d6c92ca8b
diff --git a/.env.dev b/.env.devindex bd4a10215..3a456b2a7 100644--- a/.env.dev+++ b/.env.dev@@ -24,5 +24,5 @@ JWT_SECRET=dev-jwt-secret-replace-in-production-must-be-long-enoughDATABASE_URL=file:data/arcane.db?_pragma=journal_mode(WAL)&_pragma=busy_timeout(2500)&_txlock=immediate# Agent Configuration (for development agent service)-AGENT_MODE=false+# AGENT_MODE=fAGENT_BOOTSTRAP_TOKEN=development-bootstrap-tokendiff --git a/backend/internal/api/container_handler.go b/backend/internal/api/container_handler.goindex 25b6c4f42..dd35e6aeb 100644--- a/backend/internal/api/container_handler.go+++ b/backend/internal/api/container_handler.go@@ -170,7 +170,7 @@ func (h *ContainerHandler) PullImage(c *gin.Context) {if !ok {return}- if err := h.imageService.PullImage(c.Request.Context(), imageName, c.Writer, *currentUser); err != nil {+ if err := h.imageService.PullImage(c.Request.Context(), imageName, c.Writer, *currentUser, nil); err != nil {c.JSON(http.StatusInternalServerError, gin.H{"success": false,"data": gin.H{"error": "Failed to pull image: " + err.Error()},diff --git a/backend/internal/api/environment_handler.go b/backend/internal/api/environment_handler.goindex e8eb4bbba..40b75ea21 100644--- a/backend/internal/api/environment_handler.go+++ b/backend/internal/api/environment_handler.go@@ -1,6 +1,7 @@package apiimport (+ "log/slog""net/http""github.com/gin-gonic/gin"@@ -96,14 +97,23 @@ func (h *EnvironmentHandler) CreateEnvironment(c *gin.Context) {env.Enabled = *req.Enabled}- // Auto-pair with agent if bootstrap token is providedif (req.AccessToken == nil || *req.AccessToken == "") && req.BootstrapToken != nil && *req.BootstrapToken != "" {- if token, err := h.environmentService.PairAgentWithBootstrap(c.Request.Context(), req.ApiUrl, *req.BootstrapToken); err == nil && token != "" {- env.AccessToken = &token- } else if err != nil {- c.JSON(http.StatusBadGateway, gin.H{"success": false, "data": gin.H{"error": "Agent pairing failed: " + err.Error()}})+ token, err := h.environmentService.PairAgentWithBootstrap(c.Request.Context(), req.ApiUrl, *req.BootstrapToken)+ if err != nil {+ slog.ErrorContext(c.Request.Context(), "Failed to pair with agent",+ slog.String("apiUrl", req.ApiUrl),+ slog.String("error", err.Error()))++ c.JSON(http.StatusBadGateway, gin.H{+ "success": false,+ "data": gin.H{+ "error": "Agent pairing failed: " + err.Error(),+ "hint": "Ensure the agent is running and the bootstrap token matches AGENT_BOOTSTRAP_TOKEN",+ },+ })return}+ env.AccessToken = &token} else if req.AccessToken != nil && *req.AccessToken != "" {env.AccessToken = req.AccessToken}diff --git a/backend/internal/api/image_handler.go b/backend/internal/api/image_handler.goindex d2d73ce91..fb7e452a5 100644--- a/backend/internal/api/image_handler.go+++ b/backend/internal/api/image_handler.go@@ -124,7 +124,7 @@ func (h *ImageHandler) Pull(c *gin.Context) {return}- if err := h.imageService.PullImage(ctx, req.ImageName, c.Writer, *currentUser); err != nil {+ if err := h.imageService.PullImage(ctx, req.ImageName, c.Writer, *currentUser, req.Credentials); err != nil {c.JSON(http.StatusInternalServerError, gin.H{"success": false,"data": dto.MessageDto{Message: fmt.Sprintf("Failed to pull image '%s': %s", req.ImageName, err.Error())},diff --git a/backend/internal/api/image_update_handler.go b/backend/internal/api/image_update_handler.goindex f2b46dd47..30768cc32 100644--- a/backend/internal/api/image_update_handler.go+++ b/backend/internal/api/image_update_handler.go@@ -98,7 +98,7 @@ func (h *ImageUpdateHandler) CheckMultipleImages(c *gin.Context) {return}- results, err := h.imageUpdateService.CheckMultipleImages(c.Request.Context(), req.ImageRefs)+ results, err := h.imageUpdateService.CheckMultipleImages(c.Request.Context(), req.ImageRefs, req.Credentials)if err != nil {c.JSON(http.StatusInternalServerError, gin.H{"success": false,@@ -116,7 +116,10 @@ func (h *ImageUpdateHandler) CheckMultipleImages(c *gin.Context) {}func (h *ImageUpdateHandler) CheckAllImages(c *gin.Context) {- results, err := h.imageUpdateService.CheckAllImages(c.Request.Context(), 0)+ var req dto.BatchImageUpdateRequest+ _ = c.ShouldBindJSON(&req)++ results, err := h.imageUpdateService.CheckAllImages(c.Request.Context(), 0, req.Credentials)if err != nil {c.JSON(http.StatusInternalServerError, gin.H{"success": false,diff --git a/backend/internal/bootstrap/jobs_bootstrap.go b/backend/internal/bootstrap/jobs_bootstrap.goindex bd419f9c5..b0a9f837b 100644--- a/backend/internal/bootstrap/jobs_bootstrap.go+++ b/backend/internal/bootstrap/jobs_bootstrap.go@@ -23,12 +23,11 @@ func registerJobs(appCtx context.Context, scheduler *job.Scheduler, appServicesslog.ErrorContext(appCtx, "Failed to register auto-update job", slog.Any("error", err))}- imagePollingJob := job.NewImagePollingJob(scheduler, appServices.ImageUpdate, appServices.Settings)+ imagePollingJob := job.NewImagePollingJob(scheduler, appServices.ImageUpdate, appServices.Settings, appServices.Environment)if err := imagePollingJob.Register(appCtx); err != nil {slog.ErrorContext(appCtx, "Failed to register image polling job", slog.Any("error", err))}- // Register analytics heartbeat jobanalyticsJob := job.NewAnalyticsJob(scheduler, appServices.Settings, nil, appConfig)if err := analyticsJob.Register(appCtx); err != nil {slog.ErrorContext(appCtx, "Failed to register analytics heartbeat job", slog.Any("error", err))diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.goindex c2b298ac1..d85baa277 100644--- a/backend/internal/bootstrap/router_bootstrap.go+++ b/backend/internal/bootstrap/router_bootstrap.go@@ -71,25 +71,30 @@ func setupRouter(cfg *config.Config, appServices *Services) *gin.Engine {api.NewOidcHandler(apiGroup, appServices.Auth, appServices.Oidc, cfg)api.NewSettingsHandler(apiGroup, appServices.Settings, authMiddleware)api.NewEnvironmentHandler(apiGroup, appServices.Environment, appServices.Settings, authMiddleware, cfg)+ api.NewContainerRegistryHandler(apiGroup, appServices.ContainerRegistry, authMiddleware)+ api.NewTemplateHandler(apiGroup, appServices.Template, authMiddleware)- apiGroup.Use(middleware.NewEnvProxyMiddleware(api.LOCAL_DOCKER_ENVIRONMENT_ID, func(ctx context.Context, id string) (string, *string, bool, error) {- env, err := appServices.Environment.GetEnvironmentByID(ctx, id)- if err != nil || env == nil {- return "", nil, false, err- }- return env.ApiUrl, env.AccessToken, env.Enabled, nil- }))+ envMiddleware := middleware.NewEnvProxyMiddlewareWithParam(+ api.LOCAL_DOCKER_ENVIRONMENT_ID,+ "id",+ func(ctx context.Context, id string) (string, *string, bool, error) {+ env, err := appServices.Environment.GetEnvironmentByID(ctx, id)+ if err != nil || env == nil {+ return "", nil, false, err+ }+ return env.ApiUrl, env.AccessToken, env.Enabled, nil+ },+ appServices.Environment,+ )+ apiGroup.Use(envMiddleware)api.NewHealthHandler(apiGroup)-api.NewContainerHandler(apiGroup, appServices.Docker, appServices.Container, appServices.Image, authMiddleware)- api.NewContainerRegistryHandler(apiGroup, appServices.ContainerRegistry, authMiddleware)api.NewImageHandler(apiGroup, appServices.Docker, appServices.Image, appServices.ImageUpdate, authMiddleware)api.NewImageUpdateHandler(apiGroup, appServices.ImageUpdate, authMiddleware)api.NewNetworkHandler(apiGroup, appServices.Docker, appServices.Network, authMiddleware)api.NewProjectHandler(apiGroup, appServices.Project, authMiddleware)api.NewSystemHandler(apiGroup, appServices.Docker, appServices.System, authMiddleware)- api.NewTemplateHandler(apiGroup, appServices.Template, authMiddleware)api.NewUpdaterHandler(apiGroup, appServices.Updater, authMiddleware)api.NewVolumeHandler(apiGroup, appServices.Docker, appServices.Volume, authMiddleware)diff --git a/backend/internal/dto/container_registry_dto.go b/backend/internal/dto/container_registry_dto.goindex 7a0ed1610..5dd824273 100644--- a/backend/internal/dto/container_registry_dto.go+++ b/backend/internal/dto/container_registry_dto.go@@ -12,3 +12,10 @@ type ContainerRegistryDto struct {CreatedAt time.Time `json:"createdAt"`UpdatedAt time.Time `json:"updatedAt"`}++type ContainerRegistryCredential struct {+ URL string `json:"url" binding:"required"`+ Username string `json:"username" binding:"required"`+ Token string `json:"token" binding:"required"`+ Enabled bool `json:"enabled"`+}diff --git a/backend/internal/dto/image_dto.go b/backend/internal/dto/image_dto.goindex ec09e4ff8..edc17f34c 100644--- a/backend/internal/dto/image_dto.go+++ b/backend/internal/dto/image_dto.go@@ -9,7 +9,8 @@ import ()type ImagePullDto struct {- ImageName string `json:"imageName" binding:"required"`+ ImageName string `json:"imageName" binding:"required"`+ Credentials []ContainerRegistryCredential `json:"credentials,omitempty"`}type ImageUpdateInfoDto struct {diff --git a/backend/internal/dto/image_update_dto.go b/backend/internal/dto/image_update_dto.goindex 3c3360c17..a8e39ab08 100644--- a/backend/internal/dto/image_update_dto.go+++ b/backend/internal/dto/image_update_dto.go@@ -43,7 +43,8 @@ type VersionComparisonResponse struct {}type BatchImageUpdateRequest struct {- ImageRefs []string `json:"imageRefs" binding:"required"`+ ImageRefs []string `json:"imageRefs" binding:"required"`+ Credentials []ContainerRegistryCredential `json:"credentials,omitempty"`}type BatchImageUpdateResponse map[string]*ImageUpdateResponsediff --git a/backend/internal/job/image_polling_job.go b/backend/internal/job/image_polling_job.goindex ac2561c85..51e680421 100644--- a/backend/internal/job/image_polling_job.go+++ b/backend/internal/job/image_polling_job.go@@ -6,19 +6,22 @@ import ("time""github.com/go-co-op/gocron/v2"+ "github.com/ofkm/arcane-backend/internal/dto""github.com/ofkm/arcane-backend/internal/services")type ImagePollingJob struct {imageUpdateService *services.ImageUpdateServicesettingsService *services.SettingsService+ environmentService *services.EnvironmentServicescheduler *Scheduler}-func NewImagePollingJob(scheduler *Scheduler, imageUpdateService *services.ImageUpdateService, settingsService *services.SettingsService) *ImagePollingJob {+func NewImagePollingJob(scheduler *Scheduler, imageUpdateService *services.ImageUpdateService, settingsService *services.SettingsService, environmentService *services.EnvironmentService) *ImagePollingJob {return &ImagePollingJob{imageUpdateService: imageUpdateService,settingsService: settingsService,+ environmentService: environmentService,scheduler: scheduler,}}@@ -35,14 +38,13 @@ func (j *ImagePollingJob) Register(ctx context.Context) error {interval := time.Duration(pollingInterval) * time.Minuteif interval < 5*time.Minute {slog.WarnContext(ctx, "polling interval too low; using default",- "requested_minutes", pollingInterval,- "effective_interval", "60m")+ slog.Int("requested_minutes", pollingInterval),+ slog.String("effective_interval", "60m"))interval = 60 * time.Minute}- slog.InfoContext(ctx, "registering image polling job", "interval", interval.String())+ slog.InfoContext(ctx, "registering image polling job", slog.String("interval", interval.String()))- // ensure single instancej.scheduler.RemoveJobByName("image-polling")jobDefinition := gocron.DurationJob(interval)@@ -58,9 +60,16 @@ func (j *ImagePollingJob) Register(ctx context.Context) error {func (j *ImagePollingJob) Execute(ctx context.Context) error {slog.InfoContext(ctx, "image scan run started")- results, err := j.imageUpdateService.CheckAllImages(ctx, 0)+ creds, err := j.loadRegistryCredentials(ctx)if err != nil {- slog.ErrorContext(ctx, "image scan failed", "err", err)+ slog.WarnContext(ctx, "failed to load registry credentials for polling",+ slog.String("error", err.Error()))+ creds = nil+ }++ results, err := j.imageUpdateService.CheckAllImages(ctx, 0, creds)+ if err != nil {+ slog.ErrorContext(ctx, "image scan failed", slog.Any("err", err))return err}@@ -81,14 +90,17 @@ func (j *ImagePollingJob) Execute(ctx context.Context) error {}slog.InfoContext(ctx, "image scan run completed",- "checked", total,- "updates", updates,- "errors", errors,- )+ slog.Int("checked", total),+ slog.Int("updates", updates),+ slog.Int("errors", errors))return nil}+func (j *ImagePollingJob) loadRegistryCredentials(ctx context.Context) ([]dto.ContainerRegistryCredential, error) {+ return j.environmentService.GetEnabledRegistryCredentials(ctx)+}+func (j *ImagePollingJob) Reschedule(ctx context.Context) error {pollingEnabled := j.settingsService.GetBoolSetting(ctx, "pollingEnabled", true)pollingInterval := j.settingsService.GetIntSetting(ctx, "pollingInterval", 60)@@ -103,7 +115,7 @@ func (j *ImagePollingJob) Reschedule(ctx context.Context) error {if interval < 5*time.Minute {interval = 60 * time.Minute}- slog.InfoContext(ctx, "polling settings changed; rescheduling", "interval", interval.String())+ slog.InfoContext(ctx, "polling settings changed; rescheduling", slog.String("interval", interval.String()))return j.scheduler.RescheduleDurationJobByName(ctx, "image-polling", interval, j.Execute, false)}diff --git a/backend/internal/middleware/environment_middleware.go b/backend/internal/middleware/environment_middleware.goindex 5a61961c6..86ea1c5bc 100644--- a/backend/internal/middleware/environment_middleware.go+++ b/backend/internal/middleware/environment_middleware.go@@ -11,6 +11,8 @@ import ("time""github.com/gin-gonic/gin"+ "github.com/ofkm/arcane-backend/internal/services"+ "github.com/ofkm/arcane-backend/internal/utils/remenv"wsutil "github.com/ofkm/arcane-backend/internal/utils/ws")@@ -19,37 +21,42 @@ type EnvResolver func(ctx context.Context, id string) (apiURL string, accessToke// NewEnvProxyMiddleware preserves the previous API and uses "id" as the param name.func NewEnvProxyMiddleware(localID string, resolver EnvResolver) gin.HandlerFunc {- return NewEnvProxyMiddlewareWithParam(localID, "id", resolver)+ return NewEnvProxyMiddlewareWithParam(localID, "id", resolver, nil)}// NewEnvProxyMiddlewareWithParam returns a gin middleware that proxies requests whose environment id// is remote. paramName is the URL param key (e.g. "id") that contains the environment id when using// router groups; if that param is not present the middleware will attempt to auto-detect the id// by parsing the request path after the first "/environments/" segment.-//-//nolint:gocognit-func NewEnvProxyMiddlewareWithParam(localID string, paramName string, resolver EnvResolver) gin.HandlerFunc {+func NewEnvProxyMiddlewareWithParam(localID string, paramName string, resolver EnvResolver, envService *services.EnvironmentService) gin.HandlerFunc {+ m := &EnvironmentMiddleware{+ localID: localID,+ resolver: resolver,+ envService: envService,+ httpClient: &http.Client{+ Timeout: 60 * time.Second,+ },+ }+ return m.handle(paramName)+}++type EnvironmentMiddleware struct {+ localID string+ resolver EnvResolver+ envService *services.EnvironmentService+ httpClient *http.Client+}++func (m *EnvironmentMiddleware) handle(paramName string) gin.HandlerFunc {return func(c *gin.Context) {- envID := c.Param(paramName)-- // Fallback: try to auto-detect env id from path like "/.../environments/<envID>/..."- if envID == "" {- const marker = "/environments/"- if idx := strings.Index(c.Request.URL.Path, marker); idx >= 0 {- rest := c.Request.URL.Path[idx+len(marker):]- parts := strings.SplitN(rest, "/", 2)- if len(parts) > 0 && parts[0] != "" {- envID = parts[0]- }- }- }+ envID := m.extractEnvironmentID(c, paramName)- if envID == "" || envID == localID {+ if envID == "" || envID == m.localID {c.Next()return}- apiURL, accessToken, enabled, err := resolver(c.Request.Context(), envID)+ apiURL, accessToken, enabled, err := m.resolver(c.Request.Context(), envID)if err != nil || apiURL == "" {c.JSON(http.StatusNotFound, gin.H{"success": false, "data": gin.H{"error": "Environment not found"}})c.Abort()@@ -61,146 +68,151 @@ func NewEnvProxyMiddlewareWithParam(localID string, paramName string, resolver Ereturn}- // Build target: map incoming /api/environments/:id/... -> remoteApiUrl/api/environments/<localID>/...- prefix := "/api/environments/" + envID- suffix := strings.TrimPrefix(c.Request.URL.Path, prefix)- if !strings.HasPrefix(suffix, "/") && suffix != "" {- suffix = "/" + suffix- }- target := strings.TrimRight(apiURL, "/") + path.Join("/api/environments/", localID) + suffix- if qs := c.Request.URL.RawQuery; qs != "" {- target += "?" + qs- }+ target := m.buildTargetURL(c, envID, apiURL)- if strings.EqualFold(c.GetHeader("Upgrade"), "websocket") || strings.Contains(strings.ToLower(c.GetHeader("Connection")), "upgrade") {- wsTarget := target- if strings.HasPrefix(target, "https://") {- wsTarget = "wss://" + strings.TrimPrefix(target, "https://")- } else if strings.HasPrefix(target, "http://") {- wsTarget = "ws://" + strings.TrimPrefix(target, "http://")- }-- hdr := http.Header{}- if auth := c.GetHeader("Authorization"); auth != "" {- hdr.Set("Authorization", auth)- } else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {- hdr.Set("Authorization", "Bearer "+cookieToken)- }-- if hdr.Get("Authorization") == "" {- if cookieHeader := c.Request.Header.Get("Cookie"); cookieHeader != "" {- hdr.Set("Cookie", cookieHeader)- }- }-- if accessToken != nil && *accessToken != "" {- hdr.Set("X-Arcane-Agent-Token", *accessToken)- }-- if err := wsutil.ProxyHTTP(c.Writer, c.Request, wsTarget, hdr); err != nil {- slog.Error("websocket proxy failed", "env_id", envID, "target", wsTarget, "err", err)- }- c.Abort()+ if m.isWebSocketRequest(c) {+ m.handleWebSocket(c, target, accessToken, envID)return}- var bodyReader io.Reader- if c.Request.Body != nil {- bodyReader = c.Request.Body- }+ m.proxyHTTP(c, target, accessToken)+ }+}- req, err := http.NewRequestWithContext(c.Request.Context(), c.Request.Method, target, bodyReader)- if err != nil {- c.JSON(http.StatusInternalServerError, gin.H{"success": false, "data": gin.H{"error": "Failed to create proxy request"}})- c.Abort()- return- }+func (m *EnvironmentMiddleware) extractEnvironmentID(c *gin.Context, paramName string) string {+ envID := c.Param(paramName)+ if envID != "" {+ return envID+ }- skip := map[string]struct{}{- "Host": {},- "Connection": {},- "Keep-Alive": {},- "Proxy-Authenticate": {},- "Proxy-Authorization": {},- "Te": {},- "Trailer": {},- "Transfer-Encoding": {},- "Upgrade": {},- "Content-Length": {},- "Origin": {},- "Referer": {},- "Access-Control-Request-Method": {},- "Access-Control-Request-Headers": {},- "Cookie": {},- }- for k, vs := range c.Request.Header {- ck := http.CanonicalHeaderKey(k)- if _, ok := skip[ck]; ok || ck == "Authorization" {- continue- }- for _, v := range vs {- req.Header.Add(k, v)- }+ const marker = "/environments/"+ if idx := strings.Index(c.Request.URL.Path, marker); idx >= 0 {+ rest := c.Request.URL.Path[idx+len(marker):]+ parts := strings.SplitN(rest, "/", 2)+ if len(parts) > 0 && parts[0] != "" {+ return parts[0]}+ }- // Forward Authorization (or promote cookie)- if auth := c.GetHeader("Authorization"); auth != "" {- req.Header.Set("Authorization", auth)- } else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {- req.Header.Set("Authorization", "Bearer "+cookieToken)- }+ return ""+}- // Forward agent token if provided by resolver- if accessToken != nil && *accessToken != "" {- req.Header.Set("X-Arcane-Agent-Token", *accessToken)- }+func (m *EnvironmentMiddleware) buildTargetURL(c *gin.Context, envID, apiURL string) string {+ prefix := "/api/environments/" + envID+ suffix := strings.TrimPrefix(c.Request.URL.Path, prefix)+ if !strings.HasPrefix(suffix, "/") && suffix != "" {+ suffix = "/" + suffix+ }- req.Header.Set("X-Forwarded-For", c.ClientIP())- req.Header.Set("X-Forwarded-Host", c.Request.Host)+ target := strings.TrimRight(apiURL, "/") + path.Join("/api/environments/", m.localID) + suffix+ if qs := c.Request.URL.RawQuery; qs != "" {+ target += "?" + qs+ }- client := &http.Client{Timeout: 60 * time.Second}- resp, err := client.Do(req)- if err != nil {- c.JSON(http.StatusBadGateway, gin.H{"success": false, "data": gin.H{"error": fmt.Sprintf("Proxy request failed: %v", err)}})- c.Abort()- return- }- defer resp.Body.Close()-- hop := map[string]struct{}{- http.CanonicalHeaderKey("Connection"): {},- http.CanonicalHeaderKey("Keep-Alive"): {},- http.CanonicalHeaderKey("Proxy-Authenticate"): {},- http.CanonicalHeaderKey("Proxy-Authorization"): {},- http.CanonicalHeaderKey("TE"): {},- http.CanonicalHeaderKey("Trailers"): {},- http.CanonicalHeaderKey("Trailer"): {},- http.CanonicalHeaderKey("Transfer-Encoding"): {},- http.CanonicalHeaderKey("Upgrade"): {},- }- for _, connVal := range resp.Header.Values("Connection") {- for _, token := range strings.Split(connVal, ",") {- if t := strings.TrimSpace(token); t != "" {- hop[http.CanonicalHeaderKey(t)] = struct{}{}- }- }- }+ return target+}- for k, vs := range resp.Header {- ck := http.CanonicalHeaderKey(k)- if _, ok := hop[ck]; ok {- continue- }- for _, v := range vs {- c.Writer.Header().Add(k, v)- }- }+func (m *EnvironmentMiddleware) isWebSocketRequest(c *gin.Context) bool {+ return strings.EqualFold(c.GetHeader("Upgrade"), "websocket") ||+ strings.Contains(strings.ToLower(c.GetHeader("Connection")), "upgrade")+}- c.Status(resp.StatusCode)- if c.Request.Method != http.MethodHead {- _, _ = io.Copy(c.Writer, resp.Body)+func (m *EnvironmentMiddleware) handleWebSocket(c *gin.Context, target string, accessToken *string, envID string) {+ wsTarget := m.convertToWebSocketURL(target)+ hdr := m.buildWebSocketHeaders(c, accessToken)++ if err := wsutil.ProxyHTTP(c.Writer, c.Request, wsTarget, hdr); err != nil {+ slog.Error("websocket proxy failed", "env_id", envID, "target", wsTarget, "err", err)+ }+ c.Abort()+}++func (m *EnvironmentMiddleware) convertToWebSocketURL(target string) string {+ if strings.HasPrefix(target, "https://") {+ return "wss://" + strings.TrimPrefix(target, "https://")+ }+ if strings.HasPrefix(target, "http://") {+ return "ws://" + strings.TrimPrefix(target, "http://")+ }+ return target+}++func (m *EnvironmentMiddleware) buildWebSocketHeaders(c *gin.Context, accessToken *string) http.Header {+ hdr := http.Header{}++ if auth := c.GetHeader("Authorization"); auth != "" {+ hdr.Set("Authorization", auth)+ } else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {+ hdr.Set("Authorization", "Bearer "+cookieToken)+ }++ if hdr.Get("Authorization") == "" {+ if cookieHeader := c.Request.Header.Get("Cookie"); cookieHeader != "" {+ hdr.Set("Cookie", cookieHeader)}+ }++ if accessToken != nil && *accessToken != "" {+ hdr.Set("X-Arcane-Agent-Token", *accessToken)+ }++ return hdr+}++func (m *EnvironmentMiddleware) proxyHTTP(c *gin.Context, target string, accessToken *string) {+ req, err := m.createProxyRequest(c, target, accessToken)+ if err != nil {+ c.JSON(http.StatusInternalServerError, gin.H{"success": false, "data": gin.H{"error": "Failed to create proxy request"}})+ c.Abort()+ return+ }+ resp, err := m.httpClient.Do(req)+ if err != nil {+ c.JSON(http.StatusBadGateway, gin.H{"success": false, "data": gin.H{"error": fmt.Sprintf("Proxy request failed: %v", err)}})c.Abort()+ return+ }+ defer resp.Body.Close()++ m.copyResponseToClient(c, resp)+ c.Abort()+}++func (m *EnvironmentMiddleware) createProxyRequest(c *gin.Context, target string, accessToken *string) (*http.Request, error) {+ var bodyReader io.Reader+ if c.Request.Body != nil {+ bodyReader = c.Request.Body+ }++ req, err := http.NewRequestWithContext(c.Request.Context(), c.Request.Method, target, bodyReader)+ if err != nil {+ return nil, err+ }++ skip := remenv.GetSkipHeaders()+ remenv.CopyRequestHeaders(c.Request.Header, req.Header, skip)+ remenv.SetAuthHeader(req, c)+ remenv.SetAgentToken(req, accessToken)+ remenv.SetForwardedHeaders(req, c.ClientIP(), c.Request.Host)++ if remenv.NeedsCredentialInjection(target) {+ if err := remenv.InjectRegistryCredentials(c.Request.Context(), req, m.envService); err != nil {+ slog.WarnContext(c.Request.Context(), "Failed to inject registry credentials",+ slog.String("error", err.Error()),+ slog.String("target", target))+ }+ }++ return req, nil+}++func (m *EnvironmentMiddleware) copyResponseToClient(c *gin.Context, resp *http.Response) {+ hop := remenv.BuildHopByHopHeaders(resp.Header)+ remenv.CopyResponseHeaders(resp.Header, c.Writer.Header(), hop)++ c.Status(resp.StatusCode)+ if c.Request.Method != http.MethodHead {+ _, _ = io.Copy(c.Writer, resp.Body)}}diff --git a/backend/internal/services/environment_service.go b/backend/internal/services/environment_service.goindex 001bd85eb..1a1780e59 100644--- a/backend/internal/services/environment_service.go+++ b/backend/internal/services/environment_service.go@@ -6,6 +6,7 @@ import ("errors""fmt""io"+ "log/slog""net/http""net/url""path"@@ -16,6 +17,7 @@ import ("github.com/ofkm/arcane-backend/internal/database""github.com/ofkm/arcane-backend/internal/dto""github.com/ofkm/arcane-backend/internal/models"+ "github.com/ofkm/arcane-backend/internal/utils""github.com/ofkm/arcane-backend/internal/utils/pagination""gorm.io/gorm")@@ -322,3 +324,38 @@ func (s *EnvironmentService) BuildRemoteWSTarget(environment *models.Environmenth := s.BuildWSAuthHeadersFromRequest(req, agentToken)return base.String(), h, nil}++func (s *EnvironmentService) GetDB() *database.DB {+ return s.db+}++func (s *EnvironmentService) GetEnabledRegistryCredentials(ctx context.Context) ([]dto.ContainerRegistryCredential, error) {+ var registries []models.ContainerRegistry+ if err := s.db.WithContext(ctx).Where("enabled = ?", true).Find(®istries).Error; err != nil {+ return nil, fmt.Errorf("failed to get enabled container registries: %w", err)+ }++ var creds []dto.ContainerRegistryCredential+ for _, reg := range registries {+ if !reg.Enabled || reg.Username == "" || reg.Token == "" {+ continue+ }++ decryptedToken, err := utils.Decrypt(reg.Token)+ if err != nil {+ slog.WarnContext(ctx, "Failed to decrypt registry token",+ slog.String("registryURL", reg.URL),+ slog.String("error", err.Error()))+ continue+ }++ creds = append(creds, dto.ContainerRegistryCredential{+ URL: reg.URL,+ Username: reg.Username,+ Token: decryptedToken,+ Enabled: reg.Enabled,+ })+ }++ return creds, nil+}diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.goindex abf45239d..cd41ae21b 100644--- a/backend/internal/services/image_service.go+++ b/backend/internal/services/image_service.go@@ -97,23 +97,31 @@ func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool, ureturn nil}-func (s *ImageService) PullImage(ctx context.Context, imageName string, progressWriter io.Writer, user models.User) error {+func (s *ImageService) PullImage(ctx context.Context, imageName string, progressWriter io.Writer, user models.User, externalCreds []dto.ContainerRegistryCredential) error {dockerClient, err := s.dockerService.CreateConnection(ctx)if err != nil {return fmt.Errorf("failed to connect to Docker: %w", err)}defer dockerClient.Close()- slog.Debug("attempting to pull image", slog.String("image", imageName))+ slog.DebugContext(ctx, "Attempting to pull image",+ slog.String("image", imageName),+ slog.Int("externalCredCount", len(externalCreds)))- pullOptions, err := s.getPullOptionsWithAuth(ctx, imageName)+ pullOptions, err := s.getPullOptionsWithAuth(ctx, imageName, externalCreds)if err != nil {- slog.Warn("failed to get registry authentication for image; proceeding without auth", slog.String("image", imageName), slog.Any("err", err))+ slog.WarnContext(ctx, "Failed to get registry authentication for image; proceeding without auth",+ slog.String("image", imageName),+ slog.String("error", err.Error()))pullOptions = image.PullOptions{}}reader, err := dockerClient.ImagePull(ctx, imageName, pullOptions)if err != nil {+ slog.ErrorContext(ctx, "Docker ImagePull failed",+ slog.String("image", imageName),+ slog.Bool("hasAuth", pullOptions.RegistryAuth != ""),+ slog.String("error", err.Error()))return fmt.Errorf("failed to initiate image pull for %s: %w", imageName, err)}defer reader.Close()@@ -155,15 +163,43 @@ func (s *ImageService) PullImage(ctx context.Context, imageName string, progressreturn nil}-func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef string) (image.PullOptions, error) {+func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef string, externalCreds []dto.ContainerRegistryCredential) (image.PullOptions, error) {pullOptions := image.PullOptions{}+ registryHost := s.extractRegistryHost(imageRef)++ if len(externalCreds) > 0 {+ for _, cred := range externalCreds {+ if !cred.Enabled || cred.Username == "" || cred.Token == "" {+ continue+ }++ credHost := s.normalizeRegistryForComparison(cred.URL)+ if credHost == s.normalizeRegistryForComparison(registryHost) {+ authConfig := ®istry.AuthConfig{+ Username: cred.Username,+ Password: cred.Token,+ ServerAddress: s.normalizeRegistryURL(cred.URL),+ }++ authBytes, err := json.Marshal(authConfig)+ if err != nil {+ return pullOptions, fmt.Errorf("failed to marshal auth config: %w", err)+ }++ pullOptions.RegistryAuth = base64.StdEncoding.EncodeToString(authBytes)+ slog.DebugContext(ctx, "Using external credentials for image pull",+ slog.String("registry", credHost),+ slog.String("username", cred.Username))+ return pullOptions, nil+ }+ }+ }+if s.registryService == nil {return pullOptions, nil}- registryHost := s.extractRegistryHost(imageRef)-registries, err := s.registryService.GetEnabledRegistries(ctx)if err != nil {return pullOptions, fmt.Errorf("failed to get registry credentials: %w", err)@@ -187,7 +223,10 @@ func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef strireturn pullOptions, fmt.Errorf("failed to marshal auth config: %w", err)}- pullOptions.RegistryAuth = base64.URLEncoding.EncodeToString(authBytes)+ pullOptions.RegistryAuth = base64.StdEncoding.EncodeToString(authBytes)+ slog.DebugContext(ctx, "Using database credentials for image pull",+ slog.String("registry", registryHost),+ slog.String("username", reg.Username))break}}diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.goindex cca9feec4..74f27b2f7 100644--- a/backend/internal/services/image_update_service.go+++ b/backend/internal/services/image_update_service.go@@ -887,20 +887,56 @@ func (s *ImageUpdateService) parseAndGroupImages(imageRefs []string) (map[stringreturn regRepos, results, images}-func (s *ImageUpdateService) buildCredentialMap(ctx context.Context) (map[string]batchCred, []models.ContainerRegistry) {- enabledRegs, err := s.registryService.GetEnabledRegistries(ctx)- if err != nil {- slog.DebugContext(ctx, "Failed to load enabled registries", slog.String("error", err.Error()))- return map[string]batchCred{}, nil- }- credMap := make(map[string]batchCred, len(enabledRegs))+func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCreds []dto.ContainerRegistryCredential) (map[string]batchCred, []models.ContainerRegistry) {+ var enabledRegs []models.ContainerRegistry+ credMap := make(map[string]batchCred)+normalizeHost := func(u string) string {u = strings.TrimSpace(u)u = strings.TrimPrefix(u, "https://")u = strings.TrimPrefix(u, "http://")return strings.TrimSuffix(u, "/")}- for _, r := range enabledRegs {++ if len(externalCreds) > 0 {+ for _, c := range externalCreds {+ if !c.Enabled || c.Username == "" || c.Token == "" {+ continue+ }+ host := normalizeHost(c.URL)+ if host == "" {+ continue+ }+ if _, exists := credMap[host]; !exists {+ credMap[host] = batchCred{username: c.Username, token: c.Token}+ }+ encToken, encErr := utils.Encrypt(c.Token)+ if encErr != nil {+ slog.WarnContext(ctx, "Failed to encrypt external registry token",+ slog.String("registryURL", c.URL),+ slog.String("error", encErr.Error()))+ continue+ }+ enabledRegs = append(enabledRegs, models.ContainerRegistry{+ URL: c.URL,+ Username: c.Username,+ Token: encToken,+ Enabled: c.Enabled,+ })+ }+ slog.DebugContext(ctx, "Using external credentials for batch check",+ slog.Int("credentialCount", len(credMap)))+ return credMap, enabledRegs+ }++ dbRegs, err := s.registryService.GetEnabledRegistries(ctx)+ if err != nil {+ slog.DebugContext(ctx, "Failed to load enabled registries", slog.String("error", err.Error()))+ return credMap, nil+ }+ enabledRegs = dbRegs++ for _, r := range dbRegs {if r.Username == "" || r.Token == "" {continue}@@ -1063,7 +1099,7 @@ func (s *ImageUpdateService) checkSingleImageInBatch(}}-func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs []string) (map[string]*dto.ImageUpdateResponse, error) {+func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs []string, externalCreds []dto.ContainerRegistryCredential) (map[string]*dto.ImageUpdateResponse, error) {startBatch := time.Now()results := make(map[string]*dto.ImageUpdateResponse, len(imageRefs))if len(imageRefs) == 0 {@@ -1072,19 +1108,15 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefsrc := registry.NewClient()- // Parse & groupregRepos, initialResults, images := s.parseAndGroupImages(imageRefs)for k, v := range initialResults {results[k] = v}- // Credentials + enabled registry list (for challenge retries)- credMap, enabledRegs := s.buildCredentialMap(ctx)+ credMap, enabledRegs := s.buildCredentialMap(ctx, externalCreds)- // Registry auth mapregAuthMap := s.buildRegistryAuthMap(ctx, rc, regRepos, credMap)- // ConcurrencyupdateScope := s.getUpdateScope()outCh := make(chan struct {ref string@@ -1094,38 +1126,46 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefswg := sync.WaitGroup{}wg.Add(len(images))for _, img := range images {- go func() {+ go func(bi batchImage) {defer wg.Done()- res := s.checkSingleImageInBatch(ctx, rc, regAuthMap, enabledRegs, img.parts, updateScope)- // Persist- _ = s.saveUpdateResult(ctx, img.ref, res)+ res := s.checkSingleImageInBatch(ctx, rc, regAuthMap, enabledRegs, bi.parts, updateScope)outCh <- struct {ref stringres *dto.ImageUpdateResponse- }{ref: img.ref, res: res}- }()+ }{bi.ref, res}+ }(img)}-wg.Wait()close(outCh)- for it := range outCh {- results[it.ref] = it.res+ for item := range outCh {+ results[item.ref] = item.res+ if err := s.saveUpdateResult(ctx, item.ref, item.res); err != nil {+ slog.WarnContext(ctx, "Failed to save update result",+ slog.String("imageRef", item.ref),+ slog.String("error", err.Error()))+ }}- slog.DebugContext(ctx, "Batch image update check complete",- slog.Int("count", len(results)),- slog.Int64("elapsedMs", time.Since(startBatch).Milliseconds()))+ slog.InfoContext(ctx, "Batch image update check completed",+ slog.Int("totalImages", len(imageRefs)),+ slog.Int("successCount", len(results)),+ slog.Duration("duration", time.Since(startBatch)))return results, nil}-func (s *ImageUpdateService) CheckAllImages(ctx context.Context, limit int) (map[string]*dto.ImageUpdateResponse, error) {+func (s *ImageUpdateService) CheckAllImages(ctx context.Context, limit int, externalCreds []dto.ContainerRegistryCredential) (map[string]*dto.ImageUpdateResponse, error) {imageRefs, err := s.getAllImageRefs(ctx, limit)if err != nil {return nil, fmt.Errorf("failed to get image references: %w", err)}- return s.CheckMultipleImages(ctx, imageRefs)++ if len(imageRefs) == 0 {+ return make(map[string]*dto.ImageUpdateResponse), nil+ }++ return s.CheckMultipleImages(ctx, imageRefs, externalCreds)}func (s *ImageUpdateService) CleanupOrphanedRecords(ctx context.Context) error {diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.goindex 751cbc016..6f00e473d 100644--- a/backend/internal/services/project_service.go+++ b/backend/internal/services/project_service.go@@ -613,7 +613,7 @@ func (s *ProjectService) PullProjectImages(ctx context.Context, projectID string}for img := range images {- if err := s.imageService.PullImage(ctx, img, progressWriter, systemUser); err != nil {+ if err := s.imageService.PullImage(ctx, img, progressWriter, systemUser, nil); err != nil {return fmt.Errorf("failed to pull image %s: %w", img, err)}}diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.goindex 7fcb1a1e1..82bba8e3b 100644--- a/backend/internal/services/updater_service.go+++ b/backend/internal/services/updater_service.go@@ -170,7 +170,7 @@ func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (*dto.Upcontinue}- if err := s.imageService.PullImage(ctx, p.newRef, io.Discard, systemUser); err != nil {+ if err := s.imageService.PullImage(ctx, p.newRef, io.Discard, systemUser, nil); err != nil {item.Status = "failed"item.Error = err.Error()out.Failed++diff --git a/backend/internal/utils/remenv/remenv.go b/backend/internal/utils/remenv/remenv.gonew file mode 100644index 000000000..8d7cf3fe6--- /dev/null+++ b/backend/internal/utils/remenv/remenv.go@@ -0,0 +1,191 @@+package remenv++import (+ "bytes"+ "context"+ "encoding/json"+ "fmt"+ "io"+ "log/slog"+ "net/http"+ "strconv"+ "strings"++ "github.com/gin-gonic/gin"+ "github.com/ofkm/arcane-backend/internal/dto"+)++type CredentialInjector interface {+ GetEnabledRegistryCredentials(ctx context.Context) ([]dto.ContainerRegistryCredential, error)+}++func CopyRequestHeaders(from http.Header, to http.Header, skip map[string]struct{}) {+ for k, vs := range from {+ ck := http.CanonicalHeaderKey(k)+ if _, ok := skip[ck]; ok || ck == "Authorization" {+ continue+ }+ for _, v := range vs {+ to.Add(k, v)+ }+ }+}++func SetAuthHeader(req *http.Request, c *gin.Context) {+ if auth := c.GetHeader("Authorization"); auth != "" {+ req.Header.Set("Authorization", auth)+ } else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {+ req.Header.Set("Authorization", "Bearer "+cookieToken)+ }+}++func SetAgentToken(req *http.Request, accessToken *string) {+ if accessToken != nil && *accessToken != "" {+ req.Header.Set("X-Arcane-Agent-Token", *accessToken)+ }+}++func SetForwardedHeaders(req *http.Request, clientIP, host string) {+ req.Header.Set("X-Forwarded-For", clientIP)+ req.Header.Set("X-Forwarded-Host", host)+}++func GetHopByHopHeaders() map[string]struct{} {+ return map[string]struct{}{+ http.CanonicalHeaderKey("Connection"): {},+ http.CanonicalHeaderKey("Keep-Alive"): {},+ http.CanonicalHeaderKey("Proxy-Authenticate"): {},+ http.CanonicalHeaderKey("Proxy-Authorization"): {},+ http.CanonicalHeaderKey("TE"): {},+ http.CanonicalHeaderKey("Trailers"): {},+ http.CanonicalHeaderKey("Trailer"): {},+ http.CanonicalHeaderKey("Transfer-Encoding"): {},+ http.CanonicalHeaderKey("Upgrade"): {},+ }+}++func BuildHopByHopHeaders(respHeader http.Header) map[string]struct{} {+ hop := GetHopByHopHeaders()++ for _, connVal := range respHeader.Values("Connection") {+ for _, token := range strings.Split(connVal, ",") {+ if t := strings.TrimSpace(token); t != "" {+ hop[http.CanonicalHeaderKey(t)] = struct{}{}+ }+ }+ }++ return hop+}++func CopyResponseHeaders(from http.Header, to http.Header, hop map[string]struct{}) {+ for k, vs := range from {+ ck := http.CanonicalHeaderKey(k)+ if _, ok := hop[ck]; ok {+ continue+ }+ for _, v := range vs {+ to.Add(k, v)+ }+ }+}++func NeedsCredentialInjection(target string) bool {+ return strings.Contains(target, "/image-updates/check") ||+ strings.Contains(target, "/images/pull")+}++func InjectRegistryCredentials(ctx context.Context, req *http.Request, injector CredentialInjector) error {+ if injector == nil || req.Method != http.MethodPost {+ return nil+ }++ bodyBytes, err := io.ReadAll(req.Body)+ if err != nil {+ return fmt.Errorf("failed to read request body: %w", err)+ }+ req.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))++ var pullReq dto.ImagePullDto+ if err := json.Unmarshal(bodyBytes, &pullReq); err != nil {+ return injectBatchUpdateCredentials(ctx, bodyBytes, req, injector)+ }++ return injectImagePullCredentials(ctx, pullReq, req, injector)+}++func injectBatchUpdateCredentials(ctx context.Context, bodyBytes []byte, req *http.Request, injector CredentialInjector) error {+ var batchReq dto.BatchImageUpdateRequest++ if err := json.Unmarshal(bodyBytes, &batchReq); err != nil {+ return nil //nolint:nilerr+ }++ if len(batchReq.Credentials) > 0 {+ return nil+ }++ creds, err := injector.GetEnabledRegistryCredentials(ctx)+ if err != nil {+ return fmt.Errorf("failed to load registry credentials: %w", err)+ }++ if len(creds) == 0 {+ return nil+ }++ batchReq.Credentials = creds+ modifiedBody, err := json.Marshal(batchReq)+ if err != nil {+ return fmt.Errorf("failed to marshal modified request: %w", err)+ }++ updateRequestBody(req, modifiedBody)+ slog.DebugContext(ctx, "Injected registry credentials into batch update request",+ slog.Int("credentialCount", len(creds)))++ return nil+}++func injectImagePullCredentials(ctx context.Context, pullReq dto.ImagePullDto, req *http.Request, injector CredentialInjector) error {+ if len(pullReq.Credentials) > 0 {+ return nil+ }++ creds, err := injector.GetEnabledRegistryCredentials(ctx)+ if err != nil {+ return err+ }++ if len(creds) == 0 {+ return nil+ }++ pullReq.Credentials = creds+ modifiedBody, err := json.Marshal(pullReq)+ if err != nil {+ return fmt.Errorf("failed to marshal modified request: %w", err)+ }++ updateRequestBody(req, modifiedBody)+ slog.DebugContext(ctx, "Injected registry credentials into image pull request",+ slog.Int("credentialCount", len(creds)),+ slog.String("imageName", pullReq.ImageName))++ return nil+}++func updateRequestBody(req *http.Request, body []byte) {+ req.Body = io.NopCloser(bytes.NewBuffer(body))+ req.ContentLength = int64(len(body))+ req.Header.Set("Content-Length", strconv.Itoa(len(body)))+}++func GetSkipHeaders() map[string]struct{} {+ return map[string]struct{}{+ "Host": {}, "Connection": {}, "Keep-Alive": {}, "Proxy-Authenticate": {},+ "Proxy-Authorization": {}, "Te": {}, "Trailer": {}, "Transfer-Encoding": {},+ "Upgrade": {}, "Content-Length": {}, "Origin": {}, "Referer": {},+ "Access-Control-Request-Method": {}, "Access-Control-Request-Headers": {}, "Cookie": {},+ }+}diff --git a/frontend/src/lib/components/sheets/image-pull-sheet.svelte b/frontend/src/lib/components/sheets/image-pull-sheet.svelteindex df1972ebe..282b1d510 100644--- a/frontend/src/lib/components/sheets/image-pull-sheet.svelte+++ b/frontend/src/lib/components/sheets/image-pull-sheet.svelte@@ -104,12 +104,15 @@if (!response.ok || !response.body) {const errorData = await response.json().catch(() => ({- error: m.images_pull_server_error()+ data: { message: m.images_pull_server_error() }}));+const errorMessage =- typeof errorData.error === 'string'- ? errorData.error- : errorData.message || `${m.images_pull_server_error()}: HTTP ${response.status}`;+ errorData.data?.message ||+ errorData.error ||+ errorData.message ||+ `${m.images_pull_server_error()}: HTTP ${response.status}`;+throw new Error(errorMessage);}