Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
chore: fix go lint issues (#312)
Kyle Mendellc2b09924fcd0
diff --git a/backend/frontend/frontend.go b/backend/frontend/frontend.goindex 165aa9692..eca716424 100644--- a/backend/frontend/frontend.go+++ b/backend/frontend/frontend.go@@ -52,7 +52,6 @@ func RegisterFrontend(router *gin.Engine) error {if _, err := fs.Stat(distFS, requestedPath); os.IsNotExist(err) {c.Request.URL.Path = "/"- requestedPath = "index.html"}fileServer.ServeHTTP(c.Writer, c.Request)diff --git a/backend/internal/api/auth_handler.go b/backend/internal/api/auth_handler.goindex 72564fa6b..10f4d0cef 100644--- a/backend/internal/api/auth_handler.go+++ b/backend/internal/api/auth_handler.go@@ -1,6 +1,7 @@package apiimport (+ "errors""net/http""time"@@ -70,7 +71,6 @@ func (h *AuthHandler) Login(c *gin.Context) {return}- // Check if local auth is enabledlocalAuthEnabled, err := h.authService.IsLocalAuthEnabled(c.Request.Context())if err != nil {c.JSON(http.StatusInternalServerError, LoginResponse{@@ -88,11 +88,10 @@ func (h *AuthHandler) Login(c *gin.Context) {return}- // Authenticate useruser, tokenPair, err := h.authService.Login(c.Request.Context(), req.Username, req.Password)// Handle password change required- if err == services.ErrPasswordChangeRequired && user != nil {+ if errors.Is(err, services.ErrPasswordChangeRequired) && user != nil {c.JSON(http.StatusOK, LoginResponse{Success: true,RequirePasswordChange: true,@@ -112,11 +111,11 @@ func (h *AuthHandler) Login(c *gin.Context) {var statusCode intvar errorMsg string- switch err {- case services.ErrInvalidCredentials:+ switch {+ case errors.Is(err, services.ErrInvalidCredentials):statusCode = http.StatusUnauthorizederrorMsg = "Invalid username or password"- case services.ErrLocalAuthDisabled:+ case errors.Is(err, services.ErrLocalAuthDisabled):statusCode = http.StatusBadRequesterrorMsg = "Local authentication is disabled"default:@@ -222,8 +221,8 @@ func (h *AuthHandler) RefreshToken(c *gin.Context) {var statusCode intvar errorMsg string- switch err {- case services.ErrInvalidToken, services.ErrExpiredToken:+ switch {+ case errors.Is(err, services.ErrInvalidToken), errors.Is(err, services.ErrExpiredToken):statusCode = http.StatusUnauthorizederrorMsg = "Invalid or expired refresh token"default:@@ -296,8 +295,8 @@ func (h *AuthHandler) ChangePassword(c *gin.Context) {var statusCode intvar errorMsg string- switch err {- case services.ErrInvalidCredentials:+ switch {+ case errors.Is(err, services.ErrInvalidCredentials):statusCode = http.StatusUnauthorizederrorMsg = "Current password is incorrect"default:diff --git a/backend/internal/api/environment_handler.go b/backend/internal/api/environment_handler.goindex 79244b48b..26a1a4f53 100644--- a/backend/internal/api/environment_handler.go+++ b/backend/internal/api/environment_handler.go@@ -55,143 +55,192 @@ func (h *EnvironmentHandler) routeRequest(c *gin.Context, endpoint string) {}func (h *EnvironmentHandler) handleLocalRequest(c *gin.Context, endpoint string) {+ if h.handleContainerEndpoints(c, endpoint) {+ return+ }+ if h.handleImageEndpoints(c, endpoint) {+ return+ }+ if h.handleNetworkEndpoints(c, endpoint) {+ return+ }+ if h.handleVolumeEndpoints(c, endpoint) {+ return+ }+ if h.handleStackEndpoints(c, endpoint) {+ return+ }++ c.JSON(http.StatusNotFound, gin.H{+ "success": false,+ "error": "Endpoint not found",+ })+}++func (h *EnvironmentHandler) handleContainerEndpoints(c *gin.Context, endpoint string) bool {+ containerHandler := NewContainerHandler(h.containerService, h.imageService)+switch {- case endpoint == "/containers" && c.Request.Method == "GET":- containerHandler := NewContainerHandler(h.containerService, h.imageService)+ case endpoint == "/containers" && c.Request.Method == http.MethodGet:containerHandler.List(c)- case endpoint == "/containers" && c.Request.Method == "POST":- containerHandler := NewContainerHandler(h.containerService, h.imageService)+ return true+ case endpoint == "/containers" && c.Request.Method == http.MethodPost:containerHandler.Create(c)+ return truecase strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/start"):- containerHandler := NewContainerHandler(h.containerService, h.imageService)containerHandler.Start(c)+ return truecase strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/stop"):- containerHandler := NewContainerHandler(h.containerService, h.imageService)containerHandler.Stop(c)+ return truecase strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/restart"):- containerHandler := NewContainerHandler(h.containerService, h.imageService)containerHandler.Restart(c)+ return truecase strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/pull"):- containerHandler := NewContainerHandler(h.containerService, h.imageService)containerHandler.PullImage(c)+ return truecase strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/logs"):- containerHandler := NewContainerHandler(h.containerService, h.imageService)containerHandler.GetLogs(c)+ return truecase strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/stats/stream"):- containerHandler := NewContainerHandler(h.containerService, h.imageService)containerHandler.GetStatsStream(c)+ return truecase strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/stats"):- containerHandler := NewContainerHandler(h.containerService, h.imageService)containerHandler.GetStats(c)- case strings.HasPrefix(endpoint, "/containers/") && c.Request.Method == "GET":- containerHandler := NewContainerHandler(h.containerService, h.imageService)+ return true+ case strings.HasPrefix(endpoint, "/containers/") && c.Request.Method == http.MethodGet:containerHandler.GetByID(c)- case strings.HasPrefix(endpoint, "/containers/") && c.Request.Method == "DELETE":- containerHandler := NewContainerHandler(h.containerService, h.imageService)+ return true+ case strings.HasPrefix(endpoint, "/containers/") && c.Request.Method == http.MethodDelete:containerHandler.Delete(c)+ return true+ }+ return false+}++func (h *EnvironmentHandler) handleImageEndpoints(c *gin.Context, endpoint string) bool {+ imageHandler := NewImageHandler(h.imageService, nil)- case endpoint == "/images" && c.Request.Method == "GET":- imageHandler := NewImageHandler(h.imageService, nil)+ switch {+ case endpoint == "/images" && c.Request.Method == http.MethodGet:imageHandler.List(c)- case endpoint == "/images/pull" && c.Request.Method == "POST":- imageHandler := NewImageHandler(h.imageService, nil)+ return true+ case endpoint == "/images/pull" && c.Request.Method == http.MethodPost:imageHandler.Pull(c)- case endpoint == "/images/prune" && c.Request.Method == "POST":- imageHandler := NewImageHandler(h.imageService, nil)+ return true+ case endpoint == "/images/prune" && c.Request.Method == http.MethodPost:imageHandler.Prune(c)- case strings.HasPrefix(endpoint, "/images/") && c.Request.Method == "GET":- imageHandler := NewImageHandler(h.imageService, nil)+ return true+ case strings.HasPrefix(endpoint, "/images/") && c.Request.Method == http.MethodGet:imageHandler.GetByID(c)- case strings.HasPrefix(endpoint, "/images/") && c.Request.Method == "DELETE":- imageHandler := NewImageHandler(h.imageService, nil)+ return true+ case strings.HasPrefix(endpoint, "/images/") && c.Request.Method == http.MethodDelete:imageHandler.Remove(c)+ return true+ }+ return false+}++func (h *EnvironmentHandler) handleNetworkEndpoints(c *gin.Context, endpoint string) bool {+ networkHandler := NewNetworkHandler(h.networkService)- case endpoint == "/networks" && c.Request.Method == "GET":- networkHandler := NewNetworkHandler(h.networkService)+ switch {+ case endpoint == "/networks" && c.Request.Method == http.MethodGet:networkHandler.List(c)- case endpoint == "/networks" && c.Request.Method == "POST":- networkHandler := NewNetworkHandler(h.networkService)+ return true+ case endpoint == "/networks" && c.Request.Method == http.MethodPost:networkHandler.Create(c)- case strings.HasPrefix(endpoint, "/networks/") && c.Request.Method == "GET":- networkHandler := NewNetworkHandler(h.networkService)+ return true+ case strings.HasPrefix(endpoint, "/networks/") && c.Request.Method == http.MethodGet:networkHandler.GetByID(c)- case strings.HasPrefix(endpoint, "/networks/") && c.Request.Method == "DELETE":- networkHandler := NewNetworkHandler(h.networkService)+ return true+ case strings.HasPrefix(endpoint, "/networks/") && c.Request.Method == http.MethodDelete:networkHandler.Remove(c)+ return true+ }+ return false+}- case endpoint == "/volumes" && c.Request.Method == "GET":- volumeHandler := NewVolumeHandler(h.volumeService)+func (h *EnvironmentHandler) handleVolumeEndpoints(c *gin.Context, endpoint string) bool {+ volumeHandler := NewVolumeHandler(h.volumeService)++ switch {+ case endpoint == "/volumes" && c.Request.Method == http.MethodGet:volumeHandler.List(c)- case endpoint == "/volumes" && c.Request.Method == "POST":- volumeHandler := NewVolumeHandler(h.volumeService)+ return true+ case endpoint == "/volumes" && c.Request.Method == http.MethodPost:volumeHandler.Create(c)- case endpoint == "/volumes/prune" && c.Request.Method == "POST":- volumeHandler := NewVolumeHandler(h.volumeService)+ return true+ case endpoint == "/volumes/prune" && c.Request.Method == http.MethodPost:volumeHandler.Prune(c)- case strings.HasPrefix(endpoint, "/volumes/") && c.Request.Method == "GET":- volumeHandler := NewVolumeHandler(h.volumeService)- volumeHandler.GetByName(c)- case strings.HasPrefix(endpoint, "/volumes/") && c.Request.Method == "DELETE":- volumeHandler := NewVolumeHandler(h.volumeService)- volumeHandler.Remove(c)+ return truecase strings.HasPrefix(endpoint, "/volumes/") && strings.HasSuffix(endpoint, "/usage"):- volumeHandler := NewVolumeHandler(h.volumeService)volumeHandler.GetUsage(c)+ return true+ case strings.HasPrefix(endpoint, "/volumes/") && c.Request.Method == http.MethodGet:+ volumeHandler.GetByName(c)+ return true+ case strings.HasPrefix(endpoint, "/volumes/") && c.Request.Method == http.MethodDelete:+ volumeHandler.Remove(c)+ return true+ }+ return false+}- case endpoint == "/stacks" && c.Request.Method == "GET":- stackHandler := NewStackHandler(h.stackService)+func (h *EnvironmentHandler) handleStackEndpoints(c *gin.Context, endpoint string) bool {+ stackHandler := NewStackHandler(h.stackService)++ switch {+ case endpoint == "/stacks" && c.Request.Method == http.MethodGet:stackHandler.ListStacks(c)- case endpoint == "/stacks" && c.Request.Method == "POST":- stackHandler := NewStackHandler(h.stackService)+ return true+ case endpoint == "/stacks" && c.Request.Method == http.MethodPost:stackHandler.CreateStack(c)+ return true+ case endpoint == "/stacks/convert" && c.Request.Method == http.MethodPost:+ stackHandler.ConvertDockerRun(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/deploy"):- stackHandler := NewStackHandler(h.stackService)stackHandler.DeployStack(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/start"):- stackHandler := NewStackHandler(h.stackService)stackHandler.StartStack(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/stop"):- stackHandler := NewStackHandler(h.stackService)stackHandler.StopStack(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/restart"):- stackHandler := NewStackHandler(h.stackService)stackHandler.RestartStack(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/services"):- stackHandler := NewStackHandler(h.stackService)stackHandler.GetStackServices(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/pull"):- stackHandler := NewStackHandler(h.stackService)stackHandler.PullImages(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/redeploy"):- stackHandler := NewStackHandler(h.stackService)stackHandler.RedeployStack(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/down"):- stackHandler := NewStackHandler(h.stackService)stackHandler.DownStack(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/destroy"):- stackHandler := NewStackHandler(h.stackService)stackHandler.DestroyStack(c)+ return truecase strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/logs/stream"):- stackHandler := NewStackHandler(h.stackService)stackHandler.GetStackLogsStream(c)- case endpoint == "/stacks/convert" && c.Request.Method == "POST":- stackHandler := NewStackHandler(h.stackService)- stackHandler.ConvertDockerRun(c)- case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == "GET":- stackHandler := NewStackHandler(h.stackService)+ return true+ case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == http.MethodGet:stackHandler.GetStack(c)- case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == "PUT":- stackHandler := NewStackHandler(h.stackService)+ return true+ case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == http.MethodPut:stackHandler.UpdateStack(c)- case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == "DELETE":- stackHandler := NewStackHandler(h.stackService)+ return true+ case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == http.MethodDelete:stackHandler.DeleteStack(c)- default:- c.JSON(http.StatusNotFound, gin.H{- "success": false,- "error": "Endpoint not found",- })+ return true}+ return false}func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID string, endpoint string) {@@ -223,7 +272,7 @@ func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID s}}- req, err := http.NewRequest(c.Request.Method, url, reqBody)+ req, err := http.NewRequestWithContext(c.Request.Context(), c.Request.Method, url, reqBody)if err != nil {c.JSON(http.StatusInternalServerError, gin.H{"success": false,@@ -271,7 +320,7 @@ func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID sresp, err := client.Do(req)if err != nil {- h.environmentService.UpdateEnvironmentStatus(c.Request.Context(), environmentID, "offline")+ _ = h.environmentService.UpdateEnvironmentStatus(c.Request.Context(), environmentID, "offline")c.JSON(http.StatusServiceUnavailable, gin.H{"success": false,"error": fmt.Sprintf("Failed to connect to environment: %v", err),@@ -280,7 +329,7 @@ func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID s}defer resp.Body.Close()- h.environmentService.UpdateEnvironmentHeartbeat(c.Request.Context(), environmentID)+ _ = h.environmentService.UpdateEnvironmentHeartbeat(c.Request.Context(), environmentID)responseBody, err := io.ReadAll(resp.Body)if err != nil {@@ -298,7 +347,7 @@ func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID s}c.Status(resp.StatusCode)- c.Writer.Write(responseBody)+ _, _ = c.Writer.Write(responseBody)}func (h *EnvironmentHandler) CreateEnvironment(c *gin.Context) {@@ -512,7 +561,7 @@ func (h *EnvironmentHandler) CreateStack(c *gin.Context) {h.routeRequest(c, "/stacks")}-//Containers+// Containersfunc (h *EnvironmentHandler) GetContainer(c *gin.Context) {containerID := c.Param("containerId")@@ -565,7 +614,7 @@ func (h *EnvironmentHandler) GetContainerStatsStream(c *gin.Context) {// End Containers-//Images+// Imagesfunc (h *EnvironmentHandler) GetImage(c *gin.Context) {imageID := c.Param("imageId")@@ -585,7 +634,7 @@ func (h *EnvironmentHandler) PruneImages(c *gin.Context) {h.routeRequest(c, "/images/prune")}-//End Images+// End Imagesfunc (h *EnvironmentHandler) GetNetwork(c *gin.Context) {networkID := c.Param("networkId")diff --git a/backend/internal/api/image_handler.go b/backend/internal/api/image_handler.goindex 463ab3b9e..d3c6d7819 100644--- a/backend/internal/api/image_handler.go+++ b/backend/internal/api/image_handler.go@@ -57,24 +57,22 @@ func (h *ImageHandler) List(c *gin.Context) {"version": img.MaturityRecord.CurrentVersion,"date": img.MaturityRecord.CurrentImageDate,}- } else {- if len(img.RepoTags) > 0 && img.RepoTags[0] != "<none>:<none>" && img.Repo != "<none>" && h.imageMaturityService != nil {- go func(imageID string, repo string, tag string, createdTime time.Time) {- maturityData, checkErr := h.imageMaturityService.CheckImageInRegistry(context.Background(), repo, tag, imageID)- if checkErr == nil {- setErr := h.imageMaturityService.SetImageMaturity(context.Background(), imageID, repo, tag, *maturityData, map[string]interface{}{- "registryDomain": utils.ExtractRegistryDomain(repo),- "isPrivateRegistry": utils.IsPrivateRegistry(repo),- "currentImageDate": createdTime,- })- if setErr != nil {- fmt.Printf("Error setting image maturity for %s: %v\n", imageID, setErr)- }- } else {- fmt.Printf("Error checking image maturity for %s (%s:%s): %v\n", imageID, repo, tag, checkErr)+ } else if len(img.RepoTags) > 0 && img.RepoTags[0] != "<none>:<none>" && img.Repo != "<none>" && h.imageMaturityService != nil {+ go func(imageID string, repo string, tag string, createdTime time.Time) {+ maturityData, checkErr := h.imageMaturityService.CheckImageInRegistry(context.Background(), repo, tag, imageID)+ if checkErr == nil {+ setErr := h.imageMaturityService.SetImageMaturity(context.Background(), imageID, repo, tag, *maturityData, map[string]interface{}{+ "registryDomain": utils.ExtractRegistryDomain(repo),+ "isPrivateRegistry": utils.IsPrivateRegistry(repo),+ "currentImageDate": createdTime,+ })+ if setErr != nil {+ fmt.Printf("Error setting image maturity for %s: %v\n", imageID, setErr)}- }(img.ID, img.Repo, img.Tag, img.Created)- }+ } else {+ fmt.Printf("Error checking image maturity for %s (%s:%s): %v\n", imageID, repo, tag, checkErr)+ }+ }(img.ID, img.Repo, img.Tag, img.Created)}result = append(result, imageData)}@@ -279,12 +277,17 @@ func (h *ImageHandler) CheckMaturity(c *gin.Context) {return}- err = h.imageMaturityService.SetImageMaturity(c.Request.Context(), imageID, repo, tag, *maturityData, map[string]interface{}{+ errSet := h.imageMaturityService.SetImageMaturity(c.Request.Context(), imageID, repo, tag, *maturityData, map[string]interface{}{"registryDomain": utils.ExtractRegistryDomain(repo),"isPrivateRegistry": utils.IsPrivateRegistry(repo),"currentImageDate": time.Unix(targetImage.Created, 0),})- if err != nil {+ if errSet != nil {+ c.JSON(http.StatusInternalServerError, gin.H{+ "success": false,+ "error": "Failed to set image maturity: " + errSet.Error(),+ })+ return}c.JSON(http.StatusOK, gin.H{diff --git a/backend/internal/api/system_handler.go b/backend/internal/api/system_handler.goindex d870dc37c..fa794fbe5 100644--- a/backend/internal/api/system_handler.go+++ b/backend/internal/api/system_handler.go@@ -251,7 +251,7 @@ func (h *SystemHandler) PruneAll(c *gin.Context) {slog.Int("images_deleted", len(result.ImagesDeleted)),slog.Int("volumes_deleted", len(result.VolumesDeleted)),slog.Int("networks_deleted", len(result.NetworksDeleted)),- slog.Int64("space_reclaimed", result.SpaceReclaimed),+ slog.Uint64("space_reclaimed", result.SpaceReclaimed),slog.Bool("success", result.Success),slog.Int("error_count", len(result.Errors)))diff --git a/backend/internal/api/template_handler.go b/backend/internal/api/template_handler.goindex b05be7519..525a95269 100644--- a/backend/internal/api/template_handler.go+++ b/backend/internal/api/template_handler.go@@ -440,7 +440,7 @@ func (h *TemplateHandler) FetchRegistry(c *gin.Context) {Timeout: 30 * time.Second,}- req, err := http.NewRequest("GET", url, nil)+ req, err := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, url, nil)if err != nil {c.JSON(http.StatusBadRequest, gin.H{"success": false,diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.goindex f8fd368f4..5a147f0e1 100644--- a/backend/internal/bootstrap/bootstrap.go+++ b/backend/internal/bootstrap/bootstrap.go@@ -77,7 +77,9 @@ func InitializeApp() (*App, error) {log.Println("Initial Docker image synchronization complete.")}- appServices.User.CreateDefaultAdmin()+ if err := appServices.User.CreateDefaultAdmin(); err != nil {+ log.Printf("Warning: failed to create default admin user: %v", err)+ }if cfg.PublicOidcEnabled {if err := appServices.Auth.SyncOidcEnvToDatabase(context.Background()); err != nil {@@ -113,8 +115,9 @@ func (app *App) Start() {}()srv := &http.Server{- Addr: ":" + app.Config.Port,- Handler: app.Router,+ Addr: ":" + app.Config.Port,+ Handler: app.Router,+ ReadHeaderTimeout: 5 * time.Second,}go func() {@@ -135,7 +138,7 @@ func (app *App) Start() {defer cancelShutdown()if err := srv.Shutdown(shutdownCtx); err != nil {- log.Fatalf("Server forced to shutdown: %v", err)+ log.Printf("Server forced to shutdown: %v", err)}log.Println("Server exiting")diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.goindex e2ec9293d..553f599e0 100644--- a/backend/internal/bootstrap/router_bootstrap.go+++ b/backend/internal/bootstrap/router_bootstrap.go@@ -32,7 +32,7 @@ func setupRouter(cfg *config.Config, appServices *api.Services) *gin.Engine {api.SetupRoutes(router, appServices, cfg)if err := frontend.RegisterFrontend(router); err != nil {- gin.DefaultErrorWriter.Write([]byte("Failed to register frontend: " + err.Error() + "\n"))+ _, _ = gin.DefaultErrorWriter.Write([]byte("Failed to register frontend: " + err.Error() + "\n"))}return routerdiff --git a/backend/internal/database/database.go b/backend/internal/database/database.goindex eb5e1148d..09c57ac70 100644--- a/backend/internal/database/database.go+++ b/backend/internal/database/database.go@@ -22,18 +22,16 @@ type DB struct {func Initialize(databaseURL string, environment string) (*DB, error) {var dialector gorm.Dialector- if strings.HasPrefix(databaseURL, "sqlite://") || strings.HasPrefix(databaseURL, "sqlite3://") {- // Handle both sqlite:// and sqlite3:// prefixes- dbPath := databaseURL- if strings.HasPrefix(databaseURL, "sqlite://") {- dbPath = strings.TrimPrefix(databaseURL, "sqlite://")- } else if strings.HasPrefix(databaseURL, "sqlite3://") {- dbPath = strings.TrimPrefix(databaseURL, "sqlite3://")- }+ switch {+ case strings.HasPrefix(databaseURL, "sqlite://"):+ dbPath := strings.TrimPrefix(databaseURL, "sqlite://")dialector = sqlite.Open(dbPath)- } else if strings.HasPrefix(databaseURL, "postgres") {+ case strings.HasPrefix(databaseURL, "sqlite3://"):+ dbPath := strings.TrimPrefix(databaseURL, "sqlite3://")+ dialector = sqlite.Open(dbPath)+ case strings.HasPrefix(databaseURL, "postgres"):dialector = postgres.Open(databaseURL)- } else {+ default:return nil, fmt.Errorf("unsupported database type in URL: %s", databaseURL)}diff --git a/backend/internal/job/job.go b/backend/internal/job/job.goindex b21212f2b..ed78e8c36 100644--- a/backend/internal/job/job.go+++ b/backend/internal/job/job.go@@ -9,12 +9,10 @@ import ("github.com/google/uuid")-// Scheduler manages jobs using gocron.type Scheduler struct {scheduler gocron.Scheduler}-// NewScheduler creates and returns a new Scheduler.func NewScheduler() (*Scheduler, error) {s, err := gocron.NewScheduler()if err != nil {@@ -23,8 +21,6 @@ func NewScheduler() (*Scheduler, error) {return &Scheduler{scheduler: s}, nil}-// Run starts the scheduler and blocks until the context is canceled.-// It handles the graceful shutdown of the scheduler.func (s *Scheduler) Run(ctx context.Context) error {slog.Info("Starting job scheduler")s.scheduler.Start() // Start the scheduler, non-blocking@@ -43,8 +39,6 @@ func (s *Scheduler) Run(ctx context.Context) error {return nil}-// RegisterJob adds a new job to the scheduler with specified definition, task, and options.-// It includes logging for job lifecycle events.func (s *Scheduler) RegisterJob(ctx context.Context,name string,@@ -53,11 +47,11 @@ func (s *Scheduler) RegisterJob(runImmediately bool,) error {jobOptions := []gocron.JobOption{- gocron.WithContext(ctx), // Associates the job with a context+ gocron.WithContext(ctx),gocron.WithEventListeners(gocron.BeforeJobRuns(func(jobID uuid.UUID, jobName string) {slog.Info("Job starting",- slog.String("name", name), // Use the provided name for clarity+ slog.String("name", name),slog.String("id", jobID.String()),)}),@@ -77,17 +71,8 @@ func (s *Scheduler) RegisterJob(),}- // Create the gocron tasktask := gocron.NewTask(func() {- // The task function passed to gocron.NewTask should not return an error directly.- // Errors should be handled within the taskFunc or will be caught by AfterJobRunsWithError.- // We pass a new context to the taskFunc to ensure it has its own lifecycle if needed,- // though gocron.WithContext already associates one.- jobCtx := context.Background() // Or derive from the initial ctx if appropriate- if err := taskFunc(jobCtx); err != nil {- // This error won't be directly caught by gocron's error handling for the task itself,- // but AfterJobRunsWithError will catch panics or errors returned by the job's execution logic.- // It's good practice to log it here if taskFunc can return errors.+ if err := taskFunc(ctx); err != nil {slog.Error("Error executing task function",slog.String("name", name),slog.Any("error", err),diff --git a/backend/internal/models/base.go b/backend/internal/models/base.goindex 0f9e762ea..767224f65 100644--- a/backend/internal/models/base.go+++ b/backend/internal/models/base.go@@ -16,11 +16,11 @@ type BaseModel struct {// JSON type for handling JSON columnstype JSON map[string]interface{}-func (j JSON) Value() (driver.Value, error) {- if j == nil {+func (j *JSON) Value() (driver.Value, error) {+ if *j == nil {return nil, nil}- return json.Marshal(j)+ return json.Marshal(*j)}func (j *JSON) Scan(value interface{}) error {@@ -45,11 +45,11 @@ func (j *JSON) Scan(value interface{}) error {// StringSlice for handling []string columnstype StringSlice []string-func (s StringSlice) Value() (driver.Value, error) {- if s == nil {+func (s *StringSlice) Value() (driver.Value, error) {+ if *s == nil {return nil, nil}- return json.Marshal(s)+ return json.Marshal(*s)}func (s *StringSlice) Scan(value interface{}) error {diff --git a/backend/internal/models/docker.go b/backend/internal/models/docker.goindex 1c9fa86cc..c1bfdb07b 100644--- a/backend/internal/models/docker.go+++ b/backend/internal/models/docker.go@@ -89,7 +89,7 @@ type Image struct {BaseModel}-func (Image) TableName() string {+func (i *Image) TableName() string {return "images_table"}diff --git a/backend/internal/models/errors.go b/backend/internal/models/errors.goindex 1196b938d..bc1723fb3 100644--- a/backend/internal/models/errors.go+++ b/backend/internal/models/errors.go@@ -1,6 +1,9 @@package models-import "net/http"+import (+ "errors"+ "net/http"+)type APIErrorCode string@@ -141,18 +144,25 @@ func (e *ValidationError) Error() string {// Helper function to convert any error to APIErrorfunc ToAPIError(err error) *APIError {- switch e := err.(type) {- case *APIError:- return e- case *NotFoundError:- return NewNotFoundError(e.Message)- case *ConflictError:- return NewConflictError(e.Message)- case *ValidationError:- return NewValidationError(e.Message, map[string]string{"field": e.Field})- case *DockerAPIError:- return NewAPIErrorWithDetails(e.Message, APIErrorCodeDockerAPIError, e.HTTPStatus(), e.Details)- default:- return NewInternalServerError(err.Error())+ var apiErr *APIError+ if errors.As(err, &apiErr) {+ return apiErr+ }+ var notFoundErr *NotFoundError+ if errors.As(err, ¬FoundErr) {+ return NewNotFoundError(notFoundErr.Message)+ }+ var conflictErr *ConflictError+ if errors.As(err, &conflictErr) {+ return NewConflictError(conflictErr.Message)+ }+ var validationErr *ValidationError+ if errors.As(err, &validationErr) {+ return NewValidationError(validationErr.Message, map[string]string{"field": validationErr.Field})+ }+ var dockerAPIErr *DockerAPIError+ if errors.As(err, &dockerAPIErr) {+ return NewAPIErrorWithDetails(dockerAPIErr.Message, APIErrorCodeDockerAPIError, dockerAPIErr.HTTPStatus(), dockerAPIErr.Details)}+ return NewInternalServerError(err.Error())}diff --git a/backend/internal/models/image_maturity.go b/backend/internal/models/image_maturity.goindex e59bf2418..a4f170bce 100644--- a/backend/internal/models/image_maturity.go+++ b/backend/internal/models/image_maturity.go@@ -28,7 +28,7 @@ type ImageMaturityRecord struct {BaseModel}-func (ImageMaturityRecord) TableName() string {+func (i *ImageMaturityRecord) TableName() string {return "image_maturity_table"}diff --git a/backend/internal/services/auth_service.go b/backend/internal/services/auth_service.goindex 070cd2dd1..cad818317 100644--- a/backend/internal/services/auth_service.go+++ b/backend/internal/services/auth_service.go@@ -399,7 +399,7 @@ func (s *AuthService) OidcLogin(ctx context.Context, userInfo OidcUserInfo) (*mouser, err := s.userService.GetUserByOidcSubjectId(ctx, userInfo.Subject)- if err != nil && err != ErrUserNotFound {+ if err != nil && !errors.Is(err, ErrUserNotFound) {return nil, nil, err}@@ -421,11 +421,12 @@ func (s *AuthService) OidcLogin(ctx context.Context, userInfo OidcUserInfo) (*mousername := generateUsernameFromEmail(userInfo.Email, userInfo.Subject)var displayName string- if userInfo.Name != "" {+ switch {+ case userInfo.Name != "":displayName = userInfo.Name- } else if userInfo.GivenName != "" || userInfo.FamilyName != "" {+ case userInfo.GivenName != "" || userInfo.FamilyName != "":displayName = strings.TrimSpace(fmt.Sprintf("%s %s", userInfo.GivenName, userInfo.FamilyName))- } else {+ default:displayName = username}diff --git a/backend/internal/services/auto_update_service.go b/backend/internal/services/auto_update_service.goindex e2d8af724..c9a4c46e4 100644--- a/backend/internal/services/auto_update_service.go+++ b/backend/internal/services/auto_update_service.go@@ -270,6 +270,26 @@ func (s *AutoUpdateService) CheckAndUpdateStacks(ctx context.Context) (*UpdateRelog.Println("Starting stack auto-update check...")+ eligibleStacks, err := s.getEligibleStacks(ctx)+ if err != nil {+ return nil, err+ }++ result.Checked = len(eligibleStacks)+ log.Printf("Found %d stacks eligible for auto-update", len(eligibleStacks))++ s.processStackUpdates(ctx, eligibleStacks, settings, result)++ result.EndTime = time.Now()+ result.Duration = result.EndTime.Sub(result.StartTime).String()++ log.Printf("Stack auto-update completed: %d checked, %d updated, %d skipped, %d errors",+ result.Checked, result.Updated, result.Skipped, len(result.Errors))++ return result, nil+}++func (s *AutoUpdateService) getEligibleStacks(ctx context.Context) ([]models.Stack, error) {stacks, err := s.stackService.ListStacks(ctx)if err != nil {return nil, fmt.Errorf("failed to list stacks: %w", err)@@ -292,102 +312,133 @@ func (s *AutoUpdateService) CheckAndUpdateStacks(ctx context.Context) (*UpdateRe}}- result.Checked = len(eligibleStacks)- log.Printf("Found %d stacks eligible for auto-update", len(eligibleStacks))+ return eligibleStacks, nil+}+func (s *AutoUpdateService) processStackUpdates(ctx context.Context, eligibleStacks []models.Stack, settings *models.Settings, result *UpdateResult) {for _, stack := range eligibleStacks {- stackID := stack.ID- stackName := stack.Name-- s.mutex.RLock()- isUpdating := s.updatingStacks[stackID]- s.mutex.RUnlock()-- if isUpdating {- log.Printf("Stack %s is already being updated, skipping", stackName)- result.Skipped+++ if s.shouldSkipStack(stack.ID, stack.Name, result) {continue}+ s.updateSingleStack(ctx, stack, settings, result)+ }+}++func (s *AutoUpdateService) shouldSkipStack(stackID, stackName string, result *UpdateResult) bool {+ s.mutex.RLock()+ isUpdating := s.updatingStacks[stackID]+ s.mutex.RUnlock()++ if isUpdating {+ log.Printf("Stack %s is already being updated, skipping", stackName)+ result.Skipped+++ return true+ }++ return false+}++func (s *AutoUpdateService) updateSingleStack(ctx context.Context, stack models.Stack, settings *models.Settings, result *UpdateResult) {+ stackID := stack.ID+ stackName := stack.Name++ s.mutex.Lock()+ s.updatingStacks[stackID] = true+ s.mutex.Unlock()++ defer func() {s.mutex.Lock()- s.updatingStacks[stackID] = true+ delete(s.updatingStacks, stackID)s.mutex.Unlock()+ }()- func() {- defer func() {- s.mutex.Lock()- delete(s.updatingStacks, stackID)- s.mutex.Unlock()- }()+ log.Printf("Checking stack for updates: %s", stackName)- log.Printf("Checking stack for updates: %s", stackName)-- updateAvailable, err := s.checkStackForUpdate(ctx, stack, settings)- if err != nil {- log.Printf("Error checking stack %s: %v", stackName, err)- result.Errors = append(result.Errors, UpdateError{- ID: stackID,- Name: stackName,- Type: "stack",- Error: err.Error(),- })- return- }+ updateAvailable, err := s.checkStackForUpdate(ctx, stack, settings)+ if err != nil {+ log.Printf("Error checking stack %s: %v", stackName, err)+ result.Errors = append(result.Errors, UpdateError{+ ID: stackID,+ Name: stackName,+ Type: "stack",+ Error: err.Error(),+ })+ return+ }++ if updateAvailable {+ s.performStackUpdate(ctx, stack, settings, result)+ } else {+ log.Printf("Stack %s is up-to-date", stackName)+ }+}- if updateAvailable {- log.Printf("Updates available for stack %s, stopping, pulling images and redeploying...", stackName)+func (s *AutoUpdateService) performStackUpdate(ctx context.Context, stack models.Stack, settings *models.Settings, result *UpdateResult) {+ stackID := stack.ID+ stackName := stack.Name- log.Printf("Stopping stack %s...", stackName)- if err := s.stackService.StopStack(ctx, stackID); err != nil {- log.Printf("Error stopping stack %s: %v", stackName, err)- result.Errors = append(result.Errors, UpdateError{- ID: stackID,- Name: stackName,- Type: "stack",- Error: fmt.Sprintf("Failed to stop stack: %v", err),- })- return- }+ log.Printf("Updates available for stack %s, stopping, pulling images and redeploying...", stackName)- log.Printf("Pulling updated images for stack %s...", stackName)- if err := s.pullStackImages(ctx, stack, settings); err != nil {- log.Printf("Error pulling images for stack %s: %v", stackName, err)- result.Errors = append(result.Errors, UpdateError{- ID: stackID,- Name: stackName,- Type: "stack",- Error: fmt.Sprintf("Failed to pull images: %v", err),- })- return- }+ if err := s.stopStackForUpdate(ctx, stackID, stackName, result); err != nil {+ return+ }- log.Printf("Deploying stack %s with updated images...", stackName)- if err := s.stackService.DeployStack(ctx, stackID); err != nil {- log.Printf("Error redeploying stack %s: %v", stackName, err)- result.Errors = append(result.Errors, UpdateError{- ID: stackID,- Name: stackName,- Type: "stack",- Error: fmt.Sprintf("Failed to redeploy: %v", err),- })- return- }+ if err := s.pullStackImagesForUpdate(ctx, stack, settings, result); err != nil {+ return+ }- log.Printf("Successfully updated stack %s", stackName)- result.Updated++- } else {- log.Printf("Stack %s is up-to-date", stackName)- }- }()+ if err := s.redeployStackAfterUpdate(ctx, stackID, stackName, result); err != nil {+ return}- result.EndTime = time.Now()- result.Duration = result.EndTime.Sub(result.StartTime).String()+ log.Printf("Successfully updated stack %s", stackName)+ result.Updated+++}- log.Printf("Stack auto-update completed: %d checked, %d updated, %d skipped, %d errors",- result.Checked, result.Updated, result.Skipped, len(result.Errors))+func (s *AutoUpdateService) stopStackForUpdate(ctx context.Context, stackID, stackName string, result *UpdateResult) error {+ log.Printf("Stopping stack %s...", stackName)+ if err := s.stackService.StopStack(ctx, stackID); err != nil {+ log.Printf("Error stopping stack %s: %v", stackName, err)+ result.Errors = append(result.Errors, UpdateError{+ ID: stackID,+ Name: stackName,+ Type: "stack",+ Error: fmt.Sprintf("Failed to stop stack: %v", err),+ })+ return err+ }+ return nil+}- return result, nil+func (s *AutoUpdateService) pullStackImagesForUpdate(ctx context.Context, stack models.Stack, settings *models.Settings, result *UpdateResult) error {+ log.Printf("Pulling updated images for stack %s...", stack.Name)+ if err := s.pullStackImages(ctx, stack, settings); err != nil {+ log.Printf("Error pulling images for stack %s: %v", stack.Name, err)+ result.Errors = append(result.Errors, UpdateError{+ ID: stack.ID,+ Name: stack.Name,+ Type: "stack",+ Error: fmt.Sprintf("Failed to pull images: %v", err),+ })+ return err+ }+ return nil+}++func (s *AutoUpdateService) redeployStackAfterUpdate(ctx context.Context, stackID, stackName string, result *UpdateResult) error {+ log.Printf("Deploying stack %s with updated images...", stackName)+ if err := s.stackService.DeployStack(ctx, stackID); err != nil {+ log.Printf("Error redeploying stack %s: %v", stackName, err)+ result.Errors = append(result.Errors, UpdateError{+ ID: stackID,+ Name: stackName,+ Type: "stack",+ Error: fmt.Sprintf("Failed to redeploy: %v", err),+ })+ return err+ }+ return nil}// pullStackImages pulls all images for a stack before redeployment@@ -463,15 +514,16 @@ func (s *AutoUpdateService) pullImageWithAuth(ctx context.Context, imageRef strireader, err := dockerClient.ImagePull(ctx, imageRef, pullOptions)if err != nil {- if strings.Contains(err.Error(), "not found") {+ switch {+ case strings.Contains(err.Error(), "not found"):return fmt.Errorf("image not found: %s - please verify the image exists and you have access", imageRef)- } else if strings.Contains(err.Error(), "unauthorized") {+ case strings.Contains(err.Error(), "unauthorized"):return fmt.Errorf("authentication failed for %s - please verify your credentials", imageRef)- } else if strings.Contains(err.Error(), "denied") {+ case strings.Contains(err.Error(), "denied"):return fmt.Errorf("access denied for %s - please verify your permissions", imageRef)+ default:+ return fmt.Errorf("failed to pull image %s: %w", imageRef, err)}-- return fmt.Errorf("failed to pull image %s: %w", imageRef, err)}defer reader.Close()diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.goindex ab4e852c2..38b7439ed 100644--- a/backend/internal/services/container_service.go+++ b/backend/internal/services/container_service.go@@ -4,6 +4,7 @@ import ("bufio""context""encoding/json"+ "errors""fmt""io""strings"@@ -218,7 +219,7 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containe}if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {- dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})return nil, fmt.Errorf("failed to start container: %w", err)}@@ -334,8 +335,7 @@ func (s *ContainerService) streamMultiplexedLogs(ctx context.Context, logs io.Redefer stdoutWriter.Close()defer stderrWriter.Close()_, err := stdcopy.StdCopy(stdoutWriter, stderrWriter, logs)- if err != nil && err != io.EOF {- // Log error but don't stop the stream+ if err != nil && !errors.Is(err, io.EOF) {fmt.Printf("Error demultiplexing logs: %v\n", err)}}()@@ -358,7 +358,7 @@ func (s *ContainerService) streamMultiplexedLogs(ctx context.Context, logs io.Recase <-ctx.Done():return ctx.Err()case err := <-done:- if err != nil && err != io.EOF {+ if err != nil && !errors.Is(err, io.EOF) {return err}// Wait for the other goroutine or context cancellation@@ -406,7 +406,7 @@ func (s *ContainerService) readAllLogs(logs io.ReadCloser, logsChan chan<- strinstderrBuf := &strings.Builder{}_, err := stdcopy.StdCopy(stdoutBuf, stderrBuf, logs)- if err != nil && err != io.EOF {+ if err != nil && !errors.Is(err, io.EOF) {return fmt.Errorf("failed to demultiplex logs: %w", err)}diff --git a/backend/internal/services/converter_service.go b/backend/internal/services/converter_service.goindex 1eff705bf..b15c789ab 100644--- a/backend/internal/services/converter_service.go+++ b/backend/internal/services/converter_service.go@@ -21,7 +21,6 @@ func (s *ConverterService) ParseDockerRunCommand(command string) (*models.Dockerreturn nil, fmt.Errorf("docker run command must be a non-empty string")}- // Remove 'docker run' from the beginningcmd := strings.TrimSpace(command)cmd = regexp.MustCompile(`^docker\s+run\s+`).ReplaceAllString(cmd, "")@@ -39,180 +38,151 @@ func (s *ConverterService) ParseDockerRunCommand(command string) (*models.Dockerreturn nil, fmt.Errorf("no valid tokens found in docker run command")}+ if err := s.parseTokens(tokens, result); err != nil {+ return nil, err+ }++ if result.Image == "" {+ return nil, fmt.Errorf("no Docker image specified in command")+ }++ return result, nil+}++func (s *ConverterService) parseTokens(tokens []string, result *models.DockerRunCommand) error {for i := 0; i < len(tokens); i++ {token := tokens[i]- switch token {- case "-d", "--detach":- result.Detached = true- case "-i", "--interactive":- result.Interactive = true- case "-t", "--tty":- result.TTY = true- case "--rm":- result.Remove = true- case "--privileged":- result.Privileged = true- case "--name":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for --name flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for --name flag")- }- result.Name = tokens[i]- case "-p", "--port", "--publish":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for port flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for port flag")- }- result.Ports = append(result.Ports, tokens[i])- case "-v", "--volume":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for volume flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for volume flag")- }- result.Volumes = append(result.Volumes, tokens[i])- case "-e", "--env":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for environment flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for environment flag")- }- result.Environment = append(result.Environment, tokens[i])- case "--network":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for --network flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for --network flag")- }- result.Networks = append(result.Networks, tokens[i])- case "--restart":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for --restart flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for --restart flag")- }- result.Restart = tokens[i]- case "-w", "--workdir":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for workdir flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for workdir flag")- }- result.Workdir = tokens[i]- case "-u", "--user":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for user flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for user flag")- }- result.User = tokens[i]- case "--entrypoint":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for --entrypoint flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for --entrypoint flag")- }- result.Entrypoint = tokens[i]- case "--health-cmd":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for --health-cmd flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for --health-cmd flag")- }- result.HealthCheck = tokens[i]- case "-m", "--memory":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for memory flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for memory flag")- }- result.MemoryLimit = tokens[i]- case "--cpus":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for --cpus flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for --cpus flag")+ if strings.HasPrefix(token, "-") {+ advance, err := s.parseFlag(token, tokens, i, result)+ if err != nil {+ return err}- result.CPULimit = tokens[i]- case "--label":- if i+1 >= len(tokens) {- return nil, fmt.Errorf("missing value for --label flag")- }- i++- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {- return nil, fmt.Errorf("invalid value for --label flag")- }- result.Labels = append(result.Labels, tokens[i])- default:- if strings.HasPrefix(token, "-") {- // Handle combined short flags like -dit- if strings.HasPrefix(token, "-") && !strings.HasPrefix(token, "--") && len(token) > 2 {- flags := strings.Split(token[1:], "")- for _, flag := range flags {- switch flag {- case "d":- result.Detached = true- case "i":- result.Interactive = true- case "t":- result.TTY = true- }- }- } else {- // Unknown flag - skip it and potential value- if i+1 < len(tokens) && !strings.HasPrefix(tokens[i+1], "-") && result.Image == "" {- i++ // Skip potential value- }+ i += advance+ } else {+ if result.Image == "" {+ if token == "" {+ return fmt.Errorf("image name cannot be empty")}+ result.Image = token} else {- // Token doesn't start with '-', it's either image or command- if result.Image == "" {- if token == "" {- return nil, fmt.Errorf("image name cannot be empty")- }- result.Image = token- } else {- // Everything from this point forward is part of the command- remainingTokens := tokens[i:]- result.Command = strings.Join(remainingTokens, " ")- break- }+ remainingTokens := tokens[i:]+ result.Command = strings.Join(remainingTokens, " ")+ break}}}+ return nil+}- if result.Image == "" {- return nil, fmt.Errorf("no Docker image specified in command")+func (s *ConverterService) parseFlag(token string, tokens []string, index int, result *models.DockerRunCommand) (int, error) {+ switch token {+ case "-d", "--detach":+ result.Detached = true+ return 0, nil+ case "-i", "--interactive":+ result.Interactive = true+ return 0, nil+ case "-t", "--tty":+ result.TTY = true+ return 0, nil+ case "--rm":+ result.Remove = true+ return 0, nil+ case "--privileged":+ result.Privileged = true+ return 0, nil+ default:+ return s.parseFlagWithValue(token, tokens, index, result)}+}- return result, nil+func (s *ConverterService) parseFlagWithValue(token string, tokens []string, index int, result *models.DockerRunCommand) (int, error) {+ switch token {+ case "--name":+ return s.parseStringFlag(token, tokens, index, &result.Name)+ case "-p", "--port", "--publish":+ return s.parseSliceFlag(token, tokens, index, &result.Ports)+ case "-v", "--volume":+ return s.parseSliceFlag(token, tokens, index, &result.Volumes)+ case "-e", "--env":+ return s.parseSliceFlag(token, tokens, index, &result.Environment)+ case "--network":+ return s.parseSliceFlag(token, tokens, index, &result.Networks)+ case "--restart":+ return s.parseStringFlag(token, tokens, index, &result.Restart)+ case "-w", "--workdir":+ return s.parseStringFlag(token, tokens, index, &result.Workdir)+ case "-u", "--user":+ return s.parseStringFlag(token, tokens, index, &result.User)+ case "--entrypoint":+ return s.parseStringFlag(token, tokens, index, &result.Entrypoint)+ case "--health-cmd":+ return s.parseStringFlag(token, tokens, index, &result.HealthCheck)+ case "-m", "--memory":+ return s.parseStringFlag(token, tokens, index, &result.MemoryLimit)+ case "--cpus":+ return s.parseStringFlag(token, tokens, index, &result.CPULimit)+ case "--label":+ return s.parseSliceFlag(token, tokens, index, &result.Labels)+ default:+ return s.parseUnknownFlag(token, tokens, index, result)+ }+}++func (s *ConverterService) parseStringFlag(flagName string, tokens []string, index int, target *string) (int, error) {+ if index+1 >= len(tokens) {+ return 0, fmt.Errorf("missing value for %s flag", flagName)+ }++ value := tokens[index+1]+ if value == "" || strings.HasPrefix(value, "-") {+ return 0, fmt.Errorf("invalid value for %s flag", flagName)+ }++ *target = value+ return 1, nil+}++func (s *ConverterService) parseSliceFlag(flagName string, tokens []string, index int, target *[]string) (int, error) {+ if index+1 >= len(tokens) {+ return 0, fmt.Errorf("missing value for %s flag", flagName)+ }++ value := tokens[index+1]+ if value == "" || strings.HasPrefix(value, "-") {+ return 0, fmt.Errorf("invalid value for %s flag", flagName)+ }++ *target = append(*target, value)+ return 1, nil+}++func (s *ConverterService) parseUnknownFlag(token string, tokens []string, index int, result *models.DockerRunCommand) (int, error) {+ if !strings.HasPrefix(token, "--") && len(token) > 2 {+ s.parseCombinedFlags(token, result)+ return 0, nil+ }++ if index+1 < len(tokens) && !strings.HasPrefix(tokens[index+1], "-") && result.Image == "" {+ return 1, nil+ }++ return 0, nil+}++func (s *ConverterService) parseCombinedFlags(token string, result *models.DockerRunCommand) {+ flags := strings.Split(token[1:], "")+ for _, flag := range flags {+ switch flag {+ case "d":+ result.Detached = true+ case "i":+ result.Interactive = true+ case "t":+ result.TTY = true+ }+ }}// ConvertToDockerCompose converts a parsed docker run command to docker-compose YAMLdiff --git a/backend/internal/services/environment_service.go b/backend/internal/services/environment_service.goindex c143a4784..308290ded 100644--- a/backend/internal/services/environment_service.go+++ b/backend/internal/services/environment_service.go@@ -79,19 +79,24 @@ func (s *EnvironmentService) TestConnection(ctx context.Context, id string) (str}client := &http.Client{Timeout: 10 * time.Second}- resp, err := client.Get(environment.ApiUrl + "/health")+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, environment.ApiUrl+"/health", nil)if err != nil {- s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOffline))+ _ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOffline))+ return "offline", fmt.Errorf("failed to create request: %w", err)+ }+ resp, err := client.Do(req)+ if err != nil {+ _ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOffline))return "offline", fmt.Errorf("connection failed: %w", err)}defer resp.Body.Close()if resp.StatusCode == http.StatusOK {- s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOnline))+ _ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOnline))return "online", nil}- s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusError))+ _ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusError))return "error", fmt.Errorf("unexpected status code: %d", resp.StatusCode)}diff --git a/backend/internal/services/image_maturity_service.go b/backend/internal/services/image_maturity_service.goindex 20b4c46be..42d0950c2 100644--- a/backend/internal/services/image_maturity_service.go+++ b/backend/internal/services/image_maturity_service.go@@ -74,7 +74,7 @@ func (s *ImageMaturityService) SetImageMaturity(ctx context.Context, imageID, reexisting, err := s.GetImageMaturity(ctx, imageID)if err == nil {record.CheckCount = existing.CheckCount + 1- record.BaseModel.CreatedAt = existing.BaseModel.CreatedAt+ record.CreatedAt = existing.CreatedAt}if err := s.db.WithContext(ctx).Save(record).Error; err != nil {@@ -256,7 +256,7 @@ func (s *ImageMaturityService) ProcessImagesForMaturityCheck(ctx context.ContextmaturityData, err := s.CheckImageInRegistry(ctx, repo, tag, img.ID)if err != nil {errMsg := err.Error()- s.UpdateCheckStatus(ctx, img.ID, models.ImageStatusError, &errMsg)+ _ = s.UpdateCheckStatus(ctx, img.ID, models.ImageStatusError, &errMsg)continue}@@ -308,8 +308,8 @@ func (s *ImageMaturityService) CheckImageInRegistry(ctx context.Context, repo, tfunc (s *ImageMaturityService) checkAgainstSameTagOnly(ctx context.Context, registryURL, repo, tag, token string, localManifest *RegistryManifest) (*models.ImageMaturity, error) {hasTagUpdates := s.hasTagUpdates(ctx, registryURL, repo, tag, token, localManifest)- status := models.ImageStatusUnknownimageAge := time.Since(localManifest.CreatedAt)+ var status stringif imageAge > 30*24*time.Hour {status = models.ImageStatusMatured} else {@@ -518,7 +518,7 @@ func (s *ImageMaturityService) getDockerHubManifest(ctx context.Context, repo, tmanifestURL := fmt.Sprintf("https://registry-1.docker.io/v2/%s/manifests/%s", normalizedRepo, tag)client := &http.Client{Timeout: 30 * time.Second}- req, err := http.NewRequestWithContext(ctx, "GET", manifestURL, nil)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, manifestURL, nil)if err != nil {return nil, fmt.Errorf("failed to create manifest request: %w", err)}@@ -567,7 +567,7 @@ func (s *ImageMaturityService) getGenericRegistryManifest(ctx context.Context, rmanifestURL := fmt.Sprintf("%s/%s/manifests/%s", registryURL, repo, tag)client := &http.Client{Timeout: 30 * time.Second}- req, err := http.NewRequestWithContext(ctx, "GET", manifestURL, nil)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, manifestURL, nil)if err != nil {return nil, fmt.Errorf("failed to create manifest request: %w", err)}@@ -617,7 +617,7 @@ func (s *ImageMaturityService) getDockerHubTags(ctx context.Context, repo, tokentagsURL := fmt.Sprintf("https://registry-1.docker.io/v2/%s/tags/list", normalizedRepo)client := &http.Client{Timeout: 30 * time.Second}- req, err := http.NewRequestWithContext(ctx, "GET", tagsURL, nil)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, tagsURL, nil)if err != nil {return nil, fmt.Errorf("failed to create tags request: %w", err)}@@ -649,7 +649,7 @@ func (s *ImageMaturityService) getGenericRegistryTags(ctx context.Context, registagsURL := fmt.Sprintf("%s/%s/tags/list", registryURL, normalizedRepo)client := &http.Client{Timeout: 30 * time.Second}- req, err := http.NewRequestWithContext(ctx, "GET", tagsURL, nil)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, tagsURL, nil)if err != nil {return nil, fmt.Errorf("failed to create tags request: %w", err)}diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.goindex 1cdb44184..9c3e95dc6 100644--- a/backend/internal/services/image_service.go+++ b/backend/internal/services/image_service.go@@ -295,92 +295,115 @@ func (s *ImageService) GetImageHistory(ctx context.Context, id string) ([]image.}func (s *ImageService) syncImagesToDatabase(ctx context.Context, dockerImages []image.Summary, dockerClient *client.Client) error {+ inUseImageIDs := s.getInUseImageIDs(ctx, dockerClient)+ currentDockerImageIDs := make([]string, 0, len(dockerImages))+ var lastErr error++ for _, di := range dockerImages {+ currentDockerImageIDs = append(currentDockerImageIDs, di.ID)+ if err := s.syncSingleImage(ctx, di, inUseImageIDs); err != nil {+ fmt.Printf("Error syncing image %s to database: %v\n", di.ID, err)+ lastErr = err+ }+ }++ if err := s.cleanupStaleImages(ctx, currentDockerImageIDs); err != nil {+ lastErr = err+ }++ return lastErr+}++func (s *ImageService) getInUseImageIDs(ctx context.Context, dockerClient *client.Client) map[string]bool {inUseImageIDs := make(map[string]bool)containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})if err != nil {fmt.Printf("Error listing containers for InUse check: %v. InUse status may be inaccurate.\n", err)- } else {- for _, cont := range containers {- inUseImageIDs[cont.ImageID] = true- }+ return inUseImageIDs}- var lastErr error- currentDockerImageIDs := make([]string, 0, len(dockerImages))+ for _, cont := range containers {+ inUseImageIDs[cont.ImageID] = true+ }+ return inUseImageIDs+}- for _, di := range dockerImages {- currentDockerImageIDs = append(currentDockerImageIDs, di.ID)- _, isInUse := inUseImageIDs[di.ID]-- imageModel := models.Image{- ID: di.ID,- RepoTags: models.StringSlice(di.RepoTags),- RepoDigests: models.StringSlice(di.RepoDigests),- Size: di.Size,- Created: time.Unix(di.Created, 0),- InUse: isInUse,- }+func (s *ImageService) syncSingleImage(ctx context.Context, di image.Summary, inUseImageIDs map[string]bool) error {+ _, isInUse := inUseImageIDs[di.ID]- if di.Labels != nil {- labelsJSON := make(map[string]interface{})- for k, v := range di.Labels {- labelsJSON[k] = v- }- imageModel.Labels = models.JSON(labelsJSON)- }+ imageModel := s.buildImageModel(di, isInUse)- if len(di.RepoTags) > 0 && di.RepoTags[0] != "" {- repoTag := di.RepoTags[0]- if strings.Contains(repoTag, ":") {- parts := strings.SplitN(repoTag, ":", 2)- imageModel.Repo = parts[0]- imageModel.Tag = parts[1]- } else {- imageModel.Repo = repoTag- imageModel.Tag = "latest"- }- } else {- imageModel.Repo = "<none>"- imageModel.Tag = "<none>"- }+ return s.db.WithContext(ctx).Clauses(clause.OnConflict{+ Columns: []clause.Column{{Name: "id"}},+ DoUpdates: clause.AssignmentColumns([]string{"repo_tags", "repo_digests", "size", "virtual_size", "created", "labels", "repo", "tag", "in_use"}),+ }).Create(&imageModel).Error+}- dbErr := s.db.WithContext(ctx).Clauses(clause.OnConflict{- Columns: []clause.Column{{Name: "id"}},- DoUpdates: clause.AssignmentColumns([]string{"repo_tags", "repo_digests", "size", "virtual_size", "created", "labels", "repo", "tag", "in_use"}),- }).Create(&imageModel).Error+func (s *ImageService) buildImageModel(di image.Summary, isInUse bool) models.Image {+ imageModel := models.Image{+ ID: di.ID,+ RepoTags: models.StringSlice(di.RepoTags),+ RepoDigests: models.StringSlice(di.RepoDigests),+ Size: di.Size,+ Created: time.Unix(di.Created, 0),+ InUse: isInUse,+ }- if dbErr != nil {- fmt.Printf("Error syncing image %s to database: %v\n", di.ID, dbErr)- lastErr = dbErr+ if di.Labels != nil {+ labelsJSON := make(map[string]interface{})+ for k, v := range di.Labels {+ labelsJSON[k] = v}+ imageModel.Labels = models.JSON(labelsJSON)}- if len(currentDockerImageIDs) > 0 {- deleteResult := s.db.WithContext(ctx).Where("id NOT IN ?", currentDockerImageIDs).Delete(&models.Image{})- if deleteResult.Error != nil {- errMsg := fmt.Sprintf("Error deleting stale images from database: %v", deleteResult.Error)- fmt.Println(errMsg)- if lastErr == nil {- lastErr = deleteResult.Error- }+ s.setRepoAndTag(&imageModel, di.RepoTags)+ return imageModel+}++func (s *ImageService) setRepoAndTag(imageModel *models.Image, repoTags []string) {+ if len(repoTags) > 0 && repoTags[0] != "" {+ repoTag := repoTags[0]+ if strings.Contains(repoTag, ":") {+ parts := strings.SplitN(repoTag, ":", 2)+ imageModel.Repo = parts[0]+ imageModel.Tag = parts[1]} else {- fmt.Printf("%d stale image records deleted from database.\n", deleteResult.RowsAffected)+ imageModel.Repo = repoTag+ imageModel.Tag = "latest"}} else {- fmt.Println("No images found in Docker daemon, attempting to delete all image records from database.")- deleteAllResult := s.db.WithContext(ctx).Delete(&models.Image{}, "1 = 1")- if deleteAllResult.Error != nil {- errMsg := fmt.Sprintf("Error deleting all image records from database when Docker is empty: %v", deleteAllResult.Error)- fmt.Println(errMsg)- if lastErr == nil {- lastErr = deleteAllResult.Error- }- } else {- fmt.Printf("All (%d) image records deleted from database as Docker reported no images.\n", deleteAllResult.RowsAffected)- }+ imageModel.Repo = "<none>"+ imageModel.Tag = "<none>"}+}- return lastErr+func (s *ImageService) cleanupStaleImages(ctx context.Context, currentDockerImageIDs []string) error {+ if len(currentDockerImageIDs) > 0 {+ return s.deleteStaleImages(ctx, currentDockerImageIDs)+ }+ return s.deleteAllImages(ctx)+}++func (s *ImageService) deleteStaleImages(ctx context.Context, currentDockerImageIDs []string) error {+ deleteResult := s.db.WithContext(ctx).Where("id NOT IN ?", currentDockerImageIDs).Delete(&models.Image{})+ if deleteResult.Error != nil {+ fmt.Printf("Error deleting stale images from database: %v\n", deleteResult.Error)+ return deleteResult.Error+ }+ fmt.Printf("%d stale image records deleted from database.\n", deleteResult.RowsAffected)+ return nil+}++func (s *ImageService) deleteAllImages(ctx context.Context) error {+ fmt.Println("No images found in Docker daemon, attempting to delete all image records from database.")+ deleteAllResult := s.db.WithContext(ctx).Delete(&models.Image{}, "1 = 1")+ if deleteAllResult.Error != nil {+ fmt.Printf("Error deleting all image records from database when Docker is empty: %v\n", deleteAllResult.Error)+ return deleteAllResult.Error+ }+ fmt.Printf("All (%d) image records deleted from database as Docker reported no images.\n", deleteAllResult.RowsAffected)+ return nil}func (s *ImageService) GetImageByIDFromDB(ctx context.Context, id string) (*models.Image, error) {diff --git a/backend/internal/services/oidc_service.go b/backend/internal/services/oidc_service.goindex f895f2ed0..5141efb3d 100644--- a/backend/internal/services/oidc_service.go+++ b/backend/internal/services/oidc_service.go@@ -129,13 +129,13 @@ func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedSta}// Exchange code for tokens- tokenResponse, err := s.exchangeCodeForTokens(config, code, stateData.CodeVerifier)+ tokenResponse, err := s.exchangeCodeForTokens(ctx, config, code, stateData.CodeVerifier)if err != nil {return nil, fmt.Errorf("failed to exchange code for tokens: %w", err)}// Get user info from the userinfo endpoint- userInfo, err := s.getUserInfo(config, tokenResponse.AccessToken)+ userInfo, err := s.getUserInfo(ctx, config, tokenResponse.AccessToken)if err != nil {return nil, fmt.Errorf("failed to get user info: %w", err)}@@ -144,8 +144,7 @@ func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedSta}// exchangeCodeForTokens exchanges the authorization code for access tokens-func (s *OidcService) exchangeCodeForTokens(config *models.OidcConfig, code, codeVerifier string) (*TokenResponse, error) {- // Prepare token request+func (s *OidcService) exchangeCodeForTokens(ctx context.Context, config *models.OidcConfig, code, codeVerifier string) (*TokenResponse, error) {data := url.Values{}data.Set("grant_type", "authorization_code")data.Set("code", code)@@ -154,8 +153,7 @@ func (s *OidcService) exchangeCodeForTokens(config *models.OidcConfig, code, coddata.Set("client_secret", config.ClientSecret)data.Set("code_verifier", codeVerifier)- // Make token request- req, err := http.NewRequest("POST", config.TokenEndpoint, strings.NewReader(data.Encode()))+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, config.TokenEndpoint, strings.NewReader(data.Encode()))if err != nil {return nil, err}@@ -174,7 +172,6 @@ func (s *OidcService) exchangeCodeForTokens(config *models.OidcConfig, code, codreturn nil, fmt.Errorf("token endpoint returned %d: %s", resp.StatusCode, string(bodyBytes))}- // Parse token responsevar tokenResponse TokenResponseif err := json.NewDecoder(resp.Body).Decode(&tokenResponse); err != nil {return nil, err@@ -184,9 +181,8 @@ func (s *OidcService) exchangeCodeForTokens(config *models.OidcConfig, code, cod}// getUserInfo retrieves user information from the userinfo endpoint-func (s *OidcService) getUserInfo(config *models.OidcConfig, accessToken string) (*OidcUserInfo, error) {- // Make userinfo request- req, err := http.NewRequest("GET", config.UserinfoEndpoint, nil)+func (s *OidcService) getUserInfo(ctx context.Context, config *models.OidcConfig, accessToken string) (*OidcUserInfo, error) {+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, config.UserinfoEndpoint, nil)if err != nil {return nil, err}@@ -205,13 +201,11 @@ func (s *OidcService) getUserInfo(config *models.OidcConfig, accessToken string)return nil, fmt.Errorf("userinfo endpoint returned %d: %s", resp.StatusCode, string(bodyBytes))}- // Parse userinfo responsevar userInfo OidcUserInfoif err := json.NewDecoder(resp.Body).Decode(&userInfo); err != nil {return nil, err}- // Validate required fieldsif userInfo.Subject == "" {return nil, errors.New("missing required 'sub' field in userinfo response")}diff --git a/backend/internal/services/stack_service.go b/backend/internal/services/stack_service.goindex 621e03938..d0653aa7f 100644--- a/backend/internal/services/stack_service.go+++ b/backend/internal/services/stack_service.go@@ -185,18 +185,18 @@ func (s *StackService) GetStackServices(ctx context.Context, stackID string) ([]composeFile := s.findComposeFile(stack.Path)if composeFile == "" {- return []StackServiceInfo{}, nil+ return nil, fmt.Errorf("no compose file found for stack")}- servicesFromFile, err := s.parseServicesFromComposeFile(composeFile, stack.Name)+ servicesFromFile, err := s.parseServicesFromComposeFile(ctx, composeFile, stack.Name)if err != nil {- return []StackServiceInfo{}, nil+ return nil, fmt.Errorf("failed to parse services from compose file: %w", err)}return servicesFromFile, nil}-func (s *StackService) parseServicesFromComposeFile(composeFile, stackName string) ([]StackServiceInfo, error) {+func (s *StackService) parseServicesFromComposeFile(ctx context.Context, composeFile, stackName string) ([]StackServiceInfo, error) {options, err := cli.NewProjectOptions([]string{composeFile},cli.WithOsEnv,@@ -208,7 +208,7 @@ func (s *StackService) parseServicesFromComposeFile(composeFile, stackName strinreturn nil, fmt.Errorf("failed to create project options: %w", err)}- project, err := options.LoadProject(context.Background())+ project, err := options.LoadProject(ctx)if err != nil {return nil, fmt.Errorf("failed to load project: %w", err)}@@ -384,7 +384,7 @@ func (s *StackService) UpdateStackContent(ctx context.Context, stackID string, ccomposePath = filepath.Join(stack.Path, "compose.yaml")}- if err := os.WriteFile(composePath, []byte(*composeContent), 0644); err != nil {+ if err := os.WriteFile(composePath, []byte(*composeContent), 0600); err != nil {return fmt.Errorf("failed to update compose file: %w", err)}}@@ -394,7 +394,7 @@ func (s *StackService) UpdateStackContent(ctx context.Context, stackID string, cif *envContent == "" {os.Remove(envPath)} else {- if err := os.WriteFile(envPath, []byte(*envContent), 0644); err != nil {+ if err := os.WriteFile(envPath, []byte(*envContent), 0600); err != nil {return fmt.Errorf("failed to update env file: %w", err)}}@@ -495,14 +495,12 @@ func (s *StackService) RedeployStack(ctx context.Context, stackID string, profil}func (s *StackService) DiscoverExternalStacks(ctx context.Context) ([]models.Stack, error) {- // This would use docker commands to find compose projects not in our database- // For now, return empty slice - implement based on your requirements+ // TODOreturn []models.Stack{}, nil}func (s *StackService) ImportExternalStack(ctx context.Context, stackID, stackName string) (*models.Stack, error) {- // Implementation would depend on how you want to handle external stack import- // For now, return error indicating not implemented+ // TODOreturn nil, fmt.Errorf("external stack import not implemented yet")}@@ -513,8 +511,8 @@ func (s *StackService) ValidateStackCompose(ctx context.Context, composeContent}defer os.RemoveAll(tempDir)- composePath := filepath.Join(tempDir, "docker-compose.yml")- if err := os.WriteFile(composePath, []byte(composeContent), 0644); err != nil {+ composePath := filepath.Join(tempDir, "compose.yaml")+ if err := os.WriteFile(composePath, []byte(composeContent), 0600); err != nil {return fmt.Errorf("failed to write compose file: %w", err)}@@ -625,14 +623,14 @@ func (s *StackService) StreamStackLogs(ctx context.Context, stackID string, logsselect {case <-ctx.Done():if cmd.Process != nil {- cmd.Process.Kill()+ _ = cmd.Process.Kill()}return ctx.Err()case err := <-done:if cmd.Process != nil {- cmd.Process.Kill()+ _ = cmd.Process.Kill()}- if err != nil && err != io.EOF {+ if err != nil && !errors.Is(err, io.EOF) {return err}return nil@@ -757,13 +755,13 @@ func (s *StackService) saveStackFiles(stackPath, composeContent string, envContecomposePath = filepath.Join(stackPath, "compose.yaml")}- if err := os.WriteFile(composePath, []byte(composeContent), 0644); err != nil {+ if err := os.WriteFile(composePath, []byte(composeContent), 0600); err != nil {return fmt.Errorf("failed to save compose file: %w", err)}if envContent != nil && *envContent != "" {envPath := filepath.Join(stackPath, ".env")- if err := os.WriteFile(envPath, []byte(*envContent), 0644); err != nil {+ if err := os.WriteFile(envPath, []byte(*envContent), 0600); err != nil {return fmt.Errorf("failed to save env file: %w", err)}}diff --git a/backend/internal/services/system_service.go b/backend/internal/services/system_service.goindex f0dda5d6c..f10709ebf 100644--- a/backend/internal/services/system_service.go+++ b/backend/internal/services/system_service.go@@ -46,7 +46,7 @@ type PruneAllResult struct {ImagesDeleted []string `json:"imagesDeleted,omitempty"`VolumesDeleted []string `json:"volumesDeleted,omitempty"`NetworksDeleted []string `json:"networksDeleted,omitempty"`- SpaceReclaimed int64 `json:"spaceReclaimed"`+ SpaceReclaimed uint64 `json:"spaceReclaimed"`Success bool `json:"success"`Errors []string `json:"errors,omitempty"`}@@ -126,7 +126,7 @@ func (s *SystemService) PruneAll(ctx context.Context, req dto.PruneSystemDto) (*slog.Int("images_deleted", len(result.ImagesDeleted)),slog.Int("volumes_deleted", len(result.VolumesDeleted)),slog.Int("networks_deleted", len(result.NetworksDeleted)),- slog.Int64("space_reclaimed", result.SpaceReclaimed),+ slog.Uint64("space_reclaimed", result.SpaceReclaimed),slog.Int("error_count", len(result.Errors)))return result, nil@@ -246,7 +246,7 @@ func (s *SystemService) pruneContainers(ctx context.Context, result *PruneAllRes}result.ContainersPruned = report.ContainersDeleted- result.SpaceReclaimed += int64(report.SpaceReclaimed)+ result.SpaceReclaimed += report.SpaceReclaimedreturn nil}@@ -296,7 +296,7 @@ func (s *SystemService) pruneImages(ctx context.Context, danglingOnly bool, resu}}}- result.SpaceReclaimed += int64(report.SpaceReclaimed)+ result.SpaceReclaimed += report.SpaceReclaimedreturn nil}@@ -325,7 +325,7 @@ func (s *SystemService) pruneBuildCache(ctx context.Context, result *PruneAllResslog.Int("cache_entries_deleted", len(report.CachesDeleted)),slog.Uint64("bytes_reclaimed", report.SpaceReclaimed))- result.SpaceReclaimed += int64(report.SpaceReclaimed)+ result.SpaceReclaimed += report.SpaceReclaimedreturn nil}@@ -336,7 +336,7 @@ func (s *SystemService) pruneVolumes(ctx context.Context, result *PruneAllResult}result.VolumesDeleted = report.VolumesDeleted- result.SpaceReclaimed += int64(report.SpaceReclaimed)+ result.SpaceReclaimed += report.SpaceReclaimedreturn nil}@@ -413,7 +413,7 @@ func (s *SystemService) PruneSystem(ctx context.Context, all bool) (*PruneAllResslog.Int("images_deleted", len(result.ImagesDeleted)),slog.Int("volumes_deleted", len(result.VolumesDeleted)),slog.Int("networks_deleted", len(result.NetworksDeleted)),- slog.Int64("space_reclaimed", result.SpaceReclaimed),+ slog.Uint64("space_reclaimed", result.SpaceReclaimed),slog.Int("error_count", len(result.Errors)))return result, nildiff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.goindex 58f033e13..6b61a104a 100644--- a/backend/internal/services/template_service.go+++ b/backend/internal/services/template_service.go@@ -3,6 +3,7 @@ package servicesimport ("context""encoding/json"+ "errors""fmt""io""net/http"@@ -47,7 +48,7 @@ func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.Cvar template models.ComposeTemplateerr := s.db.WithContext(ctx).Preload("Registry").Where("id = ?", id).First(&template).Errorif err != nil {- if err == gorm.ErrRecordNotFound {+ if errors.Is(err, gorm.ErrRecordNotFound) {return nil, fmt.Errorf("template not found")}return nil, fmt.Errorf("failed to get template: %w", err)@@ -75,7 +76,7 @@ func (s *TemplateService) UpdateTemplate(ctx context.Context, id string, updatesvar existing models.ComposeTemplateerr := s.db.WithContext(ctx).Where("id = ?", id).First(&existing).Errorif err != nil {- if err == gorm.ErrRecordNotFound {+ if errors.Is(err, gorm.ErrRecordNotFound) {return fmt.Errorf("template not found")}return fmt.Errorf("failed to find template: %w", err)@@ -121,7 +122,7 @@ func (s *TemplateService) SaveEnvTemplate(content string) error {}envPath := filepath.Join(templateDir, ".env.template")- if err := os.WriteFile(envPath, []byte(content), 0644); err != nil {+ if err := os.WriteFile(envPath, []byte(content), 0600); err != nil {return fmt.Errorf("failed to save env template: %w", err)}@@ -149,7 +150,7 @@ func (s *TemplateService) UpdateRegistry(ctx context.Context, id uint, updates *var existing models.TemplateRegistryerr := s.db.WithContext(ctx).Where("id = ?", id).First(&existing).Errorif err != nil {- if err == gorm.ErrRecordNotFound {+ if errors.Is(err, gorm.ErrRecordNotFound) {return fmt.Errorf("registry not found")}return fmt.Errorf("failed to find registry: %w", err)@@ -192,7 +193,7 @@ func (s *TemplateService) loadRemoteTemplates(ctx context.Context) ([]models.Comcontinue}- remoteTemplates, err := s.fetchRegistryTemplates(registry.URL)+ remoteTemplates, err := s.fetchRegistryTemplates(ctx, registry.URL)if err != nil {fmt.Printf("Warning: failed to fetch templates from registry %s: %v\n", registry.Name, err)continue@@ -207,9 +208,13 @@ func (s *TemplateService) loadRemoteTemplates(ctx context.Context) ([]models.Comreturn templates, nil}-func (s *TemplateService) fetchRegistryTemplates(url string) ([]models.RemoteTemplate, error) {+func (s *TemplateService) fetchRegistryTemplates(ctx context.Context, url string) ([]models.RemoteTemplate, error) {client := &http.Client{Timeout: 30 * time.Second}- resp, err := client.Get(url)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)+ if err != nil {+ return nil, fmt.Errorf("failed to create request: %w", err)+ }+ resp, err := client.Do(req)if err != nil {return nil, fmt.Errorf("failed to fetch registry: %w", err)}@@ -301,22 +306,26 @@ func (s *TemplateService) FetchTemplateContent(ctx context.Context, template *moreturn template.Content, "", fmt.Errorf("not a remote template")}- composeContent, err := s.fetchURL(*template.Metadata.RemoteURL)+ composeContent, err := s.fetchURL(ctx, *template.Metadata.RemoteURL)if err != nil {return "", "", fmt.Errorf("failed to fetch compose content: %w", err)}var envContent stringif template.Metadata.EnvURL != nil && *template.Metadata.EnvURL != "" {- envContent, _ = s.fetchURL(*template.Metadata.EnvURL)+ envContent, _ = s.fetchURL(ctx, *template.Metadata.EnvURL)}return composeContent, envContent, nil}-func (s *TemplateService) fetchURL(url string) (string, error) {+func (s *TemplateService) fetchURL(ctx context.Context, url string) (string, error) {client := &http.Client{Timeout: 30 * time.Second}- resp, err := client.Get(url)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)+ if err != nil {+ return "", err+ }+ resp, err := client.Do(req)if err != nil {return "", err}diff --git a/backend/internal/services/user_service.go b/backend/internal/services/user_service.goindex dcf5260c1..064294439 100644--- a/backend/internal/services/user_service.go+++ b/backend/internal/services/user_service.go@@ -2,11 +2,9 @@ package servicesimport ("context"- "crypto/rand""errors""fmt""log"- "math/big""golang.org/x/crypto/bcrypt""gorm.io/gorm"@@ -132,21 +130,6 @@ func (s *UserService) CreateDefaultAdmin() error {return nil}-func (s *UserService) generateRandomPassword(length int) (string, error) {- const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*"- password := make([]byte, length)-- for i := range password {- num, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))- if err != nil {- return "", err- }- password[i] = charset[num.Int64()]- }-- return string(password), nil-}-func (s *UserService) ListUsers(ctx context.Context) ([]models.User, error) {var users []models.Userif err := s.db.WithContext(ctx).Find(&users).Error; err != nil {diff --git a/backend/internal/utils/registry_utils.go b/backend/internal/utils/registry_utils.goindex 54531becc..732453aeb 100644--- a/backend/internal/utils/registry_utils.go+++ b/backend/internal/utils/registry_utils.go@@ -80,7 +80,7 @@ func getDockerHubToken(ctx context.Context, repo string, creds *RegistryCredentiauthURL := fmt.Sprintf("https://auth.docker.io/token?service=registry.docker.io&scope=repository:%s:pull", normalizedRepo)client := &http.Client{Timeout: 30 * time.Second}- req, err := http.NewRequestWithContext(ctx, "GET", authURL, nil)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, authURL, nil)if err != nil {return "", fmt.Errorf("failed to create auth request: %w", err)}@@ -201,7 +201,7 @@ type RegistryTestResult struct {}func testPing(ctx context.Context, client *http.Client, registryURL string, creds *RegistryCredentials) error {- req, err := http.NewRequestWithContext(ctx, "GET", registryURL+"/", nil)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, registryURL+"/", nil)if err != nil {return err}@@ -231,7 +231,7 @@ func testAuth(ctx context.Context, client *http.Client, registryURL string, credreturn nil // Skip auth test if no credentials}- req, err := http.NewRequestWithContext(ctx, "GET", registryURL+"/_catalog?n=1", nil)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, registryURL+"/_catalog?n=1", nil)if err != nil {return err}@@ -253,7 +253,7 @@ func testAuth(ctx context.Context, client *http.Client, registryURL string, cred}func testCatalog(ctx context.Context, client *http.Client, registryURL string, creds *RegistryCredentials) error {- req, err := http.NewRequestWithContext(ctx, "GET", registryURL+"/_catalog?n=5", nil)+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, registryURL+"/_catalog?n=5", nil)if err != nil {return err}