feat: translation support

See #483

.drone.yml

@@ -3,14 +3,14 @@ kind: pipeline
 name: coopcloud.tech/abra
 steps:
   - name: make check
-    image: golang:1.21
+    image: golang:1.24
     commands:
       - make check
 
   - name: make test
-    image: golang:1.21
+    image: golang:1.24
     environment:
-      CATL_URL: https://git.coopcloud.tech/coop-cloud/recipes-catalogue-json.git
+      CATL_URL: https://git.coopcloud.tech/toolshed/recipes-catalogue-json.git
     commands:
       - mkdir -p $HOME/.abra
       - git clone $CATL_URL $HOME/.abra/catalogue
@@ -29,7 +29,7 @@ steps:
       event: tag
 
   - name: release
-    image: goreleaser/goreleaser:v1.24.0
+    image: goreleaser/goreleaser:v2.5.1
     environment:
       GITEA_TOKEN:
         from_secret: goreleaser_gitea_token
@@ -47,10 +47,10 @@ steps:
     image: plugins/docker
     settings:
       auto_tag: true
-      username: 3wordchant
+      username: abra-bot
       password:
-        from_secret: git_coopcloud_tech_token_3wc
-      repo: git.coopcloud.tech/coop-cloud/abra
+        from_secret: git_coopcloud_tech_token_abra_bot
+      repo: git.coopcloud.tech/toolshed/abra
       tags: dev
       registry: git.coopcloud.tech
     when:
@@ -60,7 +60,7 @@ steps:
       - make check
       - make test
 
-  - name: integration test
+  - name: on-demand integration test
     image: appleboy/drone-ssh
     settings:
       host:
@@ -74,7 +74,31 @@ steps:
       request_pty: true
       script:
         - |
-          wget https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/tests/run-ci-int -O run-ci-int
+          wget https://git.coopcloud.tech/toolshed/abra/raw/branch/main/scripts/tests/run-ci-int -O run-ci-int
+          chmod +x run-ci-int
+          sh run-ci-int
+    when:
+      ref:
+        - refs/heads/int-*
+    depends_on:
+      - make check
+      - make test
+
+  - name: nightly integration test
+    image: appleboy/drone-ssh
+    settings:
+      host:
+        - int.coopcloud.tech
+      username: abra
+      key:
+        from_secret: abra_int_private_key
+      port: 22
+      command_timeout: 60m
+      script_stop: true
+      request_pty: true
+      script:
+        - |
+          wget https://git.coopcloud.tech/toolshed/abra/raw/branch/main/scripts/tests/run-ci-int -O run-ci-int
           chmod +x run-ci-int
           sh run-ci-int
     when:
@@ -87,3 +111,8 @@ steps:
 volumes:
   - name: deps
     temp: {}
+
+trigger:
+  action:
+    exclude:
+      - synchronized

.envrc.sample

@@ -1,6 +1,6 @@
 # integration test suite
 # export ABRA_DIR="$HOME/.abra_test"
-# export ABRA_TEST_DOMAIN=test.example.com
+# export TEST_SERVER=test.example.com
 # export ABRA_CI=1
 
 # release automation

.gitea/ISSUE_TEMPLATE.md

@@ -1,8 +0,0 @@
----
-name: "Do not use this issue tracker"
-about: "Do not use this issue tracker"
-title: "Do not use this issue tracker"
-labels: []
----
-
-Please report your issue on [`coop-cloud/organising`](https://git.coopcloud.tech/coop-cloud/organising)

.gitignore

@@ -2,7 +2,7 @@
 .e2e.env
 .envrc
 .vscode/
+/abra
 /kadabra
-abra
 dist/
 tests/integration/.bats

AUTHORS.md

@@ -4,6 +4,7 @@
 > please do add yourself! This is a community project, let's show some 💞
 
 - 3wordchant
+- ammaratef45
 - cassowary
 - codegod100
 - decentral1se
@@ -17,3 +18,5 @@
 - roxxers
 - vera
 - yksflip
+- basebuilder
+- mayel

Dockerfile

@@ -1,7 +1,7 @@
 # Build image
-FROM golang:1.21-alpine AS build
+FROM golang:1.24-alpine AS build
 
-ENV GOPRIVATE coopcloud.tech
+ENV GOPRIVATE=coopcloud.tech
 
 RUN apk add --no-cache \
   gcc \

Makefile

@@ -2,7 +2,7 @@ ABRA         := ./cmd/abra
 KADABRA      := ./cmd/kadabra
 COMMIT       := $(shell git rev-list -1 HEAD)
 GOPATH       := $(shell go env GOPATH)
-GOVERSION    := 1.21
+GOVERSION    := 1.24
 LDFLAGS      := "-X 'main.Commit=$(COMMIT)'"
 DIST_LDFLAGS := $(LDFLAGS)" -s -w"
 GCFLAGS      := "all=-l -B"

README.md

@@ -1,8 +1,9 @@
 # `abra`
 
-[![Build Status](https://build.coopcloud.tech/api/badges/coop-cloud/abra/status.svg?ref=refs/heads/main)](https://build.coopcloud.tech/coop-cloud/abra)
-[![Go Report Card](https://goreportcard.com/badge/git.coopcloud.tech/coop-cloud/abra)](https://goreportcard.com/report/git.coopcloud.tech/coop-cloud/abra)
+[![Build Status](https://build.coopcloud.tech/api/badges/toolshed/abra/status.svg?ref=refs/heads/main)](https://build.coopcloud.tech/toolshed/abra)
+[![Go Report Card](https://goreportcard.com/badge/git.coopcloud.tech/toolshed/abra)](https://goreportcard.com/report/git.coopcloud.tech/toolshed/abra)
 [![Go Reference](https://pkg.go.dev/badge/coopcloud.tech/abra.svg)](https://pkg.go.dev/coopcloud.tech/abra)
+[![Translation status](https://translate.coopcloud.tech/widget/co-op-cloud/svg-badge.svg)](https://translate.coopcloud.tech/engage/co-op-cloud/)
 
 The Co-op Cloud utility belt 🎩🐇
 

cli/app/app.go

@@ -1,34 +1,12 @@
 package app
 
 import (
-	"github.com/urfave/cli/v3"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
 )
 
-var AppCommand = cli.Command{
-	Name:      "app",
-	Aliases:   []string{"a"},
-	Usage:     "Manage apps",
-	UsageText: "abra app [command] [arguments] [options]",
-	Commands: []*cli.Command{
-		&appBackupCommand,
-		&appCheckCommand,
-		&appCmdCommand,
-		&appConfigCommand,
-		&appCpCommand,
-		&appDeployCommand,
-		&appListCommand,
-		&appLogsCommand,
-		&appNewCommand,
-		&appPsCommand,
-		&appRemoveCommand,
-		&appRestartCommand,
-		&appRestoreCommand,
-		&appRollbackCommand,
-		&appRunCommand,
-		&appSecretCommand,
-		&appServicesCommand,
-		&appUndeployCommand,
-		&appUpgradeCommand,
-		&appVolumeCommand,
-	},
+var AppCommand = &cobra.Command{
+	Use:     "app [cmd] [args] [flags]",
+	Aliases: []string{"a"},
+	Short:   gotext.Get("Manage apps"),
 }

cli/app/backup.go

@@ -1,58 +1,28 @@
 package app
 
 import (
-	"context"
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var snapshot string
-var snapshotFlag = &cli.StringFlag{
-	Name:        "snapshot",
-	Aliases:     []string{"s"},
-	Usage:       "Lists specific snapshot",
-	Destination: &snapshot,
-}
-
-var includePath string
-var includePathFlag = &cli.StringFlag{
-	Name:        "path",
-	Aliases:     []string{"p"},
-	Usage:       "Include path",
-	Destination: &includePath,
-}
-
-var resticRepo string
-var resticRepoFlag = &cli.StringFlag{
-	Name:        "repo",
-	Aliases:     []string{"r"},
-	Usage:       "Restic repository",
-	Destination: &resticRepo,
-}
-
-var appBackupListCommand = cli.Command{
-	Name:    "list",
+var AppBackupListCommand = &cobra.Command{
+	Use:     "list <domain> [flags]",
 	Aliases: []string{"ls"},
-	Flags: []cli.Flag{
-		snapshotFlag,
-		includePathFlag,
+	Short:   "List the contents of a snapshot",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	Usage:         "List all backups",
-	UsageText:     "abra app backup list <domain> [options]",
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-			log.Fatal(err)
-		}
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
@@ -64,59 +34,54 @@ var appBackupListCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
+		execEnv := []string{
+			fmt.Sprintf("SERVICE=%s", app.Domain),
+			"MACHINE_LOGS=true",
+		}
+
 		if snapshot != "" {
 			log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
 			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
 		}
-		if includePath != "" {
-			log.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath)
-			execEnv = append(execEnv, fmt.Sprintf("INCLUDE_PATH=%s", includePath))
+
+		if showAllPaths {
+			log.Debugf("including SHOW_ALL=%v in backupbot exec invocation", showAllPaths)
+			execEnv = append(execEnv, fmt.Sprintf("SHOW_ALL=%v", showAllPaths))
 		}
 
-		if err := internal.RunBackupCmdRemote(cl, "ls", targetContainer.ID, execEnv); err != nil {
+		if timestamps {
+			log.Debugf("including TIMESTAMPS=%v in backupbot exec invocation", timestamps)
+			execEnv = append(execEnv, fmt.Sprintf("TIMESTAMPS=%v", timestamps))
+		}
+
+		if _, err = internal.RunBackupCmdRemote(cl, "ls", targetContainer.ID, execEnv); err != nil {
 			log.Fatal(err)
 		}
-
-		return nil
 	},
 }
 
-var appBackupDownloadCommand = cli.Command{
-	Name:    "download",
+var AppBackupDownloadCommand = &cobra.Command{
+	Use:     "download <domain> [flags]",
 	Aliases: []string{"d"},
-	Flags: []cli.Flag{
-		snapshotFlag,
-		includePathFlag,
+	Short:   "Download a snapshot",
+	Long: `Downloads a backup.tar.gz to the current working directory.
+
+"--volumes/-v" includes data contained in volumes alongide paths specified in
+"backupbot.backup.path" labels.`,
+	Args: cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	Usage:         "Download a backup",
-	UsageText:     "abra app backup download <domain> [options]",
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		if err := app.Recipe.EnsureExists(); err != nil {
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
-		if !internal.Chaos {
-			if err := app.Recipe.EnsureIsClean(); err != nil {
-				log.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := app.Recipe.EnsureUpToDate(); err != nil {
-					log.Fatal(err)
-				}
-			}
-
-			if err := app.Recipe.EnsureLatest(); err != nil {
-				log.Fatal(err)
-			}
-		}
-
 		cl, err := client.New(app.Server)
 		if err != nil {
 			log.Fatal(err)
@@ -127,17 +92,32 @@ var appBackupDownloadCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
+		execEnv := []string{
+			fmt.Sprintf("SERVICE=%s", app.Domain),
+			"MACHINE_LOGS=true",
+		}
+
 		if snapshot != "" {
 			log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
 			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
 		}
+
 		if includePath != "" {
 			log.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath)
 			execEnv = append(execEnv, fmt.Sprintf("INCLUDE_PATH=%s", includePath))
 		}
 
-		if err := internal.RunBackupCmdRemote(cl, "download", targetContainer.ID, execEnv); err != nil {
+		if includeSecrets {
+			log.Debugf("including SECRETS=%v in backupbot exec invocation", includeSecrets)
+			execEnv = append(execEnv, fmt.Sprintf("SECRETS=%v", includeSecrets))
+		}
+
+		if includeVolumes {
+			log.Debugf("including VOLUMES=%v in backupbot exec invocation", includeVolumes)
+			execEnv = append(execEnv, fmt.Sprintf("VOLUMES=%v", includeVolumes))
+		}
+
+		if _, err := internal.RunBackupCmdRemote(cl, "download", targetContainer.ID, execEnv); err != nil {
 			log.Fatal(err)
 		}
 
@@ -146,47 +126,27 @@ var appBackupDownloadCommand = cli.Command{
 		if err = CopyFromContainer(cl, targetContainer.ID, remoteBackupDir, currentWorkingDir); err != nil {
 			log.Fatal(err)
 		}
-
-		fmt.Println("backup successfully downloaded to current working directory")
-
-		return nil
 	},
 }
 
-var appBackupCreateCommand = cli.Command{
-	Name:    "create",
+var AppBackupCreateCommand = &cobra.Command{
+	Use:     "create <domain> [flags]",
 	Aliases: []string{"c"},
-	Flags: []cli.Flag{
-		resticRepoFlag,
+	Short:   "Create a new snapshot",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	Usage:         "Create a new backup",
-	UsageText:     "abra app backup create <domain> [options]",
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		if err := app.Recipe.EnsureExists(); err != nil {
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
-		if !internal.Chaos {
-			if err := app.Recipe.EnsureIsClean(); err != nil {
-				log.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := app.Recipe.EnsureUpToDate(); err != nil {
-					log.Fatal(err)
-				}
-			}
-
-			if err := app.Recipe.EnsureLatest(); err != nil {
-				log.Fatal(err)
-			}
-		}
-
 		cl, err := client.New(app.Server)
 		if err != nil {
 			log.Fatal(err)
@@ -197,53 +157,35 @@ var appBackupCreateCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
-		if resticRepo != "" {
-			log.Debugf("including RESTIC_REPO=%s in backupbot exec invocation", resticRepo)
-			execEnv = append(execEnv, fmt.Sprintf("RESTIC_REPO=%s", resticRepo))
+		execEnv := []string{
+			fmt.Sprintf("SERVICE=%s", app.Domain),
+			"MACHINE_LOGS=true",
 		}
 
-		if err := internal.RunBackupCmdRemote(cl, "create", targetContainer.ID, execEnv); err != nil {
+		if retries != "" {
+			log.Debugf("including RETRIES=%s in backupbot exec invocation", retries)
+			execEnv = append(execEnv, fmt.Sprintf("RETRIES=%s", retries))
+		}
+
+		if _, err := internal.RunBackupCmdRemote(cl, "create", targetContainer.ID, execEnv); err != nil {
 			log.Fatal(err)
 		}
-
-		return nil
 	},
 }
 
-var appBackupSnapshotsCommand = cli.Command{
-	Name:    "snapshots",
+var AppBackupSnapshotsCommand = &cobra.Command{
+	Use:     "snapshots <domain> [flags]",
 	Aliases: []string{"s"},
-	Flags: []cli.Flag{
-		snapshotFlag,
+	Short:   "List all snapshots",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	Usage:         "List backup snapshots",
-	UsageText:     "abra app backup snapshots <domain> [options]",
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-
-		if err := app.Recipe.EnsureExists(); err != nil {
-			log.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := app.Recipe.EnsureIsClean(); err != nil {
-				log.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := app.Recipe.EnsureUpToDate(); err != nil {
-					log.Fatal(err)
-				}
-			}
-
-			if err := app.Recipe.EnsureLatest(); err != nil {
-				log.Fatal(err)
-			}
-		}
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
@@ -255,29 +197,111 @@ var appBackupSnapshotsCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
-		if snapshot != "" {
-			log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
-			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
+		execEnv := []string{
+			fmt.Sprintf("SERVICE=%s", app.Domain),
+			"MACHINE_LOGS=true",
 		}
 
-		if err := internal.RunBackupCmdRemote(cl, "snapshots", targetContainer.ID, execEnv); err != nil {
+		if _, err = internal.RunBackupCmdRemote(cl, "snapshots", targetContainer.ID, execEnv); err != nil {
 			log.Fatal(err)
 		}
-
-		return nil
 	},
 }
 
-var appBackupCommand = cli.Command{
-	Name:      "backup",
-	Aliases:   []string{"b"},
-	Usage:     "Manage app backups",
-	UsageText: "abra app backup [command] [arguments] [options]",
-	Commands: []*cli.Command{
-		&appBackupListCommand,
-		&appBackupSnapshotsCommand,
-		&appBackupDownloadCommand,
-		&appBackupCreateCommand,
-	},
+var AppBackupCommand = &cobra.Command{
+	Use:     "backup [cmd] [args] [flags]",
+	Aliases: []string{"b"},
+	Short:   "Manage app backups",
+}
+
+var (
+	snapshot       string
+	retries        string
+	includePath    string
+	showAllPaths   bool
+	timestamps     bool
+	includeSecrets bool
+	includeVolumes bool
+)
+
+func init() {
+	AppBackupListCommand.Flags().StringVarP(
+		&snapshot,
+		"snapshot",
+		"s",
+		"",
+		"list specific snapshot",
+	)
+
+	AppBackupListCommand.Flags().BoolVarP(
+		&showAllPaths,
+		"all",
+		"a",
+		false,
+		"show all paths",
+	)
+
+	AppBackupListCommand.Flags().BoolVarP(
+		&timestamps,
+		"timestamps",
+		"t",
+		false,
+		"include timestamps",
+	)
+
+	AppBackupDownloadCommand.Flags().StringVarP(
+		&snapshot,
+		"snapshot",
+		"s",
+		"",
+		"list specific snapshot",
+	)
+
+	AppBackupDownloadCommand.Flags().StringVarP(
+		&includePath,
+		"path",
+		"p",
+		"",
+		"volumes path",
+	)
+
+	AppBackupDownloadCommand.Flags().BoolVarP(
+		&includeSecrets,
+		"secrets",
+		"S",
+		false,
+		"include secrets",
+	)
+
+	AppBackupDownloadCommand.Flags().BoolVarP(
+		&includeVolumes,
+		"volumes",
+		"v",
+		false,
+		"include volumes",
+	)
+
+	AppBackupDownloadCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+
+	AppBackupCreateCommand.Flags().StringVarP(
+		&retries,
+		"retries",
+		"r",
+		"1",
+		"number of retry attempts",
+	)
+
+	AppBackupCreateCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
 }

cli/app/check.go

@@ -1,7 +1,6 @@
 package app
 
 import (
-	"context"
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
@@ -10,15 +9,14 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/charmbracelet/lipgloss"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appCheckCommand = cli.Command{
-	Name:      "check",
-	Aliases:   []string{"chk"},
-	UsageText: "abra app check <domain> [options]",
-	Usage:     "Ensure an app is well configured",
-	Description: `Compare env vars in both the app ".env" and recipe ".env.sample" file.
+var AppCheckCommand = &cobra.Command{
+	Use:     "check <domain> [flags]",
+	Aliases: []string{"chk"},
+	Short:   "Ensure an app is well configured",
+	Long: `Compare env vars in both the app ".env" and recipe ".env.sample" file.
 
 The goal is to ensure that recipe ".env.sample" env vars are defined in your
 app ".env" file. Only env var definitions in the ".env.sample" which are
@@ -28,17 +26,17 @@ these env vars, then "check" will complain.
 Recipe maintainers may or may not provide defaults for env vars within their
 recipes regardless of commenting or not (e.g. through the use of
 ${FOO:<default>} syntax). "check" does not confirm or deny this for you.`,
-	Flags: []cli.Flag{
-		internal.ChaosFlag,
-		internal.OfflineFlag,
+	Args: cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
@@ -48,7 +46,10 @@ ${FOO:<default>} syntax). "check" does not confirm or deny this for you.`,
 		}
 
 		table.
-			Headers("RECIPE ENV SAMPLE", "APP ENV").
+			Headers(
+				fmt.Sprintf("%s .env.sample", app.Recipe.Name),
+				fmt.Sprintf("%s.env", app.Name),
+			).
 			StyleFunc(func(row, col int) lipgloss.Style {
 				switch {
 				case col == 1:
@@ -73,8 +74,18 @@ ${FOO:<default>} syntax). "check" does not confirm or deny this for you.`,
 			}
 		}
 
-		fmt.Println(table)
-
-		return nil
+		if err := formatter.PrintTable(table); err != nil {
+			log.Fatal(err)
+		}
 	},
 }
+
+func init() {
+	AppCheckCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+}

cli/app/cmd.go

@@ -1,66 +1,106 @@
 package app
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"os"
 	"os/exec"
+	"slices"
 	"sort"
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/app"
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appCmdCommand = cli.Command{
-	Name:      "command",
-	Aliases:   []string{"cmd"},
-	Usage:     "Run app commands",
-	UsageText: "abra app cmd <domain> [<service>] <cmd> [<cmd-args>] [options]",
-	Description: `Run an app specific command.
+var AppCmdCommand = &cobra.Command{
+	Use:     "command <domain> [service | --local] <cmd> [[args] [flags] | [flags] -- [args]]",
+	Aliases: []string{"cmd"},
+	Short:   "Run app commands",
+	Long: `Run an app specific command.
 
 These commands are bash functions, defined in the abra.sh of the recipe itself.
 They can be run within the context of a service (e.g. app) or locally on your
-work station by passing "--local".`,
-	Flags: []cli.Flag{
-		internal.LocalCmdFlag,
-		internal.RemoteUserFlag,
-		internal.TtyFlag,
-		internal.ChaosFlag,
+work station by passing "--local/-l".
+
+N.B. If using the "--" style to pass arguments, flags (e.g. "--local/-l") must
+be passed *before* the "--". It is possible to pass arguments without the "--"
+as long as no dashes are present (i.e. "foo" works without "--", "-foo"
+does not).`,
+	Example: `  # pass <cmd> args/flags without "--"
+  abra app cmd 1312.net app my_cmd_arg foo --user bar
+
+  # pass <cmd> args/flags with "--"
+  abra app cmd 1312.net app my_cmd_args --user bar -- foo -vvv
+
+  # drop the [service] arg if using "--local/-l"
+  abra app cmd 1312.net my_cmd --local`,
+	Args: func(cmd *cobra.Command, args []string) error {
+		if local {
+			if !(len(args) >= 2) {
+				return errors.New("requires at least 2 arguments with --local/-l")
+			}
+
+			if slices.Contains(os.Args, "--") {
+				if cmd.ArgsLenAtDash() > 2 {
+					return errors.New("accepts at most 2 args with --local/-l")
+				}
+			}
+
+			// NOTE(d1): it is unclear how to correctly validate this case
+			//
+			// abra app cmd 1312.net app test_cmd_args foo --local
+			// FATAL <recipe> doesn't have a app function
+			//
+			// "app" should not be there, but there is no reliable way to detect arg
+			// count when the user can pass an arbitrary amount of recipe command
+			// arguments
+			return nil
+		}
+
+		if !(len(args) >= 3) {
+			return errors.New("requires at least 3 arguments")
+		}
+
+		return nil
 	},
-	Before: internal.SubCommandBefore,
-	Commands: []*cli.Command{
-		&appCmdListCommand,
-	},
-	ShellComplete: func(ctx context.Context, cmd *cli.Command) {
-		args := cmd.Args()
-		switch args.Len() {
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
 		case 0:
-			autocomplete.AppNameComplete(ctx, cmd)
+			return autocomplete.AppNameComplete()
 		case 1:
-			autocomplete.ServiceNameComplete(args.Get(0))
+			if !local {
+				return autocomplete.ServiceNameComplete(args[0])
+			}
+			return autocomplete.CommandNameComplete(args[0])
 		case 2:
-			cmdNameComplete(args.Get(0))
+			if !local {
+				return autocomplete.CommandNameComplete(args[0])
+			}
+			return nil, cobra.ShellCompDirectiveDefault
+		default:
+			return nil, cobra.ShellCompDirectiveError
 		}
 	},
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
-		if internal.LocalCmd && internal.RemoteUser != "" {
-			internal.ShowSubcommandHelpAndError(cmd, errors.New("cannot use --local & --user together"))
+		if local && remoteUser != "" {
+			log.Fatal("cannot use --local & --user together")
 		}
 
-		hasCmdArgs, parsedCmdArgs := parseCmdArgs(cmd.Args().Slice(), internal.LocalCmd)
+		hasCmdArgs, parsedCmdArgs := parseCmdArgs(args, local)
 
 		if _, err := os.Stat(app.Recipe.AbraShPath); err != nil {
 			if os.IsNotExist(err) {
@@ -69,12 +109,8 @@ work station by passing "--local".`,
 			log.Fatal(err)
 		}
 
-		if internal.LocalCmd {
-			if !(cmd.Args().Len() >= 2) {
-				internal.ShowSubcommandHelpAndError(cmd, errors.New("missing arguments"))
-			}
-
-			cmdName := cmd.Args().Get(1)
+		if local {
+			cmdName := args[1]
 			if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
 				log.Fatal(err)
 			}
@@ -105,53 +141,78 @@ work station by passing "--local".`,
 			if err := internal.RunCmd(cmd); err != nil {
 				log.Fatal(err)
 			}
-		} else {
-			if !(cmd.Args().Len() >= 3) {
-				internal.ShowSubcommandHelpAndError(cmd, errors.New("missing arguments"))
-			}
 
-			targetServiceName := cmd.Args().Get(1)
+			return
+		}
 
-			cmdName := cmd.Args().Get(2)
-			if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
-				log.Fatal(err)
-			}
+		cmdName := args[2]
+		if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
+			log.Fatal(err)
+		}
 
-			serviceNames, err := appPkg.GetAppServiceNames(app.Name)
-			if err != nil {
-				log.Fatal(err)
-			}
+		serviceNames, err := appPkg.GetAppServiceNames(app.Name)
+		if err != nil {
+			log.Fatal(err)
+		}
 
-			matchingServiceName := false
-			for _, serviceName := range serviceNames {
-				if serviceName == targetServiceName {
-					matchingServiceName = true
-				}
-			}
-
-			if !matchingServiceName {
-				log.Fatalf("no service %s for %s?", targetServiceName, app.Name)
-			}
-
-			log.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName)
-
-			if hasCmdArgs {
-				log.Debugf("parsed following command arguments: %s", parsedCmdArgs)
-			} else {
-				log.Debug("did not detect any command arguments")
-			}
-
-			cl, err := client.New(app.Server)
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			if err := internal.RunCmdRemote(cl, app, app.Recipe.AbraShPath, targetServiceName, cmdName, parsedCmdArgs); err != nil {
-				log.Fatal(err)
+		matchingServiceName := false
+		targetServiceName := args[1]
+		for _, serviceName := range serviceNames {
+			if serviceName == targetServiceName {
+				matchingServiceName = true
 			}
 		}
 
-		return nil
+		if !matchingServiceName {
+			log.Fatalf("no service %s for %s?", targetServiceName, app.Name)
+		}
+
+		log.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName)
+
+		if hasCmdArgs {
+			log.Debugf("parsed following command arguments: %s", parsedCmdArgs)
+		} else {
+			log.Debug("did not detect any command arguments")
+		}
+
+		cl, err := client.New(app.Server)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if err := internal.RunCmdRemote(
+			cl,
+			app,
+			disableTTY,
+			app.Recipe.AbraShPath,
+			targetServiceName, cmdName, parsedCmdArgs, remoteUser); err != nil {
+			log.Fatal(err)
+		}
+	},
+}
+
+var AppCmdListCommand = &cobra.Command{
+	Use:     "list <domain> [flags]",
+	Aliases: []string{"ls"},
+	Short:   "List all available commands",
+	Args:    cobra.MinimumNArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
+		}
+
+		cmdNames, err := appPkg.ReadAbraShCmdNames(app.Recipe.AbraShPath)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		sort.Strings(cmdNames)
+
+		for _, cmdName := range cmdNames {
+			fmt.Println(cmdName)
+		}
 	},
 }
 
@@ -174,73 +235,42 @@ func parseCmdArgs(args []string, isLocal bool) (bool, string) {
 	return hasCmdArgs, parsedCmdArgs
 }
 
-func cmdNameComplete(appName string) {
-	app, err := app.Get(appName)
-	if err != nil {
-		return
-	}
-	cmdNames, _ := getShCmdNames(app)
-	if err != nil {
-		return
-	}
-	for _, n := range cmdNames {
-		fmt.Println(n)
-	}
-}
-
-var appCmdListCommand = cli.Command{
-	Name:      "list",
-	Aliases:   []string{"ls"},
-	Usage:     "List all available commands",
-	UsageText: "abra app cmd ls <domain> [options]",
-	Flags: []cli.Flag{
-		internal.ChaosFlag,
-	},
-	ShellComplete: autocomplete.AppNameComplete,
-	Before:        internal.SubCommandBefore,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-
-		if err := app.Recipe.EnsureExists(); err != nil {
-			log.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := app.Recipe.EnsureIsClean(); err != nil {
-				log.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := app.Recipe.EnsureUpToDate(); err != nil {
-					log.Fatal(err)
-				}
-			}
-
-			if err := app.Recipe.EnsureLatest(); err != nil {
-				log.Fatal(err)
-			}
-		}
-
-		cmdNames, err := getShCmdNames(app)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		for _, cmdName := range cmdNames {
-			fmt.Println(cmdName)
-		}
-
-		return nil
-	},
-}
-
-func getShCmdNames(app appPkg.App) ([]string, error) {
-	cmdNames, err := appPkg.ReadAbraShCmdNames(app.Recipe.AbraShPath)
-	if err != nil {
-		return nil, err
-	}
-
-	sort.Strings(cmdNames)
-	return cmdNames, nil
+var (
+	local      bool
+	remoteUser string
+	disableTTY bool
+)
+
+func init() {
+	AppCmdCommand.Flags().BoolVarP(
+		&local,
+		"local",
+		"l",
+		false,
+		"run command locally",
+	)
+
+	AppCmdCommand.Flags().StringVarP(
+		&remoteUser,
+		"user",
+		"u",
+		"",
+		"request remote user",
+	)
+
+	AppCmdCommand.Flags().BoolVarP(
+		&disableTTY,
+		"tty",
+		"T",
+		false,
+		"disable remote TTY",
+	)
+
+	AppCmdCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
 }

cli/app/cmd_test.go

@@ -13,7 +13,7 @@ func TestParseCmdArgs(t *testing.T) {
 	}{
 		// `--` is not parsed when passed in from the command-line e.g. -- foo bar baz
 		// so we need to eumlate that as missing when testing if bash args are passed in
-		// see https://git.coopcloud.tech/coop-cloud/organising/issues/336 for more
+		// see https://git.coopcloud.tech/toolshed/organising/issues/336 for more
 		{[]string{"foo.com", "app", "test"}, false, ""},
 		{[]string{"foo.com", "app", "test", "foo"}, true, "foo "},
 		{[]string{"foo.com", "app", "test", "foo", "bar", "baz"}, true, "foo bar baz "},

cli/app/config.go

@@ -1,39 +1,35 @@
 package app
 
 import (
-	"context"
-	"errors"
 	"os"
 	"os/exec"
 
-	"coopcloud.tech/abra/cli/internal"
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appConfigCommand = cli.Command{
-	Name:          "config",
-	Aliases:       []string{"cfg"},
-	Usage:         "Edit app config",
-	UsageText:     "abra app config <domain> [options]",
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		appName := cmd.Args().First()
-
-		if appName == "" {
-			internal.ShowSubcommandHelpAndError(cmd, errors.New("no app provided"))
-		}
-
+var AppConfigCommand = &cobra.Command{
+	Use:     "config <domain> [flags]",
+	Aliases: []string{"cfg"},
+	Short:   "Edit app config",
+	Example: "  abra config 1312.net",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
 		files, err := appPkg.LoadAppFiles("")
 		if err != nil {
 			log.Fatal(err)
 		}
 
+		appName := args[0]
 		appFile, exists := files[appName]
 		if !exists {
 			log.Fatalf("cannot find app with name %s", appName)
@@ -57,7 +53,5 @@ var appConfigCommand = cli.Command{
 		if err := c.Run(); err != nil {
 			log.Fatal(err)
 		}
-
-		return nil
 	},
 }

cli/app/cp.go

@@ -18,45 +18,43 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/docker/api/types"
+	containertypes "github.com/docker/docker/api/types/container"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/docker/docker/errdefs"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appCpCommand = cli.Command{
-	Name:      "cp",
-	Aliases:   []string{"c"},
-	Before:    internal.SubCommandBefore,
-	Usage:     "Copy files to/from a deployed app service",
-	UsageText: "abra app cp <domain> <src> <dst> [options]",
-	Description: `Copy files to and from any app service file system.
+var AppCpCommand = &cobra.Command{
+	Use:     "cp <domain> <src> <dst> [flags]",
+	Aliases: []string{"c"},
+	Short:   "Copy files to/from a deployed app service",
+	Example: `  # copy myfile.txt to the root of the app service
+  abra app cp 1312.net myfile.txt app:/
 
-If you want to copy a myfile.txt to the root of the app service:
+  # copy that file back to your current working directory locally
+  abra app cp 1312.net app:/myfile.txt ./`,
+	Args: cobra.ExactArgs(3),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-    abra app cp <domain> myfile.txt app:/
-
-And if you want to copy that file back to your current working directory locally:
-
-    abra app cp <domain> app:/myfile.txt`,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
-		src := cmd.Args().Get(1)
-		dst := cmd.Args().Get(2)
-		if src == "" {
-			log.Fatal("missing <src> argument")
-		}
-		if dst == "" {
-			log.Fatal("missing <dest> argument")
-		}
-
+		src := args[1]
+		dst := args[2]
 		srcPath, dstPath, service, toContainer, err := parseSrcAndDst(src, dst)
 		if err != nil {
 			log.Fatal(err)
@@ -81,8 +79,6 @@ And if you want to copy that file back to your current working directory locally
 		if err != nil {
 			log.Fatal(err)
 		}
-
-		return nil
 	},
 }
 
@@ -138,7 +134,7 @@ func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 		if err != nil {
 			return err
 		}
-		if _, err := container.RunExec(dcli, cl, containerID, &types.ExecConfig{
+		if _, err := container.RunExec(dcli, cl, containerID, &containertypes.ExecOptions{
 			AttachStderr: true,
 			AttachStdin:  true,
 			AttachStdout: true,
@@ -166,7 +162,7 @@ func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 	}
 
 	log.Debugf("copy %s from local to %s on container", srcPath, dstPath)
-	copyOpts := types.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
+	copyOpts := containertypes.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
 	if err := cl.CopyToContainer(context.Background(), containerID, dstPath, content, copyOpts); err != nil {
 		return err
 	}
@@ -177,7 +173,7 @@ func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 		if err != nil {
 			return err
 		}
-		if _, err := container.RunExec(dcli, cl, containerID, &types.ExecConfig{
+		if _, err := container.RunExec(dcli, cl, containerID, &containertypes.ExecOptions{
 			AttachStderr: true,
 			AttachStdin:  true,
 			AttachStdout: true,
@@ -375,3 +371,13 @@ func moveFile(sourcePath, destPath string) error {
 	}
 	return nil
 }
+
+func init() {
+	AppCpCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+}

cli/app/deploy.go

@@ -3,8 +3,10 @@ package app
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/envfile"
@@ -17,157 +19,104 @@ import (
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/urfave/cli/v3"
+	dockerClient "github.com/docker/docker/client"
+	"github.com/spf13/cobra"
 )
 
-var appDeployCommand = cli.Command{
-	Name:      "deploy",
-	Aliases:   []string{"d"},
-	Usage:     "Deploy an app",
-	UsageText: "abra app deploy <domain> [<version>] [options]",
-	Flags: []cli.Flag{
-		internal.ForceFlag,
-		internal.ChaosFlag,
-		internal.NoDomainChecksFlag,
-		internal.DontWaitConvergeFlag,
+var AppDeployCommand = &cobra.Command{
+	Use:     "deploy <domain> [version] [flags]",
+	Aliases: []string{"d"},
+	Short:   "Deploy an app",
+	Long: `Deploy an app.
+
+This command supports chaos operations. Use "--chaos/-C" to deploy your recipe
+checkout as-is. Recipe commit hashes are also supported as values for
+"[version]". Please note, "upgrade"/"rollback" do not support chaos operations.`,
+	Example: `  # standard deployment
+  abra app deploy 1312.net
+
+  # chaos deployment
+  abra app deploy 1312.net --chaos
+  
+  # deploy specific version
+  abra app deploy 1312.net 2.0.0+1.2.3
+
+  # deploy a specific git hash
+  abra app deploy 1312.net 886db76d`,
+	Args: cobra.RangeArgs(1, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string,
+	) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		case 1:
+			app, err := appPkg.Get(args[0])
+			if err != nil {
+				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
+				return []string{errMsg}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.RecipeVersionComplete(app.Recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
 	},
-	Before: internal.SubCommandBefore,
-	Description: `Deploy an app.
+	Run: func(cmd *cobra.Command, args []string) {
+		var (
+			deployWarnMessages []string
+			toDeployVersion    string
+		)
 
-This command supports chaos operations. Use "--chaos" to deploy your recipe
-checkout as-is. Recipe commit hashes are also supported values for
-"[<version>]". Please note, "upgrade"/"rollback" do not support chaos
-operations.`,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		var warnMessages []string
+		app := internal.ValidateApp(args)
 
-		app := internal.ValidateApp(cmd)
-		stackName := app.StackName()
-
-		specificVersion := cmd.Args().Get(1)
-		if specificVersion == "" {
-			specificVersion = app.Recipe.Version
-		}
-
-		if specificVersion != "" && internal.Chaos {
-			log.Fatal("cannot use <version> and --chaos together")
-		}
-
-		if specificVersion != "" {
-			log.Debugf("overriding env file version (%s) with %s", app.Recipe.Version, specificVersion)
-			app.Recipe.Version = specificVersion
-		}
-
-		if specificVersion == "" && app.Recipe.Version != "" && !internal.Chaos {
-			log.Debugf("retrieved %s as version from env file", app.Recipe.Version)
-			specificVersion = app.Recipe.Version
-		}
-
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+		if err := validateArgsAndFlags(args); err != nil {
 			log.Fatal(err)
 		}
 
-		if err := lint.LintForErrors(app.Recipe); err != nil {
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
-		log.Debugf("checking whether %s is already deployed", stackName)
-
 		cl, err := client.New(app.Server)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
+		log.Debugf("checking whether %s is already deployed", app.StackName())
+
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		// NOTE(d1): handles "<version> as git hash" use case
-		var isChaosCommit bool
-
-		// NOTE(d1): check out specific version before dealing with secrets. This
-		// is because we need to deal with GetComposeFiles under the hood and these
-		// files change from version to version which therefore affects which
-		// secrets might be generated
-		version := deployMeta.Version
-		if specificVersion != "" {
-			version = specificVersion
-			log.Debugf("choosing %s as version to deploy", version)
-
-			var err error
-			isChaosCommit, err = app.Recipe.EnsureVersion(version)
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			if isChaosCommit {
-				log.Debugf("assuming '%s' is a chaos commit", version)
-				internal.Chaos = true
-			}
+		if deployMeta.IsDeployed && !(internal.Force || internal.Chaos) {
+			log.Fatalf("%s is already deployed", app.Name)
 		}
 
-		secStats, err := secret.PollSecretsStatus(cl, app)
+		toDeployVersion, err = getDeployVersion(args, deployMeta, app)
 		if err != nil {
-			log.Fatal(err)
+			log.Fatal(fmt.Errorf("get deploy version: %s", err))
 		}
 
-		for _, secStat := range secStats {
-			if !secStat.CreatedOnRemote {
-				log.Fatalf("unable to deploy, secrets not generated (%s)?", secStat.LocalName)
-			}
-		}
-
-		if deployMeta.IsDeployed {
-			if internal.Force || internal.Chaos {
-				warnMessages = append(warnMessages, fmt.Sprintf("%s is already deployed", app.Name))
-			} else {
-				log.Fatalf("%s is already deployed", app.Name)
-			}
-		}
-
-		if !internal.Chaos && specificVersion == "" {
-			versions, err := app.Recipe.Tags()
+		if !internal.Chaos {
+			_, err = app.Recipe.EnsureVersion(toDeployVersion)
 			if err != nil {
+				log.Fatalf("ensure recipe: %s", err)
+			}
+		}
+
+		if err := lint.LintForErrors(app.Recipe); err != nil {
+			if internal.Chaos {
+				log.Warn(err)
+			} else {
 				log.Fatal(err)
 			}
-
-			if len(versions) > 0 && !internal.Chaos {
-				version = versions[len(versions)-1]
-				log.Debugf("choosing %s as version to deploy", version)
-				if _, err := app.Recipe.EnsureVersion(version); err != nil {
-					log.Fatal(err)
-				}
-			} else {
-				head, err := app.Recipe.Head()
-				if err != nil {
-					log.Fatal(err)
-				}
-				version = formatter.SmallSHA(head.String())
-				warnMessages = append(warnMessages, fmt.Sprintf("no versions detected, using latest commit"))
-			}
 		}
 
-		chaosVersion := config.CHAOS_DEFAULT
-		if internal.Chaos {
-			warnMessages = append(warnMessages, "chaos mode engaged")
-
-			if isChaosCommit {
-				chaosVersion = specificVersion
-				versionLabelLocal, err := app.Recipe.GetVersionLabelLocal()
-				if err != nil {
-					log.Fatal(err)
-				}
-				version = versionLabelLocal
-			} else {
-				var err error
-				chaosVersion, err = app.Recipe.ChaosVersion()
-				if err != nil {
-					log.Fatal(err)
-				}
-			}
+		if err := validateSecrets(cl, app); err != nil {
+			log.Fatal(err)
 		}
 
 		abraShEnv, err := envfile.ReadAbraShEnvVars(app.Recipe.AbraShPath)
@@ -183,6 +132,7 @@ operations.`,
 			log.Fatal(err)
 		}
 
+		stackName := app.StackName()
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
@@ -198,8 +148,11 @@ operations.`,
 		appPkg.ExposeAllEnv(stackName, compose, app.Env)
 		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
 		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
-		appPkg.SetChaosVersionLabel(compose, stackName, chaosVersion)
+		if internal.Chaos {
+			appPkg.SetChaosVersionLabel(compose, stackName, toDeployVersion)
+		}
 		appPkg.SetUpdateLabel(compose, stackName, app.Env)
+		appPkg.SetVersionLabel(compose, stackName, toDeployVersion)
 
 		envVars, err := appPkg.CheckEnv(app)
 		if err != nil {
@@ -208,26 +161,36 @@ operations.`,
 
 		for _, envVar := range envVars {
 			if !envVar.Present {
-				warnMessages = append(warnMessages,
-					fmt.Sprintf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain),
+				deployWarnMessages = append(deployWarnMessages,
+					fmt.Sprintf("%s missing from %s.env", envVar.Name, app.Domain),
 				)
 			}
 		}
 
 		if !internal.NoDomainChecks {
-			domainName, ok := app.Env["DOMAIN"]
-			if ok {
+			if domainName, ok := app.Env["DOMAIN"]; ok {
 				if _, err = dns.EnsureDomainsResolveSameIPv4(domainName, app.Server); err != nil {
 					log.Fatal(err)
 				}
 			} else {
-				warnMessages = append(warnMessages, "skipping domain checks as no DOMAIN=... configured for app")
+				log.Debug("skipping domain checks, no DOMAIN=... configured")
 			}
 		} else {
-			warnMessages = append(warnMessages, "skipping domain checks as requested")
+			log.Debug("skipping domain checks")
 		}
 
-		if err := internal.DeployOverview(app, warnMessages, version, chaosVersion); err != nil {
+		deployedVersion := config.NO_VERSION_DEFAULT
+		if deployMeta.IsDeployed {
+			deployedVersion = deployMeta.Version
+		}
+
+		if err := internal.DeployOverview(
+			app,
+			deployedVersion,
+			toDeployVersion,
+			"",
+			deployWarnMessages,
+		); err != nil {
 			log.Fatal(err)
 		}
 
@@ -235,9 +198,28 @@ operations.`,
 		if err != nil {
 			log.Fatal(err)
 		}
-		log.Debugf("set waiting timeout to %d s", stack.WaitTimeout)
 
-		if err := stack.RunDeploy(cl, deployOpts, compose, app.Name, internal.DontWaitConverge); err != nil {
+		log.Debugf("set waiting timeout to %d second(s)", stack.WaitTimeout)
+
+		serviceNames, err := appPkg.GetAppServiceNames(app.Name)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		f, err := app.Filters(true, false, serviceNames...)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if err := stack.RunDeploy(
+			cl,
+			deployOpts,
+			compose,
+			app.Name,
+			app.Server,
+			internal.DontWaitConverge,
+			f,
+		); err != nil {
 			log.Fatal(err)
 		}
 
@@ -249,15 +231,124 @@ operations.`,
 			}
 		}
 
-		app.Recipe.Version = version
-		if chaosVersion != config.CHAOS_DEFAULT {
-			app.Recipe.Version = chaosVersion
+		if err := app.WriteRecipeVersion(toDeployVersion, false); err != nil {
+			log.Fatalf("writing recipe version failed: %s", err)
 		}
-		log.Debugf("choosing %s as version to save to env file", app.Recipe.Version)
-		if err := app.WriteRecipeVersion(app.Recipe.Version, false); err != nil {
-			log.Fatalf("writing new recipe version in env file: %s", err)
-		}
-
-		return nil
 	},
 }
+
+func getLatestVersionOrCommit(app app.App) (string, error) {
+	versions, err := app.Recipe.Tags()
+	if err != nil {
+		return "", err
+	}
+
+	if len(versions) > 0 && !internal.Chaos {
+		return versions[len(versions)-1], nil
+	}
+
+	head, err := app.Recipe.Head()
+	if err != nil {
+		return "", err
+	}
+
+	return formatter.SmallSHA(head.String()), nil
+}
+
+// validateArgsAndFlags ensures compatible args/flags.
+func validateArgsAndFlags(args []string) error {
+	if len(args) == 2 && args[1] != "" && internal.Chaos {
+		return fmt.Errorf("cannot use [version] and --chaos together")
+	}
+
+	return nil
+}
+
+func validateSecrets(cl *dockerClient.Client, app app.App) error {
+	secStats, err := secret.PollSecretsStatus(cl, app)
+	if err != nil {
+		return err
+	}
+
+	for _, secStat := range secStats {
+		if !secStat.CreatedOnRemote {
+			return fmt.Errorf("secret not generated: %s", secStat.LocalName)
+		}
+	}
+
+	return nil
+}
+
+func getDeployVersion(cliArgs []string, deployMeta stack.DeployMeta, app app.App) (string, error) {
+	// Chaos mode overrides everything
+	if internal.Chaos {
+		v, err := app.Recipe.ChaosVersion()
+		if err != nil {
+			return "", err
+		}
+		log.Debugf("version: taking chaos version: %s", v)
+		return v, nil
+	}
+
+	// Check if the deploy version is set with a cli argument
+	if len(cliArgs) == 2 && cliArgs[1] != "" {
+		log.Debugf("version: taking version from cli arg: %s", cliArgs[1])
+		return cliArgs[1], nil
+	}
+
+	// Check if the recipe has a version in the .env file
+	if app.Recipe.EnvVersion != "" && !internal.IgnoreEnvVersion {
+		if strings.HasSuffix(app.Recipe.EnvVersionRaw, "+U") {
+			return "", fmt.Errorf("version: can not redeploy chaos version %s", app.Recipe.EnvVersionRaw)
+		}
+		log.Debugf("version: taking version from .env file: %s", app.Recipe.EnvVersion)
+		return app.Recipe.EnvVersion, nil
+	}
+
+	// Take deployed version
+	if deployMeta.IsDeployed {
+		log.Debugf("version: taking deployed version: %s", deployMeta.Version)
+		return deployMeta.Version, nil
+	}
+
+	v, err := getLatestVersionOrCommit(app)
+	log.Debugf("version: taking new recipe version: %s", v)
+	if err != nil {
+		return "", err
+	}
+	return v, nil
+}
+
+func init() {
+	AppDeployCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+
+	AppDeployCommand.Flags().BoolVarP(
+		&internal.Force,
+		"force",
+		"f",
+		false,
+		"perform action without further prompt",
+	)
+
+	AppDeployCommand.Flags().BoolVarP(
+		&internal.NoDomainChecks,
+		"no-domain-checks",
+		"D",
+		false,
+		"disable public DNS checks",
+	)
+
+	AppDeployCommand.Flags().BoolVarP(
+		&internal.DontWaitConverge,
+		"no-converge-checks",
+		"c",
+		false,
+		"disable converge logic checks",
+	)
+}

cli/app/env.go

@@ -0,0 +1,43 @@
+package app
+
+import (
+	"fmt"
+	"sort"
+
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
+	"coopcloud.tech/abra/pkg/formatter"
+	"github.com/spf13/cobra"
+)
+
+var AppEnvCommand = &cobra.Command{
+	Use:     "env <domain> [flags]",
+	Aliases: []string{"e"},
+	Short:   "Show app .env values",
+	Example: "  abra app env 1312.net",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		var envKeys []string
+		for k := range app.Env {
+			envKeys = append(envKeys, k)
+		}
+
+		sort.Strings(envKeys)
+
+		var rows [][]string
+		for _, k := range envKeys {
+			rows = append(rows, []string{k, app.Env[k]})
+		}
+
+		overview := formatter.CreateOverview("ENV OVERVIEW", rows)
+		fmt.Println(overview)
+	},
+}

cli/app/labels.go

@@ -0,0 +1,139 @@
+package app
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
+	"coopcloud.tech/abra/pkg/client"
+	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/upstream/convert"
+	composetypes "github.com/docker/cli/cli/compose/types"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/filters"
+	dockerClient "github.com/docker/docker/client"
+	"github.com/spf13/cobra"
+)
+
+var AppLabelsCommand = &cobra.Command{
+	Use:     "labels <domain> [flags]",
+	Aliases: []string{"lb"},
+	Short:   "Show deployment labels",
+	Long:    "Both local recipe and live deployment labels are shown.",
+	Example: "  abra app labels 1312.net",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
+		}
+
+		cl, err := client.New(app.Server)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		remoteLabels, err := getLabels(cl, app.StackName())
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		rows := [][]string{
+			{"DEPLOYED LABELS", "---"},
+		}
+
+		remoteLabelKeys := make([]string, 0, len(remoteLabels))
+		for k := range remoteLabels {
+			remoteLabelKeys = append(remoteLabelKeys, k)
+		}
+
+		sort.Strings(remoteLabelKeys)
+
+		for _, k := range remoteLabelKeys {
+			rows = append(rows, []string{
+				k,
+				remoteLabels[k],
+			})
+		}
+
+		if len(remoteLabelKeys) == 0 {
+			rows = append(rows, []string{"unknown"})
+		}
+
+		rows = append(rows, []string{"RECIPE LABELS", "---"})
+
+		config, err := app.Recipe.GetComposeConfig(app.Env)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		var localLabelKeys []string
+		var appServiceConfig composetypes.ServiceConfig
+		for _, service := range config.Services {
+			if service.Name == "app" {
+				appServiceConfig = service
+
+				for k := range service.Deploy.Labels {
+					localLabelKeys = append(localLabelKeys, k)
+				}
+			}
+		}
+
+		sort.Strings(localLabelKeys)
+
+		for _, k := range localLabelKeys {
+			rows = append(rows, []string{
+				k,
+				appServiceConfig.Deploy.Labels[k],
+			})
+		}
+
+		overview := formatter.CreateOverview("LABELS OVERVIEW", rows)
+		fmt.Println(overview)
+	},
+}
+
+// getLabels reads docker labels from running services in the format of "coop-cloud.${STACK_NAME}.${LABEL}".
+func getLabels(cl *dockerClient.Client, stackName string) (map[string]string, error) {
+	labels := make(map[string]string)
+
+	filter := filters.NewArgs()
+	filter.Add("label", fmt.Sprintf("%s=%s", convert.LabelNamespace, stackName))
+
+	services, err := cl.ServiceList(context.Background(), types.ServiceListOptions{Filters: filter})
+	if err != nil {
+		return labels, err
+	}
+
+	for _, service := range services {
+		if service.Spec.Name != fmt.Sprintf("%s_app", stackName) {
+			continue
+		}
+
+		for k, v := range service.Spec.Labels {
+			labels[k] = v
+		}
+	}
+
+	return labels, nil
+}
+
+func init() {
+	AppLabelsCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+}

cli/app/list.go

@@ -1,7 +1,6 @@
 package app
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"sort"
@@ -10,42 +9,11 @@ import (
 
 	"coopcloud.tech/abra/cli/internal"
 	appPkg "coopcloud.tech/abra/pkg/app"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/tagcmp"
-	"github.com/urfave/cli/v3"
-)
-
-var (
-	status     bool
-	statusFlag = &cli.BoolFlag{
-		Name:        "status",
-		Aliases:     []string{"S"},
-		Usage:       "Show app deployment status",
-		Destination: &status,
-	}
-)
-
-var (
-	recipeFilter string
-	recipeFlag   = &cli.StringFlag{
-		Name:        "recipe",
-		Aliases:     []string{"r"},
-		Value:       "",
-		Usage:       "Show apps of a specific recipe",
-		Destination: &recipeFilter,
-	}
-)
-
-var (
-	listAppServer     string
-	listAppServerFlag = &cli.StringFlag{
-		Name:        "server",
-		Aliases:     []string{"s"},
-		Value:       "",
-		Usage:       "Show apps of a specific server",
-		Destination: &listAppServer,
-	}
+	"github.com/spf13/cobra"
 )
 
 type appStatus struct {
@@ -70,25 +38,23 @@ type serverStatus struct {
 	UpgradeCount     int         `json:"upgradeCount"`
 }
 
-var appListCommand = cli.Command{
-	Name:      "list",
-	Aliases:   []string{"ls"},
-	Usage:     "List all managed apps",
-	UsageText: "abra app list [options]",
-	Description: `Generate a report of all managed apps.
+var AppListCommand = &cobra.Command{
+	Use:     "list [flags]",
+	Aliases: []string{"ls"},
+	Short:   "List all managed apps",
+	Long: `Generate a report of all managed apps.
 
-By passing the "--status/-S" flag, you can query all your servers for the
-actual live deployment status. Depending on how many servers you manage, this
-can take some time.`,
-	Flags: []cli.Flag{
-		internal.MachineReadableFlag,
-		statusFlag,
-		listAppServerFlag,
-		recipeFlag,
-	},
-	Before:   internal.SubCommandBefore,
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
+Use "--status/-S" flag to query all servers for the live deployment status.`,
+	Example: `  # list apps of all servers without live status
+  abra app ls
+
+  # list apps of a specific server with live status
+  abra app ls -s 1312.net -S
+
+  # list apps of all servers which match a specific recipe
+  abra app ls -r gitea`,
+	Args: cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
 		appFiles, err := appPkg.LoadAppFiles(listAppServer)
 		if err != nil {
 			log.Fatal(err)
@@ -176,10 +142,14 @@ can take some time.`,
 					appStats.AutoUpdate = autoUpdate
 
 					var newUpdates []string
-					if version != "unknown" {
+					if version != "unknown" && chaos == "false" {
+						if err := app.Recipe.EnsureExists(); err != nil {
+							log.Fatalf("unable to clone %s: %s", app.Name, err)
+						}
+
 						updates, err := app.Recipe.Tags()
 						if err != nil {
-							log.Fatal(err)
+							log.Fatalf("unable to retrieve tags for %s: %s", app.Name, err)
 						}
 
 						parsedVersion, err := tagcmp.Parse(version)
@@ -207,7 +177,7 @@ can take some time.`,
 							stats.LatestCount++
 						}
 					} else {
-						newUpdates = internal.ReverseStringList(newUpdates)
+						newUpdates = internal.SortVersionsDesc(newUpdates)
 						appStats.Upgrade = strings.Join(newUpdates, "\n")
 						stats.UpgradeCount++
 					}
@@ -230,7 +200,8 @@ can take some time.`,
 			} else {
 				fmt.Println(string(jsonstring))
 			}
-			return nil
+
+			return
 		}
 
 		alreadySeen := make(map[string]bool)
@@ -241,7 +212,7 @@ can take some time.`,
 
 			serverStat := allStats[app.Server]
 
-			headers := []string{"RECIPE", "DOMAIN"}
+			headers := []string{"RECIPE", "DOMAIN", "SERVER"}
 			if status {
 				headers = append(headers, []string{
 					"STATUS",
@@ -261,7 +232,7 @@ can take some time.`,
 
 			var rows [][]string
 			for _, appStat := range serverStat.Apps {
-				row := []string{appStat.Recipe, appStat.Domain}
+				row := []string{appStat.Recipe, appStat.Domain, appStat.Server}
 				if status {
 					chaosStatus := appStat.Chaos
 					if chaosStatus != "unknown" {
@@ -289,20 +260,8 @@ can take some time.`,
 			table.Rows(rows...)
 
 			if len(rows) > 0 {
-				fmt.Println(table)
-
-				if status {
-					fmt.Println(fmt.Sprintf(
-						"SERVER: %s | TOTAL APPS: %v | VERSIONED: %v | UNVERSIONED: %v | LATEST : %v | UPGRADE: %v",
-						app.Server,
-						serverStat.AppCount,
-						serverStat.VersionCount,
-						serverStat.UnversionedCount,
-						serverStat.LatestCount,
-						serverStat.UpgradeCount,
-					))
-				} else {
-					log.Infof("SERVER: %s TOTAL APPS: %v", app.Server, serverStat.AppCount)
+				if err := formatter.PrintTable(table); err != nil {
+					log.Fatal(err)
 				}
 
 				if len(allStats) > 1 && len(rows) > 0 {
@@ -312,13 +271,59 @@ can take some time.`,
 
 			alreadySeen[app.Server] = true
 		}
-
-		if len(allStats) > 1 {
-			totalServers := formatter.BoldStyle.Render("TOTAL SERVERS")
-			totalApps := formatter.BoldStyle.Render("TOTAL APPS")
-			log.Infof("%s: %v | %s: %v ", totalServers, totalServersCount, totalApps, totalAppsCount)
-		}
-
-		return nil
 	},
 }
+
+var (
+	status        bool
+	recipeFilter  string
+	listAppServer string
+)
+
+func init() {
+	AppListCommand.Flags().BoolVarP(
+		&status,
+		"status",
+		"S",
+		false,
+		"show app deployment status",
+	)
+
+	AppListCommand.Flags().StringVarP(
+		&recipeFilter,
+		"recipe",
+		"r",
+		"",
+		"show apps of a specific recipe",
+	)
+
+	AppListCommand.RegisterFlagCompletionFunc(
+		"recipe",
+		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			return autocomplete.RecipeNameComplete()
+		},
+	)
+
+	AppListCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		"machine",
+		"m",
+		false,
+		"print machine-readable output",
+	)
+
+	AppListCommand.Flags().StringVarP(
+		&listAppServer,
+		"server",
+		"s",
+		"",
+		"show apps of a specific server",
+	)
+
+	AppListCommand.RegisterFlagCompletionFunc(
+		"server",
+		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			return autocomplete.ServerNameComplete()
+		},
+	)
+}

cli/app/logs.go

@@ -2,40 +2,43 @@ package app
 
 import (
 	"context"
-	"io"
-	"os"
-	"slices"
-	"sync"
-	"time"
+	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/logs"
 	"coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/docker/docker/api/types"
-	containerTypes "github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/swarm"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appLogsCommand = cli.Command{
-	Name:      "logs",
-	Aliases:   []string{"l"},
-	Usage:     "Tail app logs",
-	UsageText: "abra app logs <domain> [<service>] [options]",
-	Flags: []cli.Flag{
-		internal.StdErrOnlyFlag,
-		internal.SinceLogsFlag,
+var AppLogsCommand = &cobra.Command{
+	Use:     "logs <domain> [service] [flags]",
+	Aliases: []string{"l"},
+	Short:   "Tail app logs",
+	Args:    cobra.RangeArgs(1, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		case 1:
+			app, err := appPkg.Get(args[0])
+			if err != nil {
+				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
+				return []string{errMsg}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.ServiceNameComplete(app.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 		stackName := app.StackName()
 
 		if err := app.Recipe.EnsureExists(); err != nil {
@@ -56,84 +59,49 @@ var appLogsCommand = cli.Command{
 			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		serviceName := cmd.Args().Get(1)
-		serviceNames := []string{}
-		if serviceName != "" {
-			serviceNames = []string{serviceName}
+		var serviceNames []string
+		if len(args) == 2 {
+			serviceNames = []string{args[1]}
 		}
-		err = tailLogs(cl, app, serviceNames)
+
+		f, err := app.Filters(true, false, serviceNames...)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		return nil
+		opts := logs.TailOpts{
+			AppName:  app.Name,
+			Services: serviceNames,
+			StdErr:   stdErr,
+			Since:    sinceLogs,
+			Filters:  f,
+		}
+
+		if err := logs.TailLogs(cl, opts); err != nil {
+			log.Fatal(err)
+		}
 	},
 }
 
-// tailLogs prints logs for the given app with optional service names to be
-// filtered on. It also checks if the latest task is not runnning and then
-// prints the past tasks.
-func tailLogs(cl *dockerClient.Client, app appPkg.App, serviceNames []string) error {
-	f, err := app.Filters(true, false, serviceNames...)
-	if err != nil {
-		return err
-	}
+var (
+	stdErr    bool
+	sinceLogs string
+)
 
-	services, err := cl.ServiceList(context.Background(), types.ServiceListOptions{Filters: f})
-	if err != nil {
-		return err
-	}
+func init() {
+	AppLogsCommand.Flags().BoolVarP(
+		&stdErr,
+		"stderr",
+		"s",
+		false,
+		"only tail stderr",
+	)
 
-	var wg sync.WaitGroup
-	for _, service := range services {
-		filters := filters.NewArgs()
-		filters.Add("name", service.Spec.Name)
-		tasks, err := cl.TaskList(context.Background(), types.TaskListOptions{Filters: f})
-		if err != nil {
-			return err
-		}
-		if len(tasks) > 0 {
-			// Need to sort the tasks by the CreatedAt field in the inverse order.
-			// Otherwise they are in the reversed order and not sorted properly.
-			slices.SortFunc[[]swarm.Task](tasks, func(t1, t2 swarm.Task) int {
-				return int(t2.Meta.CreatedAt.Unix() - t1.Meta.CreatedAt.Unix())
-			})
-			lastTask := tasks[0].Status
-			if lastTask.State != swarm.TaskStateRunning {
-				for _, task := range tasks {
-					log.Errorf("[%s] %s State %s: %s", service.Spec.Name, task.Meta.CreatedAt.Format(time.RFC3339), task.Status.State, task.Status.Err)
-				}
-			}
-		}
-
-		// Collect the logs in a go routine, so the logs from all services are
-		// collected in parallel.
-		wg.Add(1)
-		go func(serviceID string) {
-			logs, err := cl.ServiceLogs(context.Background(), serviceID, containerTypes.LogsOptions{
-				ShowStderr: true,
-				ShowStdout: !internal.StdErrOnly,
-				Since:      internal.SinceLogs,
-				Until:      "",
-				Timestamps: true,
-				Follow:     true,
-				Tail:       "20",
-				Details:    false,
-			})
-			if err != nil {
-				log.Fatal(err)
-			}
-			defer logs.Close()
-
-			_, err = io.Copy(os.Stdout, logs)
-			if err != nil && err != io.EOF {
-				log.Fatal(err)
-			}
-		}(service.ID)
-	}
-
-	// Wait for all log streams to be closed.
-	wg.Wait()
-
-	return nil
+	AppLogsCommand.Flags().StringVarP(
+		&sinceLogs,
+		"since",
+		"S",
+		"",
+		"tail logs since YYYY-MM-DDTHH:MM:SSZ",
+	)
 }

cli/app/new.go

@@ -1,7 +1,6 @@
 package app
 
 import (
-	"context"
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
@@ -17,7 +16,7 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/charmbracelet/lipgloss/table"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
 var appNewDescription = `Creates a new app from a default recipe.
@@ -28,10 +27,10 @@ appropriate server.
 This command does not deploy your app for you. You will need to run "abra app
 deploy <domain>" to do so.
 
-You can see what recipes are available (i.e. values for the <recipe> argument)
+You can see what recipes are available (i.e. values for the [recipe] argument)
 by running "abra recipe ls".
 
-Recipe commit hashes are supported values for "[<version>]".
+Recipe commit hashes are supported values for "[version]".
 
 Passing the "--secrets/-S" flag will automatically generate secrets for your
 app and store them encrypted at rest on the chosen target server. These
@@ -42,69 +41,83 @@ You can use the "--pass/-P" to store these generated passwords locally in a
 pass store (see passwordstore.org for more). The pass command must be available
 on your $PATH.`
 
-var appNewCommand = cli.Command{
-	Name:        "new",
-	Aliases:     []string{"n"},
-	Usage:       "Create a new app",
-	UsageText:   "abra app new [<recipe>] [<version>] [options]",
-	Description: appNewDescription,
-	Flags: []cli.Flag{
-		internal.NewAppServerFlag,
-		internal.DomainFlag,
-		internal.PassFlag,
-		internal.SecretsFlag,
-		internal.ChaosFlag,
-	},
-	Before:   internal.SubCommandBefore,
-	HideHelp: true,
-	ShellComplete: func(ctx context.Context, cmd *cli.Command) {
-		args := cmd.Args()
-		switch args.Len() {
+var AppNewCommand = &cobra.Command{
+	Use:     "new [recipe] [version] [flags]",
+	Aliases: []string{"n"},
+	Short:   "Create a new app",
+	Long:    appNewDescription,
+	Args:    cobra.RangeArgs(0, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
 		case 0:
-			autocomplete.RecipeNameComplete(ctx, cmd)
+			return autocomplete.RecipeNameComplete()
 		case 1:
-			autocomplete.RecipeVersionComplete(cmd.Args().Get(0))
+			recipe := internal.ValidateRecipe(args, cmd.Name())
+			return autocomplete.RecipeVersionComplete(recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
 		}
 	},
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		recipe := internal.ValidateRecipe(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
 
-		var version string
-		if !internal.Chaos {
+		if len(args) == 2 && internal.Chaos {
+			log.Fatal("cannot use [version] and --chaos together")
+		}
+
+		var recipeVersion string
+		if len(args) == 2 {
+			recipeVersion = args[1]
+		}
+
+		chaosVersion := config.CHAOS_DEFAULT
+		if internal.Chaos {
+			var err error
+			chaosVersion, err = recipe.ChaosVersion()
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			recipeVersion = chaosVersion
+		} else {
 			if err := recipe.EnsureIsClean(); err != nil {
 				log.Fatal(err)
 			}
-			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(); err != nil {
+
+			var recipeVersions recipePkg.RecipeVersions
+			if recipeVersion == "" {
+				var err error
+				recipeVersions, _, err = recipe.GetRecipeVersions()
+				if err != nil {
 					log.Fatal(err)
 				}
 			}
 
-			if cmd.Args().Get(1) == "" {
-				recipeVersions, err := recipe.GetRecipeVersions()
-				if err != nil {
-					log.Fatal(err)
+			if len(recipeVersions) > 0 {
+				latest := recipeVersions[len(recipeVersions)-1]
+				for tag := range latest {
+					recipeVersion = tag
 				}
 
-				if len(recipeVersions) > 0 {
-					latest := recipeVersions[len(recipeVersions)-1]
-					for tag := range latest {
-						version = tag
-					}
-
-					if _, err := recipe.EnsureVersion(version); err != nil {
-						log.Fatal(err)
-					}
-				} else {
-					if err := recipe.EnsureLatest(); err != nil {
-						log.Fatal(err)
-					}
+				if _, err := recipe.EnsureVersion(recipeVersion); err != nil {
+					log.Fatal(err)
 				}
 			} else {
-				version = cmd.Args().Get(1)
-				if _, err := recipe.EnsureVersion(version); err != nil {
+				if err := recipe.EnsureLatest(); err != nil {
 					log.Fatal(err)
 				}
+
+				if recipeVersion == "" {
+					head, err := recipe.Head()
+					if err != nil {
+						log.Fatalf("failed to retrieve latest commit for %s: %s", recipe.Name, err)
+					}
+
+					recipeVersion = formatter.SmallSHA(head.String())
+				}
 			}
 		}
 
@@ -112,25 +125,25 @@ var appNewCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		if err := ensureDomainFlag(recipe, internal.NewAppServer); err != nil {
+		if err := ensureDomainFlag(recipe, newAppServer); err != nil {
 			log.Fatal(err)
 		}
 
-		sanitisedAppName := appPkg.SanitiseAppName(internal.Domain)
-		log.Debugf("%s sanitised as %s for new app", internal.Domain, sanitisedAppName)
+		sanitisedAppName := appPkg.SanitiseAppName(appDomain)
+		log.Debugf("%s sanitised as %s for new app", appDomain, sanitisedAppName)
 
 		if err := appPkg.TemplateAppEnvSample(
 			recipe,
-			internal.Domain,
-			internal.NewAppServer,
-			internal.Domain,
+			appDomain,
+			newAppServer,
+			appDomain,
 		); err != nil {
 			log.Fatal(err)
 		}
 
-		var secrets AppSecrets
+		var appSecrets AppSecrets
 		var secretsTable *table.Table
-		if internal.Secrets {
+		if generateSecrets {
 			sampleEnv, err := recipe.SampleEnv()
 			if err != nil {
 				log.Fatal(err)
@@ -141,21 +154,25 @@ var appNewCommand = cli.Command{
 				log.Fatal(err)
 			}
 
-			secretsConfig, err := secret.ReadSecretsConfig(recipe.SampleEnvPath, composeFiles, appPkg.StackName(internal.Domain))
+			secretsConfig, err := secret.ReadSecretsConfig(
+				recipe.SampleEnvPath,
+				composeFiles,
+				appPkg.StackName(appDomain),
+			)
 			if err != nil {
-				return err
+				log.Fatal(err)
 			}
 
 			if err := promptForSecrets(recipe.Name, secretsConfig); err != nil {
 				log.Fatal(err)
 			}
 
-			cl, err := client.New(internal.NewAppServer)
+			cl, err := client.New(newAppServer)
 			if err != nil {
 				log.Fatal(err)
 			}
 
-			secrets, err = createSecrets(cl, secretsConfig, sanitisedAppName)
+			appSecrets, err = createSecrets(cl, secretsConfig, sanitisedAppName)
 			if err != nil {
 				log.Fatal(err)
 			}
@@ -168,62 +185,42 @@ var appNewCommand = cli.Command{
 			headers := []string{"NAME", "VALUE"}
 			secretsTable.Headers(headers...)
 
-			for name, val := range secrets {
+			for name, val := range appSecrets {
 				secretsTable.Row(name, val)
 			}
 		}
 
-		if internal.NewAppServer == "default" {
-			internal.NewAppServer = "local"
+		if newAppServer == "default" {
+			newAppServer = "local"
 		}
 
-		table, err := formatter.CreateTable()
-		if err != nil {
-			log.Fatal(err)
-		}
+		log.Infof("%s created (version: %s)", appDomain, recipeVersion)
 
-		headers := []string{"SERVER", "DOMAIN", "RECIPE", "VERSION"}
-		table.Headers(headers...)
+		if len(appSecrets) > 0 {
+			rows := [][]string{}
+			for k, v := range appSecrets {
+				rows = append(rows, []string{k, v})
+			}
 
-		table.Row(internal.NewAppServer, internal.Domain, recipe.Name, version)
+			overview := formatter.CreateOverview("SECRETS OVERVIEW", rows)
 
-		log.Infof("new app '%s' created 🌞", recipe.Name)
-
-		fmt.Println("")
-		fmt.Println(table)
-		fmt.Println("")
-
-		fmt.Println("Configure this app:")
-		fmt.Println(fmt.Sprintf("\n    abra app config %s", internal.Domain))
-
-		fmt.Println("")
-		fmt.Println("Deploy this app:")
-		fmt.Println(fmt.Sprintf("\n    abra app deploy %s", internal.Domain))
-
-		if len(secrets) > 0 {
-			fmt.Println("")
-			fmt.Println("Generated secrets:")
-			fmt.Println("")
-			fmt.Println(secretsTable)
+			fmt.Println(overview)
 
 			log.Warnf(
-				"generated secrets %s shown again, please take note of them %s",
-				formatter.BoldStyle.Render("NOT"),
-				formatter.BoldStyle.Render("NOW"),
+				"secrets are %s shown again, please save them %s",
+				formatter.BoldUnderlineStyle.Render("NOT"),
+				formatter.BoldUnderlineStyle.Render("NOW"),
 			)
 		}
 
-		app, err := app.Get(internal.Domain)
+		app, err := app.Get(appDomain)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		log.Debugf("choosing %s as version to save to env file", version)
-		if err := app.WriteRecipeVersion(version, false); err != nil {
-			log.Fatalf("writing new recipe version in env file: %s", err)
+		if err := app.WriteRecipeVersion(recipeVersion, false); err != nil {
+			log.Fatalf("writing recipe version failed: %s", err)
 		}
-
-		return nil
 	},
 }
 
@@ -238,19 +235,19 @@ func createSecrets(cl *dockerClient.Client, secretsConfig map[string]secret.Secr
 		sanitisedAppName = sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH]
 	}
 
-	secrets, err := secret.GenerateSecrets(cl, secretsConfig, internal.NewAppServer)
+	secrets, err := secret.GenerateSecrets(cl, secretsConfig, newAppServer)
 	if err != nil {
 		return nil, err
 	}
 
-	if internal.Pass {
+	if saveInPass {
 		for secretName := range secrets {
 			secretValue := secrets[secretName]
 			if err := secret.PassInsertSecret(
 				secretValue,
 				secretName,
-				internal.Domain,
-				internal.NewAppServer,
+				appDomain,
+				newAppServer,
 			); err != nil {
 				return nil, err
 			}
@@ -262,17 +259,17 @@ func createSecrets(cl *dockerClient.Client, secretsConfig map[string]secret.Secr
 
 // ensureDomainFlag checks if the domain flag was used. if not, asks the user for it/
 func ensureDomainFlag(recipe recipePkg.Recipe, server string) error {
-	if internal.Domain == "" && !internal.NoInput {
+	if appDomain == "" && !internal.NoInput {
 		prompt := &survey.Input{
 			Message: "Specify app domain",
 			Default: fmt.Sprintf("%s.%s", recipe.Name, server),
 		}
-		if err := survey.AskOne(prompt, &internal.Domain); err != nil {
+		if err := survey.AskOne(prompt, &appDomain); err != nil {
 			return err
 		}
 	}
 
-	if internal.Domain == "" {
+	if appDomain == "" {
 		return fmt.Errorf("no domain provided")
 	}
 
@@ -286,11 +283,11 @@ func promptForSecrets(recipeName string, secretsConfig map[string]secret.Secret)
 		return nil
 	}
 
-	if !internal.Secrets && !internal.NoInput {
+	if !generateSecrets && !internal.NoInput {
 		prompt := &survey.Confirm{
 			Message: "Generate app secrets?",
 		}
-		if err := survey.AskOne(prompt, &internal.Secrets); err != nil {
+		if err := survey.AskOne(prompt, &generateSecrets); err != nil {
 			return err
 		}
 	}
@@ -305,19 +302,82 @@ func ensureServerFlag() error {
 		return err
 	}
 
-	if internal.NewAppServer == "" && !internal.NoInput {
+	if len(servers) == 1 {
+		newAppServer = servers[0]
+		log.Infof("single server detected, choosing %s automatically", newAppServer)
+		return nil
+	}
+
+	if newAppServer == "" && !internal.NoInput {
 		prompt := &survey.Select{
 			Message: "Select app server:",
 			Options: servers,
 		}
-		if err := survey.AskOne(prompt, &internal.NewAppServer); err != nil {
+		if err := survey.AskOne(prompt, &newAppServer); err != nil {
 			return err
 		}
 	}
 
-	if internal.NewAppServer == "" {
+	if newAppServer == "" {
 		return fmt.Errorf("no server provided")
 	}
 
 	return nil
 }
+
+var (
+	newAppServer    string
+	appDomain       string
+	saveInPass      bool
+	generateSecrets bool
+)
+
+func init() {
+	AppNewCommand.Flags().StringVarP(
+		&newAppServer,
+		"server",
+		"s",
+		"",
+		"specify server for new app",
+	)
+
+	AppNewCommand.RegisterFlagCompletionFunc(
+		"server",
+		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			return autocomplete.ServerNameComplete()
+		},
+	)
+
+	AppNewCommand.Flags().StringVarP(
+		&appDomain,
+		"domain",
+		"D",
+		"",
+		"domain name for app",
+	)
+
+	AppNewCommand.Flags().BoolVarP(
+		&saveInPass,
+		"pass",
+		"p",
+		false,
+		"store secrets in a local pass store",
+	)
+
+	AppNewCommand.Flags().BoolVarP(
+		&generateSecrets,
+		"secrets",
+		"S",
+		false,
+		"automatically generate secrets",
+	)
+
+	AppNewCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+
+}

cli/app/ps.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"sort"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	appPkg "coopcloud.tech/abra/pkg/app"
@@ -18,26 +20,24 @@ import (
 	containerTypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appPsCommand = cli.Command{
-	Name:        "ps",
-	Aliases:     []string{"p"},
-	Usage:       "Check app status",
-	UsageText:   "abra app ps <domain> [options]",
-	Description: "Show status of a deployed app.",
-	Flags: []cli.Flag{
-		internal.MachineReadableFlag,
-		internal.ChaosFlag,
-		internal.OfflineFlag,
+var AppPsCommand = &cobra.Command{
+	Use:     "ps <domain> [flags]",
+	Aliases: []string{"p"},
+	Short:   "Check app deployment status",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
@@ -59,16 +59,16 @@ var appPsCommand = cli.Command{
 		statuses, err := appPkg.GetAppStatuses([]appPkg.App{app}, true)
 		if statusMeta, ok := statuses[app.StackName()]; ok {
 			if isChaos, exists := statusMeta["chaos"]; exists && isChaos == "true" {
-				chaosVersion, err = app.Recipe.ChaosVersion()
-				if err != nil {
-					log.Fatal(err)
+				if cVersion, exists := statusMeta["chaosVersion"]; exists {
+					chaosVersion = cVersion
+					if strings.HasSuffix(chaosVersion, config.DIRTY_DEFAULT) {
+						chaosVersion = formatter.BoldDirtyDefault(chaosVersion)
+					}
 				}
 			}
 		}
 
 		showPSOutput(app, cl, deployMeta.Version, chaosVersion)
-
-		return nil
 	},
 }
 
@@ -92,9 +92,14 @@ func showPSOutput(app appPkg.App, cl *dockerClient.Client, deployedVersion, chao
 		return
 	}
 
+	services := compose.Services
+	sort.Slice(services, func(i, j int) bool {
+		return services[i].Name < services[j].Name
+	})
+
 	var rows [][]string
 	allContainerStats := make(map[string]map[string]string)
-	for _, service := range compose.Services {
+	for _, service := range services {
 		filters := filters.NewArgs()
 		filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), service.Name))
 
@@ -132,24 +137,35 @@ func showPSOutput(app appPkg.App, cl *dockerClient.Client, deployedVersion, chao
 
 		allContainerStats[containerStats["service"]] = containerStats
 
+		// NOTE(d1): don't clobber these variables for --machine output
+		dVersion := deployedVersion
+		cVersion := chaosVersion
+
+		if containerStats["service"] != "app" {
+			// NOTE(d1): don't repeat info which only relevant for the "app" service
+			dVersion = ""
+			cVersion = ""
+		}
+
 		row := []string{
 			containerStats["service"],
-			containerStats["image"],
-			containerStats["created"],
 			containerStats["status"],
-			containerStats["state"],
-			containerStats["ports"],
+			containerStats["image"],
+			dVersion,
+			cVersion,
 		}
 
 		rows = append(rows, row)
 	}
 
 	if internal.MachineReadable {
-		jsonstring, err := json.Marshal(allContainerStats)
+		rendered, err := json.Marshal(allContainerStats)
 		if err != nil {
 			log.Fatal("unable to convert to JSON: %s", err)
 		}
-		fmt.Println(string(jsonstring))
+
+		fmt.Println(string(rendered))
+
 		return
 	}
 
@@ -160,18 +176,35 @@ func showPSOutput(app appPkg.App, cl *dockerClient.Client, deployedVersion, chao
 
 	headers := []string{
 		"SERVICE",
-		"IMAGE",
-		"CREATED",
 		"STATUS",
-		"STATE",
-		"PORTS",
+		"IMAGE",
+		"VERSION",
+		"CHAOS",
 	}
 
 	table.
 		Headers(headers...).
 		Rows(rows...)
 
-	fmt.Println(table)
-
-	log.Infof("VERSION: %s CHAOS: %s", deployedVersion, chaosVersion)
+	if err := formatter.PrintTable(table); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func init() {
+	AppPsCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		"machine",
+		"m",
+		false,
+		"print machine-readable output",
+	)
+
+	AppPsCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
 }

cli/app/remove.go

@@ -9,18 +9,17 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
+	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/docker/api/types"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appRemoveCommand = cli.Command{
-	Name:      "remove",
-	Aliases:   []string{"rm"},
-	UsageText: "abra app remove <domain> [options]",
-	Usage:     "Remove all app data, locally and remotely",
-	Description: `Remove everything related to an app which is already undeployed.
+var AppRemoveCommand = &cobra.Command{
+	Use:     "remove <domain> [flags]",
+	Aliases: []string{"rm"},
+	Short:   "Remove all app data, locally and remotely",
+	Long: `Remove everything related to an app which is already undeployed.
 
 By default, it will prompt for confirmation before proceeding. All secrets,
 volumes and the local app env file will be deleted.
@@ -36,17 +35,19 @@ secrets first, Abra will *not* be able to help you remove them afterwards.
 
 To delete everything without prompt, use the "--force/-f" or the "--no-input/n"
 flag.`,
-	Flags: []cli.Flag{
-		internal.ForceFlag,
+	Example: "  abra app remove 1312.net",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	ShellComplete: autocomplete.AppNameComplete,
-	Before:        internal.SubCommandBefore,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
 		if !internal.Force && !internal.NoInput {
-			log.Warnf("ALERTA ALERTA: this will completely remove %s data and config locally and remotely", app.Name)
+			log.Warnf("ALERTA ALERTA: deleting %s data and config (local/remote)", app.Name)
 
 			response := false
 			prompt := &survey.Confirm{Message: "are you sure?"}
@@ -77,6 +78,22 @@ flag.`,
 			log.Fatal(err)
 		}
 
+		configs, err := client.GetConfigs(cl, context.Background(), app.Server, fs)
+		if err != nil {
+			log.Fatal(err)
+		}
+		configNames := client.GetConfigNames(configs)
+
+		if len(configNames) > 0 {
+			if err := client.RemoveConfigs(cl, context.Background(), configNames, internal.Force); err != nil {
+				log.Fatalf("removing configs failed: %s", err)
+			}
+
+			log.Infof("%d config(s) removed successfully", len(configNames))
+		} else {
+			log.Info("no configs to remove")
+		}
+
 		secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: fs})
 		if err != nil {
 			log.Fatal(err)
@@ -119,7 +136,7 @@ flag.`,
 				log.Fatalf("removing volumes failed: %s", err)
 			}
 
-			log.Infof("%d volumes removed successfully", len(volumeNames))
+			log.Infof("%d volume(s) removed successfully", len(volumeNames))
 		} else {
 			log.Info("no volumes to remove")
 		}
@@ -129,7 +146,15 @@ flag.`,
 		}
 
 		log.Info(fmt.Sprintf("file: %s removed", app.Path))
-
-		return nil
 	},
 }
+
+func init() {
+	AppRemoveCommand.Flags().BoolVarP(
+		&internal.Force,
+		"force",
+		"f",
+		false,
+		"perform action without further prompt",
+	)
+}

cli/app/restart.go

@@ -2,7 +2,6 @@ package app
 
 import (
 	"context"
-	"errors"
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
@@ -10,45 +9,66 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/ui"
 	upstream "coopcloud.tech/abra/pkg/upstream/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/urfave/cli/v3"
+	"github.com/docker/docker/api/types"
+	"github.com/spf13/cobra"
 )
 
-var appRestartCommand = cli.Command{
-	Name:      "restart",
-	Aliases:   []string{"re"},
-	Usage:     "Restart an app",
-	UsageText: "abra app restart <domain> [<service>] [options]",
-	Flags: []cli.Flag{
-		internal.AllServicesFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `This command restarts services within a deployed app.
+var AppRestartCommand = &cobra.Command{
+	Use:     "restart <domain> [[service] | --all-services] [flags]",
+	Aliases: []string{"re"},
+	Short:   "Restart an app",
+	Long: `This command restarts services within a deployed app.
 
 Run "abra app ps <domain>" to see a list of service names.
 
 Pass "--all-services/-a" to restart all services.`,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		if err := app.Recipe.Ensure(false, false); err != nil {
+	Example: `  # restart a single app service
+  abra app restart 1312.net app
+
+  # restart all app services
+  abra app restart 1312.net -a`,
+	Args: cobra.RangeArgs(1, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		case 1:
+			if !allServices {
+				return autocomplete.ServiceNameComplete(args[0])
+			}
+			return nil, cobra.ShellCompDirectiveDefault
+		default:
+			return nil, cobra.ShellCompDirectiveError
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
-		serviceName := cmd.Args().Get(1)
-		if serviceName == "" && !internal.AllServices {
-			err := errors.New("missing <service>")
-			internal.ShowSubcommandHelpAndError(cmd, err)
+		var serviceName string
+		if len(args) == 2 {
+			serviceName = args[1]
 		}
 
-		if serviceName != "" && internal.AllServices {
-			log.Fatal("cannot use <service> and --all-services together")
+		if serviceName == "" && !allServices {
+			log.Fatal("missing [service]")
+		}
+
+		if serviceName != "" && allServices {
+			log.Fatal("cannot use [service] and --all-services/-a together")
 		}
 
 		var serviceNames []string
-		if internal.AllServices {
+		if allServices {
 			var err error
 			serviceNames, err = appPkg.GetAppServiceNames(app.Name)
 			if err != nil {
@@ -75,13 +95,36 @@ Pass "--all-services/-a" to restart all services.`,
 		for _, serviceName := range serviceNames {
 			stackServiceName := fmt.Sprintf("%s_%s", app.StackName(), serviceName)
 
+			service, _, err := cl.ServiceInspectWithRaw(
+				context.Background(),
+				stackServiceName,
+				types.ServiceInspectOptions{},
+			)
+			if err != nil {
+				log.Fatal(err)
+			}
+
 			log.Debugf("attempting to scale %s to 0", stackServiceName)
 
 			if err := upstream.RunServiceScale(context.Background(), cl, stackServiceName, 0); err != nil {
 				log.Fatal(err)
 			}
 
-			if err := stack.WaitOnService(context.Background(), cl, stackServiceName, app.Name); err != nil {
+			f, err := app.Filters(true, false, serviceName)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			waitOpts := stack.WaitOpts{
+				Services:   []ui.ServiceMeta{{Name: stackServiceName, ID: service.ID}},
+				AppName:    app.Name,
+				ServerName: app.Server,
+				Filters:    f,
+				NoLog:      true,
+				Quiet:      true,
+			}
+
+			if err := stack.WaitOnServices(cmd.Context(), cl, waitOpts); err != nil {
 				log.Fatal(err)
 			}
 
@@ -92,14 +135,31 @@ Pass "--all-services/-a" to restart all services.`,
 				log.Fatal(err)
 			}
 
-			if err := stack.WaitOnService(context.Background(), cl, stackServiceName, app.Name); err != nil {
+			if err := stack.WaitOnServices(cmd.Context(), cl, waitOpts); err != nil {
 				log.Fatal(err)
 			}
 
 			log.Debugf("%s has been scaled to 1", stackServiceName)
 			log.Infof("%s service successfully restarted", serviceName)
 		}
-
-		return nil
 	},
 }
+
+var allServices bool
+
+func init() {
+	AppRestartCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+	AppRestartCommand.Flags().BoolVarP(
+		&allServices,
+		"all-services",
+		"a",
+		false,
+		"restart all services",
+	)
+}

cli/app/restore.go

@@ -1,38 +1,34 @@
 package app
 
 import (
-	"context"
 	"fmt"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var targetPath string
-var targetPathFlag = &cli.StringFlag{
-	Name:        "target",
-	Aliases:     []string{"t"},
-	Usage:       "Target path",
-	Destination: &targetPath,
-}
+var AppRestoreCommand = &cobra.Command{
+	Use:     "restore <domain> [flags]",
+	Aliases: []string{"rs"},
+	Short:   "Restore a snapshot",
+	Long: `Snapshots are restored while apps are deployed.
 
-var appRestoreCommand = cli.Command{
-	Name:      "restore",
-	Aliases:   []string{"rs"},
-	Usage:     "Restore an app backup",
-	UsageText: "abra app restore <domain> <service> [options]",
-	Flags: []cli.Flag{
-		targetPathFlag,
+Some restore scenarios may require service / app restarts.`,
+	Args: cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
@@ -46,20 +42,94 @@ var appRestoreCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
+		execEnv := []string{
+			fmt.Sprintf("SERVICE=%s", app.Domain),
+			"MACHINE_LOGS=true",
+		}
+
 		if snapshot != "" {
 			log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
 			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
 		}
+
 		if targetPath != "" {
 			log.Debugf("including TARGET=%s in backupbot exec invocation", targetPath)
 			execEnv = append(execEnv, fmt.Sprintf("TARGET=%s", targetPath))
 		}
 
-		if err := internal.RunBackupCmdRemote(cl, "restore", targetContainer.ID, execEnv); err != nil {
-			log.Fatal(err)
+		if internal.NoInput {
+			log.Debugf("including NONINTERACTIVE=%v in backupbot exec invocation", internal.NoInput)
+			execEnv = append(execEnv, fmt.Sprintf("NONINTERACTIVE=%v", internal.NoInput))
 		}
 
-		return nil
+		if len(volumes) > 0 {
+			allVolumes := strings.Join(volumes, ",")
+			log.Debugf("including VOLUMES=%s in backupbot exec invocation", allVolumes)
+			execEnv = append(execEnv, fmt.Sprintf("VOLUMES=%s", allVolumes))
+		}
+
+		if len(services) > 0 {
+			allServices := strings.Join(services, ",")
+			log.Debugf("including CONTAINER=%s in backupbot exec invocation", allServices)
+			execEnv = append(execEnv, fmt.Sprintf("CONTAINER=%s", allServices))
+		}
+
+		if hooks {
+			log.Debugf("including NO_COMMANDS=%v in backupbot exec invocation", false)
+			execEnv = append(execEnv, fmt.Sprintf("NO_COMMANDS=%v", false))
+		}
+
+		if _, err := internal.RunBackupCmdRemote(cl, "restore", targetContainer.ID, execEnv); err != nil {
+			log.Fatal(err)
+		}
 	},
 }
+
+var (
+	targetPath string
+	hooks      bool
+	services   []string
+	volumes    []string
+)
+
+func init() {
+	AppRestoreCommand.Flags().StringVarP(
+		&targetPath,
+		"target",
+		"t",
+		"/",
+		"target path",
+	)
+
+	AppRestoreCommand.Flags().StringArrayVarP(
+		&services,
+		"services",
+		"s",
+		[]string{},
+		"restore specific services",
+	)
+
+	AppRestoreCommand.Flags().StringArrayVarP(
+		&volumes,
+		"volumes",
+		"v",
+		[]string{},
+		"restore specific volumes",
+	)
+
+	AppRestoreCommand.Flags().BoolVarP(
+		&hooks,
+		"hooks",
+		"H",
+		false,
+		"enable pre/post-hook command execution",
+	)
+
+	AppRestoreCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+}

cli/app/rollback.go

@@ -1,13 +1,14 @@
 package app
 
 import (
-	"context"
 	"fmt"
 
+	"coopcloud.tech/abra/pkg/app"
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/envfile"
+	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/lint"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
@@ -16,46 +17,61 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appRollbackCommand = cli.Command{
-	Name:      "rollback",
-	Aliases:   []string{"rl"},
-	Usage:     "Roll an app back to a previous version",
-	UsageText: "abra app rollback <domain> [<version>] [options]",
-	Flags: []cli.Flag{
-		internal.ForceFlag,
-		internal.NoDomainChecksFlag,
-		internal.DontWaitConvergeFlag,
+var AppRollbackCommand = &cobra.Command{
+	Use:     "rollback <domain> [version] [flags]",
+	Aliases: []string{"rl"},
+	Short:   "Roll an app back to a previous version",
+	Long: `This command rolls an app back to a previous version.
+
+Unlike "abra app deploy", chaos operations are not supported here. Only recipe
+versions are supported values for "[version]".
+
+It is possible to "--force/-f" an downgrade if you want to re-deploy a specific
+version.
+
+Only the deployed version is consulted when trying to determine what downgrades
+are available. The live deployment version is the "source of truth" in this
+case. The stored .env version is not consulted.
+
+A downgrade can be destructive, please ensure you have a copy of your app data
+beforehand. See "abra app backup" for more.`,
+	Example: ` # standard rollback
+  abra app rollback 1312.net
+
+  # rollback to specific version
+  abra app rollback 1312.net 2.0.0+1.2.3`,
+	Args: cobra.RangeArgs(1, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		case 1:
+			app, err := appPkg.Get(args[0])
+			if err != nil {
+				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
+				return []string{errMsg}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.RecipeVersionComplete(app.Recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveError
+		}
 	},
-	Before: internal.SubCommandBefore,
-	Description: `This command rolls an app back to a previous version.
+	Run: func(cmd *cobra.Command, args []string) {
+		var (
+			downgradeWarnMessages []string
+			chosenDowngrade       string
+			availableDowngrades   []string
+		)
 
-Unlike "deploy", chaos operations are not supported here. Only recipe versions
-are supported values for "[<version>]".
+		app := internal.ValidateApp(args)
 
-A rollback can be destructive, please ensure you have a copy of your app data
-beforehand.`,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		var warnMessages []string
-
-		app := internal.ValidateApp(cmd)
-		stackName := app.StackName()
-
-		specificVersion := cmd.Args().Get(1)
-		if specificVersion != "" {
-			log.Debugf("overriding env file version (%s) with %s", app.Recipe.Version, specificVersion)
-			app.Recipe.Version = specificVersion
-		}
-
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-			log.Fatal(err)
-		}
-
-		if err := lint.LintForErrors(app.Recipe); err != nil {
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
@@ -64,15 +80,13 @@ beforehand.`,
 			log.Fatal(err)
 		}
 
-		log.Debugf("checking whether %s is already deployed", stackName)
-
-		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := ensureDeployed(cl, app)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		if !deployMeta.IsDeployed {
-			log.Fatalf("%s is not deployed?", app.Name)
+		if err := lint.LintForErrors(app.Recipe); err != nil {
+			log.Fatal(err)
 		}
 
 		versions, err := app.Recipe.Tags()
@@ -80,84 +94,56 @@ beforehand.`,
 			log.Fatal(err)
 		}
 
-		var availableDowngrades []string
-		if deployMeta.Version == "unknown" {
+		// NOTE(d1): we've no idea what the live deployment version is, so every
+		// possible downgrade can be shown. it's up to the user to make the choice
+		if deployMeta.Version == config.UNKNOWN_DEFAULT {
 			availableDowngrades = versions
-			warnMessages = append(warnMessages, fmt.Sprintf("failed to determine deployed version of %s", app.Name))
 		}
 
-		if specificVersion != "" {
-			parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
-			if err != nil {
-				log.Fatalf("'%s' is not a known version for %s", deployMeta.Version, app.Recipe.Name)
+		if len(args) == 2 && args[1] != "" {
+			chosenDowngrade = args[1]
+
+			if err := validateDowngradeVersionArg(chosenDowngrade, app, deployMeta); err != nil {
+				log.Fatal(err)
 			}
 
-			parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
-			if err != nil {
-				log.Fatalf("'%s' is not a known version for %s", specificVersion, app.Recipe.Name)
-			}
-
-			if parsedSpecificVersion.IsGreaterThan(parsedDeployedVersion) && !parsedSpecificVersion.Equals(parsedDeployedVersion) {
-				log.Fatalf("%s is not a downgrade for %s?", deployMeta.Version, specificVersion)
-			}
-
-			if parsedSpecificVersion.Equals(parsedDeployedVersion) && !internal.Force {
-				log.Fatalf("%s is not a downgrade for %s?", deployMeta.Version, specificVersion)
-			}
-
-			availableDowngrades = append(availableDowngrades, specificVersion)
+			availableDowngrades = append(availableDowngrades, chosenDowngrade)
 		}
 
-		if deployMeta.Version != "unknown" && specificVersion == "" {
-			if deployMeta.IsChaos {
-				warnMessages = append(warnMessages, fmt.Sprintf("attempting to rollback a chaos deployment"))
+		if deployMeta.Version != config.UNKNOWN_DEFAULT && chosenDowngrade == "" {
+			downgradeAvailable, err := ensureDowngradesAvailable(versions, &availableDowngrades, deployMeta)
+			if err != nil {
+				log.Fatal(err)
 			}
 
-			for _, version := range versions {
-				parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
-				if err != nil {
-					log.Fatal(err)
-				}
-
-				parsedVersion, err := tagcmp.Parse(version)
-				if err != nil {
-					log.Fatal(err)
-				}
-
-				if parsedVersion.IsLessThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
-					availableDowngrades = append(availableDowngrades, version)
-				}
-			}
-
-			if len(availableDowngrades) == 0 && !internal.Force {
+			if !downgradeAvailable {
 				log.Info("no available downgrades")
-				return nil
+				return
 			}
 		}
 
-		var chosenDowngrade string
-		if len(availableDowngrades) > 0 {
-			if internal.Force || internal.NoInput || specificVersion != "" {
+		if internal.Force || internal.NoInput || chosenDowngrade != "" {
+			if len(availableDowngrades) > 0 {
 				chosenDowngrade = availableDowngrades[len(availableDowngrades)-1]
-				log.Debugf("choosing %s as version to downgrade to (--force/--no-input)", chosenDowngrade)
-			} else {
-				msg := fmt.Sprintf("please select a downgrade (version: %s):", deployMeta.Version)
-				if deployMeta.IsChaos {
-					msg = fmt.Sprintf("please select a downgrade (version: %s, chaosVersion: %s):", deployMeta.Version, deployMeta.ChaosVersion)
-				}
-
-				prompt := &survey.Select{
-					Message: msg,
-					Options: internal.ReverseStringList(availableDowngrades),
-				}
-
-				if err := survey.AskOne(prompt, &chosenDowngrade); err != nil {
-					return err
-				}
 			}
+		} else {
+			if err := chooseDowngrade(availableDowngrades, deployMeta, &chosenDowngrade); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		if internal.Force &&
+			chosenDowngrade == "" &&
+			deployMeta.Version != config.UNKNOWN_DEFAULT {
+			chosenDowngrade = deployMeta.Version
+		}
+
+		if chosenDowngrade == "" {
+			log.Fatal("unknown deployed version, unable to downgrade")
 		}
 
 		log.Debugf("choosing %s as version to rollback", chosenDowngrade)
+
 		if _, err := app.Recipe.EnsureVersion(chosenDowngrade); err != nil {
 			log.Fatal(err)
 		}
@@ -175,6 +161,7 @@ beforehand.`,
 			log.Fatal(err)
 		}
 
+		stackName := app.StackName()
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
@@ -191,36 +178,166 @@ beforehand.`,
 		appPkg.ExposeAllEnv(stackName, compose, app.Env)
 		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
 		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
-		appPkg.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
+		if internal.Chaos {
+			appPkg.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
+		}
 		appPkg.SetUpdateLabel(compose, stackName, app.Env)
 
-		chaosVersion := config.CHAOS_DEFAULT
-		if deployMeta.IsChaos {
-			chaosVersion = deployMeta.ChaosVersion
-		}
-
 		// NOTE(d1): no release notes implemeneted for rolling back
-		if err := internal.NewVersionOverview(
+		if err := internal.DeployOverview(
 			app,
-			warnMessages,
-			"rollback",
 			deployMeta.Version,
-			chaosVersion,
 			chosenDowngrade,
-			""); err != nil {
+			"",
+			downgradeWarnMessages,
+		); err != nil {
 			log.Fatal(err)
 		}
 
-		if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
+		stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
+		if err != nil {
 			log.Fatal(err)
 		}
 
-		app.Recipe.Version = chosenDowngrade
-		log.Debugf("choosing %s as version to save to env file", app.Recipe.Version)
-		if err := app.WriteRecipeVersion(app.Recipe.Version, false); err != nil {
-			log.Fatalf("writing new recipe version in env file: %s", err)
+		log.Debugf("set waiting timeout to %d second(s)", stack.WaitTimeout)
+
+		serviceNames, err := appPkg.GetAppServiceNames(app.Name)
+		if err != nil {
+			log.Fatal(err)
 		}
 
-		return nil
+		f, err := app.Filters(true, false, serviceNames...)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if err := stack.RunDeploy(
+			cl,
+			deployOpts,
+			compose,
+			stackName,
+			app.Server,
+			internal.DontWaitConverge,
+			f,
+		); err != nil {
+			log.Fatal(err)
+		}
+
+		if err := app.WriteRecipeVersion(chosenDowngrade, false); err != nil {
+			log.Fatalf("writing recipe version failed: %s", err)
+		}
 	},
 }
+
+// chooseDowngrade prompts the user to choose an downgrade interactively.
+func chooseDowngrade(
+	availableDowngrades []string,
+	deployMeta stack.DeployMeta,
+	chosenDowngrade *string,
+) error {
+	msg := fmt.Sprintf("please select a downgrade (version: %s):", deployMeta.Version)
+
+	if deployMeta.IsChaos {
+		chaosVersion := formatter.BoldDirtyDefault(deployMeta.ChaosVersion)
+
+		msg = fmt.Sprintf(
+			"please select a downgrade (version: %s, chaos: %s):",
+			deployMeta.Version,
+			chaosVersion,
+		)
+	}
+
+	prompt := &survey.Select{
+		Message: msg,
+		Options: internal.SortVersionsDesc(availableDowngrades),
+	}
+
+	if err := survey.AskOne(prompt, chosenDowngrade); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// validateDownpgradeVersionArg validates the specific version.
+func validateDowngradeVersionArg(
+	specificVersion string,
+	app app.App,
+	deployMeta stack.DeployMeta,
+) error {
+	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+	if err != nil {
+		return fmt.Errorf("current deployment '%s' is not a known version for %s", deployMeta.Version, app.Recipe.Name)
+	}
+
+	parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
+	if err != nil {
+		return fmt.Errorf("'%s' is not a known version for %s", specificVersion, app.Recipe.Name)
+	}
+
+	if parsedSpecificVersion.IsGreaterThan(parsedDeployedVersion) &&
+		!parsedSpecificVersion.Equals(parsedDeployedVersion) {
+		return fmt.Errorf("%s is not a downgrade for %s?", deployMeta.Version, specificVersion)
+	}
+
+	if parsedSpecificVersion.Equals(parsedDeployedVersion) && !internal.Force {
+		return fmt.Errorf("%s is not a downgrade for %s?", deployMeta.Version, specificVersion)
+	}
+
+	return nil
+}
+
+// ensureDowngradesAvailable ensures that there are available downgrades.
+func ensureDowngradesAvailable(
+	versions []string,
+	availableDowngrades *[]string,
+	deployMeta stack.DeployMeta,
+) (bool, error) {
+	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+	if err != nil {
+		return false, err
+	}
+
+	for _, version := range versions {
+		parsedVersion, err := tagcmp.Parse(version)
+		if err != nil {
+			return false, err
+		}
+
+		if parsedVersion.IsLessThan(parsedDeployedVersion) &&
+			!(parsedVersion.Equals(parsedDeployedVersion)) {
+			*availableDowngrades = append(*availableDowngrades, version)
+		}
+	}
+
+	if len(*availableDowngrades) == 0 && !internal.Force {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+func init() {
+	AppRollbackCommand.Flags().BoolVarP(
+		&internal.Force,
+		"force",
+		"f",
+		false,
+		"perform action without further prompt",
+	)
+
+	AppRollbackCommand.Flags().BoolVarP(
+		&internal.NoDomainChecks,
+		"no-domain-checks",
+		"D",
+		false,
+		"disable public DNS checks",
+	)
+
+	AppRollbackCommand.Flags().BoolVarP(
+		&internal.DontWaitConverge, "no-converge-checks",
+		"c",
+		false,
+		"disable converge logic checks",
+	)
+}

cli/app/run.go

@@ -2,7 +2,6 @@ package app
 
 import (
 	"context"
-	"errors"
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
@@ -12,56 +11,50 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/docker/api/types"
+	containertypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var user string
-var userFlag = &cli.StringFlag{
-	Name:        "user",
-	Aliases:     []string{"u"},
-	Value:       "",
-	Destination: &user,
-}
-
-var noTTY bool
-var noTTYFlag = &cli.BoolFlag{
-	Name:        "no-tty",
-	Aliases:     []string{"t"},
-	Destination: &noTTY,
-}
-
-var appRunCommand = cli.Command{
-	Name:    "run",
+var AppRunCommand = &cobra.Command{
+	Use:     "run <domain> <service> <cmd> [[args] [flags] | [flags] -- [args]]",
 	Aliases: []string{"r"},
-	Flags: []cli.Flag{
-		noTTYFlag,
-		userFlag,
+	Short:   "Run a command inside a service container",
+	Example: `  # run <cmd> with args/flags
+  abra app run 1312.net app -- ls -lha
+
+  # run <cmd> without args/flags
+  abra app run 1312.net app bash --user nobody
+
+  # run <cmd> with both kinds of args/flags 
+  abra app run 1312.net app --user nobody -- ls -lha`,
+	Args: cobra.MinimumNArgs(3),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		case 1:
+			return autocomplete.ServiceNameComplete(args[0])
+		case 2:
+			return autocomplete.CommandNameComplete(args[0])
+		default:
+			return nil, cobra.ShellCompDirectiveError
+		}
 	},
-	Before:        internal.SubCommandBefore,
-	Usage:         "Run a command in an app service",
-	UsageText:     "abra app run <domain> <service> <args> [options]",
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-
-		if cmd.Args().Len() < 2 {
-			internal.ShowSubcommandHelpAndError(cmd, errors.New("no <service> provided?"))
-		}
-
-		if cmd.Args().Len() < 3 {
-			internal.ShowSubcommandHelpAndError(cmd, errors.New("no <args> provided?"))
-		}
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		serviceName := cmd.Args().Get(1)
+		serviceName := args[1]
 		stackAndServiceName := fmt.Sprintf("^%s_%s", app.StackName(), serviceName)
+
 		filters := filters.NewArgs()
 		filters.Add("name", stackAndServiceName)
 
@@ -70,24 +63,23 @@ var appRunCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		c := cmd.Args().Slice()[2:]
-		execCreateOpts := types.ExecConfig{
+		userCmd := args[2:]
+		execCreateOpts := containertypes.ExecOptions{
 			AttachStderr: true,
 			AttachStdin:  true,
 			AttachStdout: true,
-			Cmd:          c,
+			Cmd:          userCmd,
 			Detach:       false,
 			Tty:          true,
 		}
 
-		if user != "" {
-			execCreateOpts.User = user
+		if runAsUser != "" {
+			execCreateOpts.User = runAsUser
 		}
 		if noTTY {
 			execCreateOpts.Tty = false
 		}
 
-		// FIXME: avoid instantiating a new CLI
 		dcli, err := command.NewDockerCli()
 		if err != nil {
 			log.Fatal(err)
@@ -96,7 +88,27 @@ var appRunCommand = cli.Command{
 		if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
 			log.Fatal(err)
 		}
-
-		return nil
 	},
 }
+
+var (
+	noTTY     bool
+	runAsUser string
+)
+
+func init() {
+	AppRunCommand.Flags().BoolVarP(&noTTY,
+		"no-tty",
+		"t",
+		false,
+		"do not request a TTY",
+	)
+
+	AppRunCommand.Flags().StringVarP(
+		&runAsUser,
+		"user",
+		"u",
+		"",
+		"run command as user",
+	)
+}

cli/app/secret.go

@@ -2,7 +2,6 @@ package app
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"os"
 	"strconv"
@@ -17,57 +16,45 @@ import (
 	"coopcloud.tech/abra/pkg/secret"
 	"github.com/docker/docker/api/types"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var (
-	allSecrets     bool
-	allSecretsFlag = &cli.BoolFlag{
-		Name:        "all",
-		Aliases:     []string{"a"},
-		Destination: &allSecrets,
-		Usage:       "Generate all secrets",
-	}
-)
-
-var (
-	rmAllSecrets     bool
-	rmAllSecretsFlag = &cli.BoolFlag{
-		Name:        "all",
-		Aliases:     []string{"a"},
-		Destination: &rmAllSecrets,
-		Usage:       "Remove all secrets",
-	}
-)
-
-var appSecretGenerateCommand = cli.Command{
-	Name:      "generate",
-	Aliases:   []string{"g"},
-	Usage:     "Generate secrets",
-	UsageText: "abra app secret generate <domain> <secret> <version> [options]",
-	Flags: []cli.Flag{
-		allSecretsFlag,
-		internal.PassFlag,
-		internal.MachineReadableFlag,
-		internal.ChaosFlag,
+var AppSecretGenerateCommand = &cobra.Command{
+	Use:     "generate <domain> [[secret] [version] | --all] [flags]",
+	Aliases: []string{"g"},
+	Short:   "Generate secrets",
+	Args:    cobra.RangeArgs(1, 3),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		case 1:
+			app, err := appPkg.Get(args[0])
+			if err != nil {
+				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
+				return []string{errMsg}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.SecretComplete(app.Recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
-		if cmd.Args().Len() == 1 && !allSecrets {
-			err := errors.New("missing arguments <secret>/<version> or '--all'")
-			internal.ShowSubcommandHelpAndError(cmd, err)
+		if len(args) <= 2 && !generateAllSecrets {
+			log.Fatal("missing arguments [secret]/[version] or '--all'")
 		}
 
-		if cmd.Args().Get(1) != "" && allSecrets {
-			err := errors.New("cannot use '<secret> <version>' and '--all' together")
-			internal.ShowSubcommandHelpAndError(cmd, err)
+		if len(args) > 2 && generateAllSecrets {
+			log.Fatal("cannot use '[secret] [version]' and '--all' together")
 		}
 
 		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
@@ -80,9 +67,9 @@ var appSecretGenerateCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		if !allSecrets {
-			secretName := cmd.Args().Get(1)
-			secretVersion := cmd.Args().Get(2)
+		if !generateAllSecrets {
+			secretName := args[1]
+			secretVersion := args[2]
 			s, ok := secrets[secretName]
 			if !ok {
 				log.Fatalf("%s doesn't exist in the env config?", secretName)
@@ -103,7 +90,7 @@ var appSecretGenerateCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		if internal.Pass {
+		if storeInPass {
 			for name, data := range secretVals {
 				if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil {
 					log.Fatal(err)
@@ -137,48 +124,62 @@ var appSecretGenerateCommand = cli.Command{
 				log.Fatal("unable to render to JSON: %s", err)
 			}
 			fmt.Println(out)
-			return nil
+			return
 		}
 
-		fmt.Println(table)
+		if err := formatter.PrintTable(table); err != nil {
+			log.Fatal(err)
+		}
 
 		log.Warnf(
 			"generated secrets %s shown again, please take note of them %s",
 			formatter.BoldStyle.Render("NOT"),
 			formatter.BoldStyle.Render("NOW"),
 		)
-
-		return nil
 	},
 }
 
-var appSecretInsertCommand = cli.Command{
-	Name:      "insert",
-	Aliases:   []string{"i"},
-	Usage:     "Insert secret",
-	UsageText: "abra app secret insert <domain> <secret> <version> <data> [options]",
-	Flags: []cli.Flag{
-		internal.PassFlag,
-		internal.FileFlag,
-		internal.TrimFlag,
-		internal.ChaosFlag,
-	},
-	Before:          internal.SubCommandBefore,
-	ShellComplete:   autocomplete.AppNameComplete,
-	HideHelpCommand: true,
-	Description: `This command inserts a secret into an app environment.
+var AppSecretInsertCommand = &cobra.Command{
+	Use:     "insert <domain> <secret> <version> <data> [flags]",
+	Aliases: []string{"i"},
+	Short:   "Insert secret",
+	Long: `This command inserts a secret into an app environment.
+
+Arbitrary secret insertion is not supported. Secrets that are inserted must
+match those configured in the recipe beforehand.
 
 This can be useful when you want to manually generate secrets for an app
 environment. Typically, you can let Abra generate them for you on app creation
-(see "abra app new --secrets" for more).`,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-			log.Fatal(err)
-		}
+(see "abra app new --secrets/-S" for more).`,
+	Example: `  # insert regular secret
+  abra app secret insert 1312.net my_secret v1 mySuperSecret
 
-		if cmd.Args().Len() != 4 {
-			internal.ShowSubcommandHelpAndError(cmd, errors.New("missing arguments?"))
+  # insert secret as file
+  abra app secret insert 1312.net my_secret v1 secret.txt -f`,
+	Args: cobra.MinimumNArgs(4),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		case 1:
+			app, err := appPkg.Get(args[0])
+			if err != nil {
+				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
+				return []string{errMsg}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.SecretComplete(app.Recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
@@ -186,11 +187,31 @@ environment. Typically, you can let Abra generate them for you on app creation
 			log.Fatal(err)
 		}
 
-		name := cmd.Args().Get(1)
-		version := cmd.Args().Get(2)
-		data := cmd.Args().Get(3)
+		name := args[1]
+		version := args[2]
+		data := args[3]
 
-		if internal.File {
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		secrets, err := secret.ReadSecretsConfig(app.Path, composeFiles, app.StackName())
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		var isRecipeSecret bool
+		for secretName := range secrets {
+			if secretName == name {
+				isRecipeSecret = true
+			}
+		}
+		if !isRecipeSecret {
+			log.Fatalf("no secret %s available for recipe %s?", name, app.Recipe.Name)
+		}
+
+		if insertFromFile {
 			raw, err := os.ReadFile(data)
 			if err != nil {
 				log.Fatalf("reading secret from file: %s", err)
@@ -198,7 +219,7 @@ environment. Typically, you can let Abra generate them for you on app creation
 			data = string(raw)
 		}
 
-		if internal.Trim {
+		if trimInput {
 			data = strings.TrimSpace(data)
 		}
 
@@ -209,13 +230,11 @@ environment. Typically, you can let Abra generate them for you on app creation
 
 		log.Infof("%s successfully stored on server", secretName)
 
-		if internal.Pass {
+		if storeInPass {
 			if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil {
 				log.Fatal(err)
 			}
 		}
-
-		return nil
 	},
 }
 
@@ -227,7 +246,7 @@ func secretRm(cl *dockerClient.Client, app appPkg.App, secretName, parsed string
 
 	log.Infof("deleted %s successfully from server", secretName)
 
-	if internal.PassRemove {
+	if removeFromPass {
 		if err := secret.PassRmSecret(parsed, app.StackName(), app.Server); err != nil {
 			return err
 		}
@@ -238,30 +257,41 @@ func secretRm(cl *dockerClient.Client, app appPkg.App, secretName, parsed string
 	return nil
 }
 
-var appSecretRmCommand = cli.Command{
-	Name:      "remove",
-	Aliases:   []string{"rm"},
-	Usage:     "Remove a secret",
-	UsageText: "abra app remove <domainabra app remove <domain> [options]",
-	Flags: []cli.Flag{
-		internal.NoInputFlag,
-		rmAllSecretsFlag,
-		internal.PassRemoveFlag,
-		internal.OfflineFlag,
-		internal.ChaosFlag,
+var AppSecretRmCommand = &cobra.Command{
+	Use:     "remove <domain> [[secret] | --all] [flags]",
+	Aliases: []string{"rm"},
+	Short:   "Remove a secret",
+	Long: `This command removes a secret from an app environment.
+
+Arbitrary secret removal is not supported. Secrets that are removed must
+match those configured in the recipe beforehand.`,
+	Example: "  abra app secret rm 1312.net oauth_key",
+	Args:    cobra.RangeArgs(1, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		case 1:
+			if !rmAllSecrets {
+				app, err := appPkg.Get(args[0])
+				if err != nil {
+					errMsg := fmt.Sprintf("autocomplete failed: %s", err)
+					return []string{errMsg}, cobra.ShellCompDirectiveError
+				}
+				return autocomplete.SecretComplete(app.Recipe.Name)
+			}
+			return nil, cobra.ShellCompDirectiveDefault
+		default:
+			return nil, cobra.ShellCompDirectiveError
+		}
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.AppNameComplete,
-	Description: `
-This command removes app secrets.
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-Example:
-
-    abra app secret remove myapp db_pass`,
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
@@ -275,12 +305,12 @@ Example:
 			log.Fatal(err)
 		}
 
-		if cmd.Args().Get(1) != "" && rmAllSecrets {
-			internal.ShowSubcommandHelpAndError(cmd, errors.New("cannot use '<secret-name>' and '--all' together"))
+		if len(args) == 2 && rmAllSecrets {
+			log.Fatal("cannot use [secret] and --all/-a together")
 		}
 
-		if cmd.Args().Get(1) == "" && !rmAllSecrets {
-			internal.ShowSubcommandHelpAndError(cmd, errors.New("no secret(s) specified?"))
+		if len(args) != 2 && !rmAllSecrets {
+			log.Fatal("no secret(s) specified?")
 		}
 
 		cl, err := client.New(app.Server)
@@ -303,8 +333,12 @@ Example:
 			remoteSecretNames[cont.Spec.Annotations.Name] = true
 		}
 
+		var secretToRm string
+		if len(args) == 2 {
+			secretToRm = args[1]
+		}
+
 		match := false
-		secretToRm := cmd.Args().Get(1)
 		for secretName, val := range secrets {
 			secretRemoteName := fmt.Sprintf("%s_%s_%s", app.StackName(), secretName, val.Version)
 			if _, ok := remoteSecretNames[secretRemoteName]; ok {
@@ -314,7 +348,7 @@ Example:
 							log.Fatal(err)
 						}
 
-						return nil
+						return
 					}
 				} else {
 					match = true
@@ -333,27 +367,24 @@ Example:
 		if !match {
 			log.Fatal("no secrets to remove?")
 		}
-
-		return nil
 	},
 }
 
-var appSecretLsCommand = cli.Command{
-	Name:    "list",
+var AppSecretLsCommand = &cobra.Command{
+	Use:     "list <domain>",
 	Aliases: []string{"ls"},
-	Flags: []cli.Flag{
-		internal.OfflineFlag,
-		internal.ChaosFlag,
-		internal.MachineReadableFlag,
+	Short:   "List all secrets",
+	Args:    cobra.MinimumNArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	Usage:         "List all secrets",
-	UsageText:     "abra app secret list [options]",
-	HideHelp:      true,
-	ShellComplete: autocomplete.AppNameComplete,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
@@ -395,28 +426,137 @@ var appSecretLsCommand = cli.Command{
 					log.Fatal("unable to render to JSON: %s", err)
 				}
 				fmt.Println(out)
-				return nil
+				return
 			}
 
-			fmt.Println(table)
-			return nil
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
+			}
+
+			return
 		}
 
 		log.Warnf("no secrets stored for %s", app.Name)
-
-		return nil
 	},
 }
 
-var appSecretCommand = cli.Command{
-	Name:      "secret",
-	Aliases:   []string{"s"},
-	Usage:     "Manage app secrets",
-	UsageText: "abra app secret [command] [arguments] [options]",
-	Commands: []*cli.Command{
-		&appSecretGenerateCommand,
-		&appSecretInsertCommand,
-		&appSecretRmCommand,
-		&appSecretLsCommand,
-	},
+var AppSecretCommand = &cobra.Command{
+	Use:     "secret [cmd] [args] [flags]",
+	Aliases: []string{"s"},
+	Short:   "Manage app secrets",
+}
+
+var (
+	storeInPass        bool
+	insertFromFile     bool
+	trimInput          bool
+	rmAllSecrets       bool
+	generateAllSecrets bool
+	removeFromPass     bool
+)
+
+func init() {
+	AppSecretGenerateCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		"machine",
+		"m",
+		false,
+		"print machine-readable output",
+	)
+
+	AppSecretGenerateCommand.Flags().BoolVarP(
+		&storeInPass,
+		"pass",
+		"p",
+		false,
+		"store generated secrets in a local pass store",
+	)
+
+	AppSecretGenerateCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+
+	AppSecretGenerateCommand.Flags().BoolVarP(
+		&generateAllSecrets,
+		"all",
+		"a",
+		false,
+		"generate all secrets",
+	)
+
+	AppSecretInsertCommand.Flags().BoolVarP(
+		&storeInPass,
+		"pass",
+		"p",
+		false,
+		"store generated secrets in a local pass store",
+	)
+
+	AppSecretInsertCommand.Flags().BoolVarP(
+		&insertFromFile,
+		"file",
+		"f",
+		false,
+		"treat input as a file",
+	)
+
+	AppSecretInsertCommand.Flags().BoolVarP(
+		&trimInput,
+		"trim",
+		"t",
+		false,
+		"trim input",
+	)
+
+	AppSecretInsertCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+
+	AppSecretRmCommand.Flags().BoolVarP(
+		&rmAllSecrets,
+		"all",
+		"a",
+		false,
+		"remove all secrets",
+	)
+
+	AppSecretRmCommand.Flags().BoolVarP(
+		&removeFromPass,
+		"pass",
+		"p",
+		false,
+		"remove generated secrets from a local pass store",
+	)
+
+	AppSecretRmCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+
+	AppSecretLsCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+
+	AppSecretLsCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		"machine",
+		"m",
+		false,
+		"print machine-readable output",
+	)
 }

cli/app/services.go

@@ -13,20 +13,24 @@ import (
 	"coopcloud.tech/abra/pkg/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	containerTypes "github.com/docker/docker/api/types/container"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appServicesCommand = cli.Command{
-	Name:          "services",
-	Aliases:       []string{"sr"},
-	Usage:         "Display all services of an app",
-	UsageText:     "abra app services <domain> [options]",
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+var AppServicesCommand = &cobra.Command{
+	Use:     "services <domain> [flags]",
+	Aliases: []string{"sr"},
+	Short:   "Display all services of an app",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
@@ -59,7 +63,7 @@ var appServicesCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		headers := []string{"SERVICE (SHORT)", "SERVICE (LONG)", "IMAGE"}
+		headers := []string{"SERVICE (SHORT)", "SERVICE (LONG)"}
 		table.Headers(headers...)
 
 		var rows [][]string
@@ -76,7 +80,6 @@ var appServicesCommand = cli.Command{
 			row := []string{
 				serviceShortName,
 				serviceLongName,
-				formatter.RemoveSha(container.Image),
 			}
 
 			rows = append(rows, row)
@@ -85,9 +88,9 @@ var appServicesCommand = cli.Command{
 		table.Rows(rows...)
 
 		if len(rows) > 0 {
-			fmt.Println(table)
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
+			}
 		}
-
-		return nil
 	},
 }

cli/app/undeploy.go

@@ -14,16 +14,98 @@ import (
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var prune bool
+var AppUndeployCommand = &cobra.Command{
+	Use:     "undeploy <domain> [flags]",
+	Aliases: []string{"un"},
+	Short:   "Undeploy an app",
+	Long: `This does not destroy any application data.
 
-var pruneFlag = &cli.BoolFlag{
-	Name:        "prune",
-	Aliases:     []string{"p"},
-	Destination: &prune,
-	Usage:       "Prunes unused containers, networks, and dangling images for an app",
+However, you should remain vigilant, as your swarm installation will consider
+any previously attached volumes as eligible for pruning once undeployed.
+
+Passing "--prune/-p" does not remove those volumes.`,
+	Args: cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+		stackName := app.StackName()
+
+		if err := app.Recipe.EnsureExists(); err != nil {
+			log.Fatal(err)
+		}
+
+		cl, err := client.New(app.Server)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		log.Debugf("checking whether %s is already deployed", stackName)
+
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if !deployMeta.IsDeployed {
+			log.Fatalf("%s is not deployed?", app.Name)
+		}
+
+		if err := internal.DeployOverview(
+			app,
+			deployMeta.Version,
+			config.NO_DOMAIN_DEFAULT,
+			"",
+			nil,
+		); err != nil {
+			log.Fatal(err)
+		}
+
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		opts := stack.Deploy{Composefiles: composeFiles, Namespace: stackName}
+		compose, err := appPkg.GetAppComposeConfig(app.Name, opts, app.Env)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		log.Info("initialising undeploy")
+
+		rmOpts := stack.Remove{
+			Namespaces: []string{stackName},
+			Detach:     false,
+		}
+		if err := stack.RunRemove(context.Background(), cl, rmOpts); err != nil {
+			log.Fatal(err)
+		}
+
+		if prune {
+			if err := pruneApp(cl, app); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		log.Info("undeploy succeeded 🟢")
+
+		if err := app.WriteRecipeVersion(deployMeta.Version, false); err != nil {
+			log.Fatalf("writing recipe version failed: %s", err)
+		}
+	},
 }
 
 // pruneApp runs the equivalent of a "docker system prune" but only filtering
@@ -62,68 +144,16 @@ func pruneApp(cl *dockerClient.Client, app appPkg.App) error {
 	return nil
 }
 
-var appUndeployCommand = cli.Command{
-	Name:      "undeploy",
-	Aliases:   []string{"un"},
-	UsageText: "abra app undeploy <domain> [options]",
-	Flags: []cli.Flag{
-		internal.NoInputFlag,
-		internal.OfflineFlag,
-		pruneFlag,
-	},
-	Before:        internal.SubCommandBefore,
-	Usage:         "Undeploy an app",
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Description: `This does not destroy any of the application data.
+var (
+	prune bool
+)
 
-However, you should remain vigilant, as your swarm installation will consider
-any previously attached volumes as eligible for pruning once undeployed.
-
-Passing "-p/--prune" does not remove those volumes.`,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
-		stackName := app.StackName()
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		log.Debugf("checking whether %s is already deployed", stackName)
-
-		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		if !deployMeta.IsDeployed {
-			log.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		chaosVersion := config.CHAOS_DEFAULT
-		if deployMeta.IsChaos {
-			chaosVersion = deployMeta.ChaosVersion
-		}
-
-		if err := internal.DeployOverview(app, []string{}, deployMeta.Version, chaosVersion); err != nil {
-			log.Fatal(err)
-		}
-
-		rmOpts := stack.Remove{
-			Namespaces: []string{app.StackName()},
-			Detach:     false,
-		}
-		if err := stack.RunRemove(context.Background(), cl, rmOpts); err != nil {
-			log.Fatal(err)
-		}
-
-		if prune {
-			if err := pruneApp(cl, app); err != nil {
-				log.Fatal(err)
-			}
-		}
-
-		return nil
-	},
+func init() {
+	AppUndeployCommand.Flags().BoolVarP(
+		&prune,
+		"prune",
+		"p",
+		false,
+		"prune unused containers, networks, and dangling images",
+	)
 }

cli/app/upgrade.go

@@ -3,55 +3,91 @@ package app
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/app"
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/envfile"
+	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/recipe"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/urfave/cli/v3"
+	dockerClient "github.com/docker/docker/client"
+	"github.com/spf13/cobra"
 )
 
-var appUpgradeCommand = cli.Command{
-	Name:      "upgrade",
-	Aliases:   []string{"up"},
-	Usage:     "Upgrade an app",
-	UsageText: "abra app upgrade <domain> [<version>] [options]",
-	Flags: []cli.Flag{
-		internal.ForceFlag,
-		internal.NoDomainChecksFlag,
-		internal.DontWaitConvergeFlag,
-		internal.ReleaseNotesFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `Upgrade an app.
+var AppUpgradeCommand = &cobra.Command{
+	Use:     "upgrade <domain> [version] [flags]",
+	Aliases: []string{"up"},
+	Short:   "Upgrade an app",
+	Long: `Upgrade an app.
 
-Unlike "deploy", chaos operations are not supported here. Only recipe versions
-are supported values for "[<version>]".
+Unlike "abra app deploy", chaos operations are not supported here. Only recipe
+versions are supported values for "[version]".
+
+It is possible to "--force/-f" an upgrade if you want to re-deploy a specific
+version.
+
+Only the deployed version is consulted when trying to determine what upgrades
+are available. The live deployment version is the "source of truth" in this
+case. The stored .env version is not consulted.
 
 An upgrade can be destructive, please ensure you have a copy of your app data
-beforehand.`,
-	HideHelp:      true,
-	ShellComplete: autocomplete.AppNameComplete,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		var warnMessages []string
+beforehand. See "abra app backup" for more.`,
+	Args: cobra.RangeArgs(1, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string,
+	) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.AppNameComplete()
+		case 1:
+			app, err := appPkg.Get(args[0])
+			if err != nil {
+				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
+				return []string{errMsg}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.RecipeVersionComplete(app.Recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveError
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		var (
+			upgradeWarnMessages []string
+			chosenUpgrade       string
+			availableUpgrades   []string
+			upgradeReleaseNotes string
+		)
 
-		app := internal.ValidateApp(cmd)
-		stackName := app.StackName()
+		app := internal.ValidateApp(args)
 
-		specificVersion := cmd.Args().Get(1)
-		if specificVersion != "" {
-			log.Debugf("overriding env file version (%s) with %s", app.Recipe.Version, specificVersion)
-			app.Recipe.Version = specificVersion
+		if err := app.Recipe.Ensure(recipe.EnsureContext{
+			Chaos:   internal.Chaos,
+			Offline: internal.Offline,
+			// Ignore the env version for now, to make sure we are at the latest commit.
+			// This enables us to get release notes, that were added after a release.
+			IgnoreEnvVersion: true,
+		}); err != nil {
+			log.Fatal(err)
 		}
 
-		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+		cl, err := client.New(app.Server)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		deployMeta, err := ensureDeployed(cl, app)
+		if err != nil {
 			log.Fatal(err)
 		}
 
@@ -59,134 +95,68 @@ beforehand.`,
 			log.Fatal(err)
 		}
 
-		log.Debugf("checking whether %s is already deployed", stackName)
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		if !deployMeta.IsDeployed {
-			log.Fatalf("%s is not deployed?", app.Name)
-		}
-
 		versions, err := app.Recipe.Tags()
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		var availableUpgrades []string
-		if deployMeta.Version == "unknown" {
+		// NOTE(d1): we've no idea what the live deployment version is, so every
+		// possible upgrade can be shown. it's up to the user to make the choice
+		if deployMeta.Version == config.UNKNOWN_DEFAULT {
 			availableUpgrades = versions
-			warnMessages = append(warnMessages, fmt.Sprintf("failed to determine deployed version of %s", app.Name))
 		}
 
-		if specificVersion != "" {
-			parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
-			if err != nil {
-				log.Fatalf("'%s' is not a known version for %s", deployMeta.Version, app.Recipe.Name)
-			}
-			parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
-			if err != nil {
-				log.Fatalf("'%s' is not a known version for %s", specificVersion, app.Recipe.Name)
+		if len(args) == 2 && args[1] != "" {
+			chosenUpgrade = args[1]
+
+			if err := validateUpgradeVersionArg(chosenUpgrade, app, deployMeta); err != nil {
+				log.Fatal(err)
 			}
 
-			if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) && !parsedSpecificVersion.Equals(parsedDeployedVersion) {
-				log.Fatalf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
-			}
-
-			if parsedSpecificVersion.Equals(parsedDeployedVersion) && !internal.Force {
-				log.Fatalf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
-			}
-
-			availableUpgrades = append(availableUpgrades, specificVersion)
+			availableUpgrades = append(availableUpgrades, chosenUpgrade)
 		}
 
-		parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		if deployMeta.Version != "unknown" && specificVersion == "" {
-			if deployMeta.IsChaos {
-				warnMessages = append(warnMessages, fmt.Sprintf("attempting to upgrade a chaos deployment"))
-			}
-
-			for _, version := range versions {
-				parsedVersion, err := tagcmp.Parse(version)
-				if err != nil {
-					log.Fatal(err)
-				}
-				if parsedVersion.IsGreaterThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
-					availableUpgrades = append(availableUpgrades, version)
-				}
-			}
-
-			if len(availableUpgrades) == 0 && !internal.Force {
-				log.Info("no available upgrades")
-				return nil
-			}
-		}
-
-		var chosenUpgrade string
-		if len(availableUpgrades) > 0 {
-			if internal.Force || internal.NoInput || specificVersion != "" {
-				chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
-				log.Debugf("choosing %s as version to upgrade to", chosenUpgrade)
-			} else {
-				msg := fmt.Sprintf("please select an upgrade (version: %s):", deployMeta.Version)
-				if deployMeta.IsChaos {
-					msg = fmt.Sprintf("please select an upgrade (version: %s, chaosVersion: %s):", deployMeta.Version, deployMeta.ChaosVersion)
-				}
-
-				prompt := &survey.Select{
-					Message: msg,
-					Options: internal.ReverseStringList(availableUpgrades),
-				}
-
-				if err := survey.AskOne(prompt, &chosenUpgrade); err != nil {
-					return err
-				}
-			}
-		}
-
-		if internal.Force && chosenUpgrade == "" {
-			warnMessages = append(warnMessages, fmt.Sprintf("%s is already upgraded to latest", app.Name))
-			chosenUpgrade = deployMeta.Version
-		}
-
-		// if release notes written after git tag published, read them before we
-		// check out the tag and then they'll appear to be missing. this covers
-		// when we obviously will forget to write release notes before publishing
-		var releaseNotes string
-		if chosenUpgrade != "" {
-			parsedChosenUpgrade, err := tagcmp.Parse(chosenUpgrade)
+		if deployMeta.Version != config.UNKNOWN_DEFAULT && chosenUpgrade == "" {
+			upgradeAvailable, err := ensureUpgradesAvailable(app, versions, &availableUpgrades, deployMeta)
 			if err != nil {
 				log.Fatal(err)
 			}
-			for _, version := range versions {
-				parsedVersion, err := tagcmp.Parse(version)
-				if err != nil {
-					log.Fatal(err)
-				}
-				if parsedVersion.IsGreaterThan(parsedDeployedVersion) && parsedVersion.IsLessThan(parsedChosenUpgrade) {
-					note, err := app.Recipe.GetReleaseNotes(version)
-					if err != nil {
-						return err
-					}
-					if note != "" {
-						releaseNotes += fmt.Sprintf("%s\n", note)
-					}
-				}
+
+			if !upgradeAvailable {
+				log.Info("no available upgrades")
+				return
 			}
 		}
 
+		if internal.Force || internal.NoInput || chosenUpgrade != "" {
+			if len(availableUpgrades) > 0 {
+				chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
+			}
+		} else {
+			if err := chooseUpgrade(availableUpgrades, deployMeta, &chosenUpgrade); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		if internal.Force &&
+			chosenUpgrade == "" &&
+			deployMeta.Version != config.UNKNOWN_DEFAULT {
+			chosenUpgrade = deployMeta.Version
+		}
+
+		if chosenUpgrade == "" {
+			log.Fatal("unknown deployed version, unable to upgrade")
+		}
+
 		log.Debugf("choosing %s as version to upgrade", chosenUpgrade)
+
+		// Get the release notes before checking out the new version in the
+		// recipe. This enables us to get release notes, that were added after
+		// a release.
+		if err := getReleaseNotes(app, versions, chosenUpgrade, deployMeta, &upgradeReleaseNotes); err != nil {
+			log.Fatal(err)
+		}
+
 		if _, err := app.Recipe.EnsureVersion(chosenUpgrade); err != nil {
 			log.Fatal(err)
 		}
@@ -204,6 +174,7 @@ beforehand.`,
 			log.Fatal(err)
 		}
 
+		stackName := app.StackName()
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
@@ -220,7 +191,9 @@ beforehand.`,
 		appPkg.ExposeAllEnv(stackName, compose, app.Env)
 		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
 		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
-		appPkg.SetChaosVersionLabel(compose, stackName, chosenUpgrade)
+		if internal.Chaos {
+			appPkg.SetChaosVersionLabel(compose, stackName, chosenUpgrade)
+		}
 		appPkg.SetUpdateLabel(compose, stackName, app.Env)
 
 		envVars, err := appPkg.CheckEnv(app)
@@ -230,31 +203,31 @@ beforehand.`,
 
 		for _, envVar := range envVars {
 			if !envVar.Present {
-				warnMessages = append(warnMessages,
-					fmt.Sprintf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain),
+				upgradeWarnMessages = append(upgradeWarnMessages,
+					fmt.Sprintf("%s missing from %s.env", envVar.Name, app.Domain),
 				)
 			}
 		}
 
-		if internal.ReleaseNotes {
-			fmt.Println()
-			fmt.Print(releaseNotes)
-			return nil
+		if showReleaseNotes {
+			fmt.Print(upgradeReleaseNotes)
+			return
 		}
 
-		chaosVersion := config.CHAOS_DEFAULT
-		if deployMeta.IsChaos {
-			chaosVersion = deployMeta.ChaosVersion
+		if upgradeReleaseNotes == "" {
+			upgradeWarnMessages = append(
+				upgradeWarnMessages,
+				fmt.Sprintf("no release notes available for %s", chosenUpgrade),
+			)
 		}
 
-		if err := internal.NewVersionOverview(
+		if err := internal.DeployOverview(
 			app,
-			warnMessages,
-			"upgrade",
 			deployMeta.Version,
-			chaosVersion,
 			chosenUpgrade,
-			releaseNotes); err != nil {
+			upgradeReleaseNotes,
+			upgradeWarnMessages,
+		); err != nil {
 			log.Fatal(err)
 		}
 
@@ -262,26 +235,227 @@ beforehand.`,
 		if err != nil {
 			log.Fatal(err)
 		}
-		log.Debugf("set waiting timeout to %d s", stack.WaitTimeout)
 
-		if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
+		log.Debugf("set waiting timeout to %d second(s)", stack.WaitTimeout)
+
+		serviceNames, err := appPkg.GetAppServiceNames(app.Name)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		f, err := app.Filters(true, false, serviceNames...)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if err := stack.RunDeploy(
+			cl,
+			deployOpts,
+			compose,
+			stackName,
+			app.Server,
+			internal.DontWaitConverge,
+			f,
+		); err != nil {
 			log.Fatal(err)
 		}
 
 		postDeployCmds, ok := app.Env["POST_UPGRADE_CMDS"]
 		if ok && !internal.DontWaitConverge {
 			log.Debugf("run the following post-deploy commands: %s", postDeployCmds)
+
 			if err := internal.PostCmds(cl, app, postDeployCmds); err != nil {
 				log.Fatalf("attempting to run post deploy commands, saw: %s", err)
 			}
 		}
 
-		app.Recipe.Version = chosenUpgrade
-		log.Debugf("choosing %s as version to save to env file", app.Recipe.Version)
-		if err := app.WriteRecipeVersion(app.Recipe.Version, false); err != nil {
-			log.Fatalf("writing new recipe version in env file: %s", err)
+		if err := app.WriteRecipeVersion(chosenUpgrade, false); err != nil {
+			log.Fatalf("writing recipe version failed: %s", err)
 		}
-
-		return nil
 	},
 }
+
+// chooseUpgrade prompts the user to choose an upgrade interactively.
+func chooseUpgrade(
+	availableUpgrades []string,
+	deployMeta stack.DeployMeta,
+	chosenUpgrade *string,
+) error {
+	msg := fmt.Sprintf("please select an upgrade (version: %s):", deployMeta.Version)
+
+	if deployMeta.IsChaos {
+		chaosVersion := formatter.BoldDirtyDefault(deployMeta.ChaosVersion)
+
+		msg = fmt.Sprintf(
+			"please select an upgrade (version: %s, chaos: %s):",
+			deployMeta.Version,
+			chaosVersion,
+		)
+	}
+
+	prompt := &survey.Select{
+		Message: msg,
+		Options: internal.SortVersionsDesc(availableUpgrades),
+	}
+
+	if err := survey.AskOne(prompt, chosenUpgrade); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func getReleaseNotes(
+	app app.App,
+	versions []string,
+	chosenUpgrade string,
+	deployMeta stack.DeployMeta,
+	upgradeReleaseNotes *string,
+) error {
+	parsedChosenUpgrade, err := tagcmp.Parse(chosenUpgrade)
+	if err != nil {
+		return fmt.Errorf("parsing chosen upgrade version failed: %s", err)
+	}
+
+	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+	if err != nil {
+		return fmt.Errorf("parsing deployment version failed: %s", err)
+	}
+
+	for _, version := range internal.SortVersionsDesc(versions) {
+		parsedVersion, err := tagcmp.Parse(version)
+		if err != nil {
+			return fmt.Errorf("parsing recipe version failed: %s", err)
+		}
+
+		if parsedVersion.IsGreaterThan(parsedDeployedVersion) &&
+			parsedVersion.IsLessThan(parsedChosenUpgrade) {
+			note, err := app.Recipe.GetReleaseNotes(version)
+			if err != nil {
+				return err
+			}
+
+			if note != "" {
+				// NOTE(d1): trim any final newline on the end of the note itself before
+				//           we manually handle newlines (for multiple release notes and
+				//           ensuring space between the warning messages)
+				note = strings.TrimSuffix(note, "\n")
+
+				*upgradeReleaseNotes += fmt.Sprintf("%s\n", note)
+			}
+		}
+	}
+
+	return nil
+}
+
+// ensureUpgradesAvailable ensures that there are available upgrades.
+func ensureUpgradesAvailable(
+	app app.App,
+	versions []string,
+	availableUpgrades *[]string,
+	deployMeta stack.DeployMeta,
+) (bool, error) {
+	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+	if err != nil {
+		return false, fmt.Errorf("parsing deployed version failed: %s", err)
+	}
+
+	for _, version := range versions {
+		parsedVersion, err := tagcmp.Parse(version)
+		if err != nil {
+			return false, fmt.Errorf("parsing recipe version failed: %s", err)
+		}
+
+		if parsedVersion.IsGreaterThan(parsedDeployedVersion) &&
+			!(parsedVersion.Equals(parsedDeployedVersion)) {
+			*availableUpgrades = append(*availableUpgrades, version)
+		}
+	}
+
+	if len(*availableUpgrades) == 0 && !internal.Force {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+// validateUpgradeVersionArg validates the specific version.
+func validateUpgradeVersionArg(
+	specificVersion string,
+	app app.App,
+	deployMeta stack.DeployMeta,
+) error {
+	parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
+	if err != nil {
+		return fmt.Errorf("'%s' is not a known version for %s", specificVersion, app.Recipe.Name)
+	}
+
+	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+	if err != nil {
+		return fmt.Errorf("'%s' is not a known version", deployMeta.Version)
+	}
+
+	if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) &&
+		!parsedSpecificVersion.Equals(parsedDeployedVersion) {
+		return fmt.Errorf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
+	}
+
+	if parsedSpecificVersion.Equals(parsedDeployedVersion) && !internal.Force {
+		return fmt.Errorf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
+	}
+
+	return nil
+}
+
+// ensureDeployed ensures the app is deployed and if so, returns deployment
+// meta info.
+func ensureDeployed(cl *dockerClient.Client, app app.App) (stack.DeployMeta, error) {
+	log.Debugf("checking whether %s is already deployed", app.StackName())
+
+	deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+	if err != nil {
+		return stack.DeployMeta{}, err
+	}
+
+	if !deployMeta.IsDeployed {
+		return stack.DeployMeta{}, fmt.Errorf("%s is not deployed?", app.Name)
+	}
+
+	return deployMeta, nil
+}
+
+var showReleaseNotes bool
+
+func init() {
+	AppUpgradeCommand.Flags().BoolVarP(
+		&internal.Force,
+		"force",
+		"f",
+		false,
+		"perform action without further prompt",
+	)
+
+	AppUpgradeCommand.Flags().BoolVarP(
+		&internal.NoDomainChecks,
+		"no-domain-checks",
+		"D",
+		false,
+		"disable public DNS checks",
+	)
+
+	AppUpgradeCommand.Flags().BoolVarP(
+		&internal.DontWaitConverge, "no-converge-checks",
+		"c",
+		false,
+		"disable converge logic checks",
+	)
+
+	AppUpgradeCommand.Flags().BoolVarP(
+		&showReleaseNotes,
+		"releasenotes",
+		"r",
+		false,
+		"only show release notes",
+	)
+}

cli/app/volume.go

@@ -11,19 +11,22 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var appVolumeListCommand = cli.Command{
-	Name:          "list",
-	Aliases:       []string{"ls"},
-	UsageText:     "abra app volume list <domain> [options]",
-	Before:        internal.SubCommandBefore,
-	Usage:         "List volumes associated with an app",
-	ShellComplete: autocomplete.AppNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
+var AppVolumeListCommand = &cobra.Command{
+	Use:     "list <domain> [flags]",
+	Aliases: []string{"ls"},
+	Short:   "List volumes associated with an app",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
@@ -40,7 +43,7 @@ var appVolumeListCommand = cli.Command{
 			log.Fatal(err)
 		}
 
-		headers := []string{"name", "created", "mounted"}
+		headers := []string{"NAME", "ON SERVER"}
 
 		table, err := formatter.CreateTable()
 		if err != nil {
@@ -51,27 +54,27 @@ var appVolumeListCommand = cli.Command{
 
 		var rows [][]string
 		for _, volume := range volumes {
-			row := []string{volume.Name, volume.CreatedAt, volume.Mountpoint}
+			row := []string{volume.Name, volume.Mountpoint}
 			rows = append(rows, row)
 		}
 
 		table.Rows(rows...)
 
 		if len(rows) > 0 {
-			fmt.Println(table)
-			return nil
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
+			}
+			return
 		}
 
 		log.Warnf("no volumes created for %s", app.Name)
-
-		return nil
 	},
 }
 
-var appVolumeRemoveCommand = cli.Command{
-	Name:  "remove",
-	Usage: "Remove volume(s) associated with an app",
-	Description: `Remove volumes associated with an app.
+var AppVolumeRemoveCommand = &cobra.Command{
+	Use:   "remove <domain> [volume] [flags]",
+	Short: "Remove volume(s) associated with an app",
+	Long: `Remove volumes associated with an app.
 
 The app in question must be undeployed before you try to remove volumes. See
 "abra app undeploy <domain>" for more.
@@ -81,16 +84,26 @@ you to make a seclection. Use the "?" key to see more help on navigating this
 interface.
 
 Passing "--force/-f" will select all volumes for removal. Be careful.`,
-	UsageText: "abra app volume remove [options] <domain>",
-	Aliases:   []string{"rm"},
-	Flags: []cli.Flag{
-		internal.NoInputFlag,
-		internal.ForceFlag,
+	Example: `  # delete volumes interactively
+  abra app volume rm 1312.net
+
+  # delete specific volume
+  abra app volume rm 1312.net my_volume`,
+	Aliases: []string{"rm"},
+	Args:    cobra.MinimumNArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.AppNameComplete,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		app := internal.ValidateApp(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		var volumeToDelete string
+		if len(args) == 2 {
+			volumeToDelete = args[1]
+		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
@@ -117,6 +130,30 @@ Passing "--force/-f" will select all volumes for removal. Be careful.`,
 		}
 		volumeNames := client.GetVolumeNames(volumeList)
 
+		if volumeToDelete != "" {
+			var exactMatch bool
+
+			fullVolumeToDeleteName := fmt.Sprintf("%s_%s", app.StackName(), volumeToDelete)
+			for _, volName := range volumeNames {
+				if volName == fullVolumeToDeleteName {
+					exactMatch = true
+				}
+			}
+
+			if !exactMatch {
+				log.Fatalf("unable to remove volume: no volume with name '%s'?", volumeToDelete)
+			}
+
+			err := client.RemoveVolumes(cl, context.Background(), []string{fullVolumeToDeleteName}, internal.Force, 5)
+			if err != nil {
+				log.Fatalf("removing volume %s failed: %s", volumeToDelete, err)
+			}
+
+			log.Infof("volume %s removed successfully", volumeToDelete)
+
+			return
+		}
+
 		var volumesToRemove []string
 		if !internal.Force && !internal.NoInput {
 			volumesPrompt := &survey.MultiSelect{
@@ -145,18 +182,21 @@ Passing "--force/-f" will select all volumes for removal. Be careful.`,
 		} else {
 			log.Info("no volumes removed")
 		}
-
-		return nil
 	},
 }
 
-var appVolumeCommand = cli.Command{
-	Name:      "volume",
-	Aliases:   []string{"vl"},
-	Usage:     "Manage app volumes",
-	UsageText: "abra app volume [command] [options] [arguments]",
-	Commands: []*cli.Command{
-		&appVolumeListCommand,
-		&appVolumeRemoveCommand,
-	},
+var AppVolumeCommand = &cobra.Command{
+	Use:     "volume [cmd] [args] [flags]",
+	Aliases: []string{"vl"},
+	Short:   "Manage app volumes",
+}
+
+func init() {
+	AppVolumeRemoveCommand.Flags().BoolVarP(
+		&internal.Force,
+		"force",
+		"f",
+		false,
+		"perform action without further prompt",
+	)
 }

cli/catalogue/catalogue.go

@@ -1,11 +1,11 @@
 package catalogue
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"path"
+	"slices"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
@@ -16,41 +16,50 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/go-git/go-git/v5"
-	"github.com/urfave/cli/v3"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
 )
 
-var catalogueGenerateCommand = cli.Command{
-	Name:      "generate",
-	Aliases:   []string{"g"},
-	Usage:     "Generate the recipe catalogue",
-	UsageText: "abra catalogue generate [<recipe>] [options]",
-	Flags: []cli.Flag{
-		internal.PublishFlag,
-		internal.DryFlag,
-		internal.SkipUpdatesFlag,
-		internal.ChaosFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `Generate a new copy of the recipe catalogue.
+var CatalogueGenerateCommand = &cobra.Command{
+	Use:     gotext.Get("generate [recipe] [flags]"),
+	Aliases: []string{"g"},
+	Short:   gotext.Get("Generate the recipe catalogue"),
+	Long: gotext.Get(`Generate a new copy of the recipe catalogue.
+
+N.B. this command **will** wipe local unstaged changes from your local recipes
+if present. "--chaos/-C" on this command refers to the catalogue repository
+("$ABRA_DIR/catalogue") and not the recipes. Please take care not to lose your
+changes.
 
 It is possible to generate new metadata for a single recipe by passing
-<recipe>. The existing local catalogue will be updated, not overwritten.
+[recipe]. The existing local catalogue will be updated, not overwritten.
 
 It is quite easy to get rate limited by Docker Hub when running this command.
-If you have a Hub account you can have Abra log you in to avoid this. Pass
-"--user" and "--pass".
+If you have a Hub account you can "docker login" and Abra will automatically
+use those details.
 
-Push your new release to git.coopcloud.tech with "-p/--publish". This requires
+Push your new release to git.coopcloud.tech with "--publish/-p". This requires
 that you have permission to git push to these repositories and have your SSH
-keys configured on your account.`,
-	ShellComplete: autocomplete.RecipeNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		recipeName := cmd.Args().First()
-		r := recipe.Get(recipeName)
+keys configured on your account.`),
+	Args: cobra.RangeArgs(0, 1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		var recipeName string
+		if len(args) > 0 {
+			recipeName = args[0]
+		}
 
 		if recipeName != "" {
-			internal.ValidateRecipe(cmd)
+			internal.ValidateRecipe(args, cmd.Name())
+		}
+
+		if err := catalogue.EnsureCatalogue(); err != nil {
+			log.Fatal(err)
 		}
 
 		if !internal.Chaos {
@@ -59,44 +68,48 @@ keys configured on your account.`,
 			}
 		}
 
-		repos, err := recipe.ReadReposMetadata()
+		repos, err := recipe.ReadReposMetadata(internal.Debug)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		var barLength int
-		var logMsg string
+		barLength := len(repos)
 		if recipeName != "" {
 			barLength = 1
-			logMsg = fmt.Sprintf("ensuring %v recipe is cloned & up-to-date", barLength)
-		} else {
-			barLength = len(repos)
-			logMsg = fmt.Sprintf("ensuring %v recipes are cloned & up-to-date, this could take some time...", barLength)
 		}
 
-		if !internal.SkipUpdates {
-			log.Warn(logMsg)
-			if err := recipe.UpdateRepositories(repos, recipeName); err != nil {
+		if !skipUpdates {
+			if err := recipe.UpdateRepositories(repos, recipeName, internal.Debug); err != nil {
 				log.Fatal(err)
 			}
 		}
 
+		var warnings []string
 		catl := make(recipe.RecipeCatalogue)
-		catlBar := formatter.CreateProgressbar(barLength, "generating catalogue metadata...")
+		catlBar := formatter.CreateProgressbar(barLength, gotext.Get("collecting catalogue metadata"))
 		for _, recipeMeta := range repos {
 			if recipeName != "" && recipeName != recipeMeta.Name {
-				catlBar.Add(1)
+				if !internal.Debug {
+					catlBar.Add(1)
+				}
 				continue
 			}
 
-			versions, err := r.GetRecipeVersions()
+			r := recipe.Get(recipeMeta.Name)
+			versions, warnMsgs, err := r.GetRecipeVersions()
 			if err != nil {
-				log.Warn(err)
+				warnings = append(warnings, err.Error())
+			}
+			if len(warnMsgs) > 0 {
+				warnings = append(warnings, warnMsgs...)
 			}
 
-			features, category, err := recipe.GetRecipeFeaturesAndCategory(r)
+			features, category, warnMsgs, err := recipe.GetRecipeFeaturesAndCategory(r)
 			if err != nil {
-				log.Warn(err)
+				warnings = append(warnings, err.Error())
+			}
+			if len(warnMsgs) > 0 {
+				warnings = append(warnings, warnMsgs...)
 			}
 
 			catl[recipeMeta.Name] = recipe.RecipeMeta{
@@ -112,7 +125,24 @@ keys configured on your account.`,
 				Features:      features,
 			}
 
-			catlBar.Add(1)
+			if !internal.Debug {
+				catlBar.Add(1)
+			}
+		}
+
+		if err := catlBar.Close(); err != nil {
+			log.Fatal(err)
+		}
+
+		var uniqueWarnings []string
+		for _, w := range warnings {
+			if !slices.Contains(uniqueWarnings, w) {
+				uniqueWarnings = append(uniqueWarnings, w)
+			}
+		}
+
+		for _, warnMsg := range uniqueWarnings {
+			log.Warn(warnMsg)
 		}
 
 		recipesJSON, err := json.MarshalIndent(catl, "", "    ")
@@ -142,10 +172,10 @@ keys configured on your account.`,
 			}
 		}
 
-		log.Infof("generated new recipe catalogue in %s", config.RECIPES_JSON)
+		log.Info(gotext.Get("generated recipe catalogue: %s", config.RECIPES_JSON))
 
 		cataloguePath := path.Join(config.ABRA_DIR, "catalogue")
-		if internal.Publish {
+		if publishChanges {
 
 			isClean, err := gitPkg.IsClean(cataloguePath)
 			if err != nil {
@@ -154,11 +184,11 @@ keys configured on your account.`,
 
 			if isClean {
 				if !internal.Dry {
-					log.Fatalf("no changes discovered in %s, nothing to publish?", cataloguePath)
+					log.Fatal(gotext.Get("no changes discovered in %s, nothing to publish?", cataloguePath))
 				}
 			}
 
-			msg := "chore: publish new catalogue release changes"
+			msg := gotext.Get("chore: publish new catalogue release changes")
 			if err := gitPkg.Commit(cataloguePath, msg, internal.Dry); err != nil {
 				log.Fatal(err)
 			}
@@ -168,7 +198,7 @@ keys configured on your account.`,
 				log.Fatal(err)
 			}
 
-			sshURL := fmt.Sprintf(config.SSH_URL_TEMPLATE, config.CATALOGUE_JSON_REPO_NAME)
+			sshURL := fmt.Sprintf(config.TOOLSHED_SSH_URL_TEMPLATE, config.CATALOGUE_JSON_REPO_NAME)
 			if err := gitPkg.CreateRemote(repo, "origin-ssh", sshURL, internal.Dry); err != nil {
 				log.Fatal(err)
 			}
@@ -188,26 +218,59 @@ keys configured on your account.`,
 			log.Fatal(err)
 		}
 
-		if !internal.Dry && internal.Publish {
+		if !internal.Dry && publishChanges {
 			url := fmt.Sprintf("%s/%s/commit/%s", config.REPOS_BASE_URL, config.CATALOGUE_JSON_REPO_NAME, head.Hash())
-			log.Infof("new changes published: %s", url)
+			log.Info(gotext.Get("new changes published: %s", url))
 		}
 
 		if internal.Dry {
-			log.Info("dry run: no changes published")
+			log.Info(gotext.Get("dry run: no changes published"))
 		}
-
-		return nil
 	},
 }
 
 // CatalogueCommand defines the `abra catalogue` command and sub-commands.
-var CatalogueCommand = cli.Command{
-	Name:      "catalogue",
-	Usage:     "Manage the recipe catalogue",
-	Aliases:   []string{"c"},
-	UsageText: "abra catalogue [command] [options] [arguments]",
-	Commands: []*cli.Command{
-		&catalogueGenerateCommand,
-	},
+var CatalogueCommand = &cobra.Command{
+	Use:     gotext.Get("catalogue [cmd] [args] [flags]"),
+	Short:   gotext.Get("Manage the recipe catalogue"),
+	Aliases: []string{"c"},
+}
+
+var (
+	publishChanges bool
+	skipUpdates    bool
+)
+
+func init() {
+	CatalogueGenerateCommand.Flags().BoolVarP(
+		&publishChanges,
+		"publish",
+		"p",
+		false,
+		gotext.Get("publish changes to git.coopcloud.tech"),
+	)
+
+	CatalogueGenerateCommand.Flags().BoolVarP(
+		&internal.Dry,
+		"dry-run",
+		"r",
+		false,
+		gotext.Get("report changes that would be made"),
+	)
+
+	CatalogueGenerateCommand.Flags().BoolVarP(
+		&skipUpdates,
+		"skip-updates",
+		"s",
+		false,
+		gotext.Get("skip updating recipe repositories"),
+	)
+
+	CatalogueGenerateCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		gotext.Get("ignore uncommitted recipes changes"),
+	)
 }

cli/cli.go

@@ -1,206 +0,0 @@
-// Package cli provides the interface for the command-line.
-package cli
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"os/exec"
-	"path"
-
-	"coopcloud.tech/abra/cli/app"
-	"coopcloud.tech/abra/cli/catalogue"
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/cli/recipe"
-	"coopcloud.tech/abra/cli/server"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/log"
-	"coopcloud.tech/abra/pkg/web"
-	charmLog "github.com/charmbracelet/log"
-	"github.com/urfave/cli/v3"
-)
-
-// AutoCompleteCommand helps people set up auto-complete in their shells
-var AutoCompleteCommand = cli.Command{
-	Name:      "autocomplete",
-	Aliases:   []string{"ac"},
-	Usage:     "Configure shell autocompletion",
-	UsageText: "abra autocomplete <shell> [options]",
-	Description: `Set up shell auto-completion.
-
-Supported shells are: bash, fish, fizsh & zsh.`,
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		shellType := cmd.Args().First()
-
-		if shellType == "" {
-			internal.ShowSubcommandHelpAndError(cmd, errors.New("no shell provided"))
-		}
-
-		supportedShells := map[string]bool{
-			"bash":  true,
-			"zsh":   true,
-			"fizsh": true,
-			"fish":  true,
-		}
-
-		if _, ok := supportedShells[shellType]; !ok {
-			log.Fatalf("%s is not a supported shell right now, sorry", shellType)
-		}
-
-		if shellType == "fizsh" {
-			shellType = "zsh" // handled the same on the autocompletion side
-		}
-
-		autocompletionDir := path.Join(config.ABRA_DIR, "autocompletion")
-		if err := os.Mkdir(autocompletionDir, 0764); err != nil {
-			if !os.IsExist(err) {
-				log.Fatal(err)
-			}
-			log.Debugf("%s already created", autocompletionDir)
-		}
-
-		autocompletionFile := path.Join(config.ABRA_DIR, "autocompletion", shellType)
-		if _, err := os.Stat(autocompletionFile); err != nil && os.IsNotExist(err) {
-			url := fmt.Sprintf("https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/autocomplete/%s", shellType)
-			log.Infof("fetching %s", url)
-			if err := web.GetFile(autocompletionFile, url); err != nil {
-				log.Fatal(err)
-			}
-		}
-
-		switch shellType {
-		case "bash":
-			fmt.Println(fmt.Sprintf(`
-# run the following commands once to install auto-completion
-sudo mkdir -p /etc/bash_completion.d/
-sudo cp %s /etc/bash_completion.d/abra
-echo "source /etc/bash_completion.d/abra" >> ~/.bashrc
-source /etc/bash_completion.d/abra
-# To test, run the following: "abra app <hit tab key>" - you should see command completion!
-`, autocompletionFile))
-		case "zsh":
-			fmt.Println(fmt.Sprintf(`
-# run the following commands to once install auto-completion
-sudo mkdir -p /etc/zsh/completion.d/
-sudo cp %s /etc/zsh/completion.d/abra
-echo "PROG=abra\n_CLI_ZSH_AUTOCOMPLETE_HACK=1\nsource /etc/zsh/completion.d/abra" >> ~/.zshrc
-source /etc/zsh/completion.d/abra
-# to test, run the following: "abra app <hit tab key>" - you should see command completion!
-`, autocompletionFile))
-		case "fish":
-			fmt.Println(fmt.Sprintf(`
-# run the following commands once to install auto-completion
-sudo mkdir -p /etc/fish/completions
-sudo cp %s /etc/fish/completions/abra
-echo "source /etc/fish/completions/abra" >> ~/.config/fish/config.fish
-source /etc/fish/completions/abra
-# to test, run the following: "abra app <hit tab key>" - you should see command completion!
-`, autocompletionFile))
-		}
-
-		return nil
-	},
-}
-
-// UpgradeCommand upgrades abra in-place.
-var UpgradeCommand = cli.Command{
-	Name:      "upgrade",
-	Aliases:   []string{"u"},
-	Usage:     "Upgrade abra",
-	UsageText: "abra upgrade [options]",
-	Description: `Upgrade abra in-place with the latest stable or release candidate.
-
-Use "--rc/-r" to install the latest release candidate. Please bear in mind that
-it may contain absolutely catastrophic deal-breaker bugs. Thank you very much
-for the testing efforts 💗`,
-	Flags:    []cli.Flag{internal.RCFlag},
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		mainURL := "https://install.abra.coopcloud.tech"
-		c := exec.Command("bash", "-c", fmt.Sprintf("wget -q -O- %s | bash", mainURL))
-
-		if internal.RC {
-			releaseCandidateURL := "https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/installer/installer"
-			c = exec.Command("bash", "-c", fmt.Sprintf("wget -q -O- %s | bash -s -- --rc", releaseCandidateURL))
-		}
-
-		log.Debugf("attempting to run %s", c)
-
-		if err := internal.RunCmd(c); err != nil {
-			log.Fatal(err)
-		}
-
-		return nil
-	},
-}
-
-func newAbraApp(version, commit string) *cli.Command {
-	app := &cli.Command{
-		Name:      "abra",
-		Usage:     "The Co-op Cloud command-line utility belt 🎩🐇",
-		UsageText: "abra [command] [arguments] [options]",
-		Version:   fmt.Sprintf("%s-%s", version, commit[:7]),
-		Flags: []cli.Flag{
-			// NOTE(d1): "GLOBAL OPTIONS" flags
-			internal.DebugFlag,
-		},
-		Commands: []*cli.Command{
-			&app.AppCommand,
-			&server.ServerCommand,
-			&recipe.RecipeCommand,
-			&catalogue.CatalogueCommand,
-			&UpgradeCommand,
-			&AutoCompleteCommand,
-		},
-		EnableShellCompletion:  true,
-		UseShortOptionHandling: true,
-		HideHelpCommand:        true,
-		ShellComplete:          autocomplete.SubcommandComplete,
-	}
-
-	app.Before = func(ctx context.Context, cmd *cli.Command) error {
-		paths := []string{
-			config.ABRA_DIR,
-			config.SERVERS_DIR,
-			config.RECIPES_DIR,
-			config.VENDOR_DIR,
-			config.BACKUP_DIR,
-		}
-
-		for _, path := range paths {
-			if err := os.Mkdir(path, 0764); err != nil {
-				if !os.IsExist(err) {
-					log.Fatal(err)
-				}
-				continue
-			}
-		}
-
-		log.Logger.SetStyles(log.Styles())
-		charmLog.SetDefault(log.Logger)
-
-		log.Debugf("abra version %s, commit %s", version, commit)
-
-		return nil
-	}
-
-	cli.HelpFlag = &cli.BoolFlag{
-		Name:    "help",
-		Aliases: []string{"h, H"},
-		Usage:   "Show help",
-	}
-
-	return app
-}
-
-// RunApp runs CLI abra app.
-func RunApp(version, commit string) {
-	app := newAbraApp(version, commit)
-
-	if err := app.Run(context.Background(), os.Args); err != nil {
-		log.Fatal(err)
-	}
-}

cli/complete.go

@@ -0,0 +1,63 @@
+package cli
+
+import (
+	"os"
+
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
+)
+
+var AutocompleteCommand = &cobra.Command{
+	Use:   gotext.Get("autocomplete [bash|zsh|fish|powershell]"),
+	Short: gotext.Get("Generate autocompletion script"),
+	Long: gotext.Get(`To load completions:
+
+Bash:
+  # Load autocompletion for the current Bash session
+  $ source <(abra autocomplete bash)
+
+  # To load autocompletion for each session, execute once:
+  # Linux:
+  $ abra autocomplete bash | sudo tee /etc/bash_completion.d/abra
+  # macOS:
+  $ abra autocomplete bash | sudo tee $(brew --prefix)/etc/bash_completion.d/abra
+
+Zsh:
+  # If shell autocompletion is not already enabled in your environment,
+  # you will need to enable it.  You can execute the following once:
+
+  $ echo "autoload -U compinit; compinit" >> ~/.zshrc
+
+  # To load autocompletions for each session, execute once:
+  $ abra autocomplete zsh > "${fpath[1]}/_abra"
+
+  # You will need to start a new shell for this setup to take effect.
+
+fish:
+  $ abra autocomplete fish | source
+
+  # To load autocompletions for each session, execute once:
+  $ abra autocomplete fish > ~/.config/fish/completions/abra.fish
+
+PowerShell:
+  PS> abra autocomplete powershell | Out-String | Invoke-Expression
+
+  # To load autocompletions for every new session, run:
+  PS> abra autocomplete powershell > abra.ps1
+  # and source this file from your PowerShell profile.`),
+	DisableFlagsInUseLine: true,
+	ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
+	Args:                  cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
+	Run: func(cmd *cobra.Command, args []string) {
+		switch args[0] {
+		case "bash":
+			cmd.Root().GenBashCompletion(os.Stdout)
+		case "zsh":
+			cmd.Root().GenZshCompletion(os.Stdout)
+		case "fish":
+			cmd.Root().GenFishCompletion(os.Stdout, true)
+		case "powershell":
+			cmd.Root().GenPowerShellCompletionWithDesc(os.Stdout)
+		}
+	},
+}

cli/internal/backup.go

@@ -2,6 +2,8 @@ package internal
 
 import (
 	"context"
+	"fmt"
+	"io"
 
 	"coopcloud.tech/abra/pkg/config"
 	containerPkg "coopcloud.tech/abra/pkg/container"
@@ -10,6 +12,7 @@ import (
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
+	containertypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
 )
@@ -19,7 +22,7 @@ func RetrieveBackupBotContainer(cl *dockerClient.Client) (types.Container, error
 	ctx := context.Background()
 	chosenService, err := service.GetServiceByLabel(ctx, cl, config.BackupbotLabel, NoInput)
 	if err != nil {
-		return types.Container{}, err
+		return types.Container{}, fmt.Errorf("no backupbot discovered, is it deployed?")
 	}
 
 	log.Debugf("retrieved %s as backup enabled service", chosenService.Spec.Name)
@@ -40,8 +43,12 @@ func RetrieveBackupBotContainer(cl *dockerClient.Client) (types.Container, error
 }
 
 // RunBackupCmdRemote runs a backup related command on a remote backupbot container.
-func RunBackupCmdRemote(cl *dockerClient.Client, backupCmd string, containerID string, execEnv []string) error {
-	execBackupListOpts := types.ExecConfig{
+func RunBackupCmdRemote(
+	cl *dockerClient.Client,
+	backupCmd string,
+	containerID string,
+	execEnv []string) (io.Writer, error) {
+	execBackupListOpts := containertypes.ExecOptions{
 		AttachStderr: true,
 		AttachStdin:  true,
 		AttachStdout: true,
@@ -56,12 +63,13 @@ func RunBackupCmdRemote(cl *dockerClient.Client, backupCmd string, containerID s
 	// FIXME: avoid instantiating a new CLI
 	dcli, err := command.NewDockerCli()
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	if _, err := container.RunExec(dcli, cl, containerID, &execBackupListOpts); err != nil {
-		return err
+	out, err := container.RunExec(dcli, cl, containerID, &execBackupListOpts)
+	if err != nil {
+		return nil, err
 	}
 
-	return nil
+	return out, nil
 }

cli/internal/cli.go

@@ -1,331 +1,20 @@
 package internal
 
-import (
-	"context"
-	"os"
+var (
+	// NOTE(d1): global
+	Debug            bool
+	NoInput          bool
+	Offline          bool
+	IgnoreEnvVersion bool
 
-	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v3"
+	// NOTE(d1): sub-command specific
+	Chaos            bool
+	DontWaitConverge bool
+	Dry              bool
+	Force            bool
+	MachineReadable  bool
+	Major            bool
+	Minor            bool
+	NoDomainChecks   bool
+	Patch            bool
 )
-
-// Secrets stores the variable from SecretsFlag
-var Secrets bool
-
-// SecretsFlag turns on/off automatically generating secrets
-var SecretsFlag = &cli.BoolFlag{
-	Name:        "secrets",
-	Aliases:     []string{"S"},
-	Usage:       "Automatically generate secrets",
-	Destination: &Secrets,
-}
-
-// Pass stores the variable from PassFlag
-var Pass bool
-
-// PassFlag turns on/off storing generated secrets in pass
-var PassFlag = &cli.BoolFlag{
-	Name:        "pass",
-	Aliases:     []string{"p"},
-	Usage:       "Store the generated secrets in a local pass store",
-	Destination: &Pass,
-}
-
-// PassRemove stores the variable for PassRemoveFlag
-var PassRemove bool
-
-// PassRemoveFlag turns on/off removing generated secrets from pass
-var PassRemoveFlag = &cli.BoolFlag{
-	Name:        "pass",
-	Aliases:     []string{"p"},
-	Usage:       "Remove generated secrets from a local pass store",
-	Destination: &PassRemove,
-}
-
-var File bool
-var FileFlag = &cli.BoolFlag{
-	Name:        "file",
-	Aliases:     []string{"f"},
-	Usage:       "Treat input as a file",
-	Destination: &File,
-}
-
-var Trim bool
-var TrimFlag = &cli.BoolFlag{
-	Name:        "trim",
-	Aliases:     []string{"t"},
-	Usage:       "Trim input",
-	Destination: &Trim,
-}
-
-// Force force functionality without asking.
-var Force bool
-
-// ForceFlag turns on/off force functionality.
-var ForceFlag = &cli.BoolFlag{
-	Name:        "force",
-	Aliases:     []string{"f"},
-	Usage:       "Perform action without further prompt. Use with care!",
-	Destination: &Force,
-}
-
-// Chaos engages chaos mode.
-var Chaos bool
-
-// ChaosFlag turns on/off chaos functionality.
-var ChaosFlag = &cli.BoolFlag{
-	Name:        "chaos",
-	Aliases:     []string{"C"},
-	Usage:       "Ignore uncommitted recipes changes. Use with care!",
-	Destination: &Chaos,
-}
-
-// Disable tty to run commands from script
-var Tty bool
-
-// TtyFlag turns on/off tty mode.
-var TtyFlag = &cli.BoolFlag{
-	Name:        "tty",
-	Aliases:     []string{"T"},
-	Usage:       "Disables TTY mode to run this command from a script.",
-	Destination: &Tty,
-}
-
-var NoInput bool
-var NoInputFlag = &cli.BoolFlag{
-	Name:        "no-input",
-	Aliases:     []string{"n"},
-	Usage:       "Toggle non-interactive mode",
-	Destination: &NoInput,
-}
-
-// Debug stores the variable from DebugFlag.
-var Debug bool
-
-// DebugFlag turns on/off verbose logging down to the DEBUG level.
-var DebugFlag = &cli.BoolFlag{
-	Name:        "debug",
-	Aliases:     []string{"d"},
-	Destination: &Debug,
-	Usage:       "Show DEBUG messages",
-}
-
-// Offline stores the variable from OfflineFlag.
-var Offline bool
-
-// DebugFlag turns on/off offline mode.
-var OfflineFlag = &cli.BoolFlag{
-	Name:        "offline",
-	Aliases:     []string{"o"},
-	Destination: &Offline,
-	Usage:       "Prefer offline & filesystem access",
-}
-
-// ReleaseNotes stores the variable from ReleaseNotesFlag.
-var ReleaseNotes bool
-
-// ReleaseNotesFlag turns on/off printing only release notes when upgrading.
-var ReleaseNotesFlag = &cli.BoolFlag{
-	Name:        "releasenotes",
-	Aliases:     []string{"r"},
-	Destination: &ReleaseNotes,
-	Usage:       "Only show release notes",
-}
-
-// MachineReadable stores the variable from MachineReadableFlag
-var MachineReadable bool
-
-// MachineReadableFlag turns on/off machine readable output where supported
-var MachineReadableFlag = &cli.BoolFlag{
-	Name:        "machine",
-	Aliases:     []string{"m"},
-	Destination: &MachineReadable,
-	Usage:       "Machine-readable output",
-}
-
-// RC signifies the latest release candidate
-var RC bool
-
-// RCFlag chooses the latest release candidate for install
-var RCFlag = &cli.BoolFlag{
-	Name:        "rc",
-	Aliases:     []string{"r"},
-	Destination: &RC,
-	Usage:       "Install the latest release candidate",
-}
-
-var Major bool
-var MajorFlag = &cli.BoolFlag{
-	Name:        "major",
-	Aliases:     []string{"x"},
-	Usage:       "Increase the major part of the version",
-	Destination: &Major,
-}
-
-var Minor bool
-var MinorFlag = &cli.BoolFlag{
-	Name:        "minor",
-	Aliases:     []string{"y"},
-	Usage:       "Increase the minor part of the version",
-	Destination: &Minor,
-}
-
-var Patch bool
-var PatchFlag = &cli.BoolFlag{
-	Name:        "patch",
-	Aliases:     []string{"z"},
-	Usage:       "Increase the patch part of the version",
-	Destination: &Patch,
-}
-
-var Dry bool
-var DryFlag = &cli.BoolFlag{
-	Name:        "dry-run",
-	Aliases:     []string{"r"},
-	Usage:       "Only reports changes that would be made",
-	Destination: &Dry,
-}
-
-var Publish bool
-var PublishFlag = &cli.BoolFlag{
-	Name:        "publish",
-	Aliases:     []string{"p"},
-	Usage:       "Publish changes to git.coopcloud.tech",
-	Destination: &Publish,
-}
-
-var Domain string
-var DomainFlag = &cli.StringFlag{
-	Name:        "domain",
-	Aliases:     []string{"D"},
-	Value:       "",
-	Usage:       "Choose a domain name",
-	Destination: &Domain,
-}
-
-var NewAppServer string
-var NewAppServerFlag = &cli.StringFlag{
-	Name:        "server",
-	Aliases:     []string{"s"},
-	Value:       "",
-	Usage:       "Show apps of a specific server",
-	Destination: &NewAppServer,
-}
-
-var NoDomainChecks bool
-var NoDomainChecksFlag = &cli.BoolFlag{
-	Name:        "no-domain-checks",
-	Aliases:     []string{"D"},
-	Usage:       "Disable public DNS checks",
-	Destination: &NoDomainChecks,
-}
-
-var StdErrOnly bool
-var StdErrOnlyFlag = &cli.BoolFlag{
-	Name:        "stderr",
-	Aliases:     []string{"s"},
-	Usage:       "Only tail stderr",
-	Destination: &StdErrOnly,
-}
-
-var SinceLogs string
-var SinceLogsFlag = &cli.StringFlag{
-	Name:        "since",
-	Aliases:     []string{"S"},
-	Value:       "",
-	Usage:       "tail logs since YYYY-MM-DDTHH:MM:SSZ",
-	Destination: &SinceLogs,
-}
-
-var DontWaitConverge bool
-var DontWaitConvergeFlag = &cli.BoolFlag{
-	Name:        "no-converge-checks",
-	Aliases:     []string{"c"},
-	Usage:       "Don't wait for converge logic checks",
-	Destination: &DontWaitConverge,
-}
-
-var Watch bool
-var WatchFlag = &cli.BoolFlag{
-	Name:        "watch",
-	Aliases:     []string{"w"},
-	Usage:       "Watch status by polling repeatedly",
-	Destination: &Watch,
-}
-
-var OnlyErrors bool
-var OnlyErrorFlag = &cli.BoolFlag{
-	Name:        "errors",
-	Aliases:     []string{"e"},
-	Usage:       "Only show errors",
-	Destination: &OnlyErrors,
-}
-
-var SkipUpdates bool
-var SkipUpdatesFlag = &cli.BoolFlag{
-	Name:        "skip-updates",
-	Aliases:     []string{"s"},
-	Usage:       "Skip updating recipe repositories",
-	Destination: &SkipUpdates,
-}
-
-var AllTags bool
-var AllTagsFlag = &cli.BoolFlag{
-	Name:        "all-tags",
-	Aliases:     []string{"a"},
-	Usage:       "List all tags, not just upgrades",
-	Destination: &AllTags,
-}
-
-var LocalCmd bool
-var LocalCmdFlag = &cli.BoolFlag{
-	Name:        "local",
-	Aliases:     []string{"l"},
-	Usage:       "Run command locally",
-	Destination: &LocalCmd,
-}
-
-var RemoteUser string
-var RemoteUserFlag = &cli.StringFlag{
-	Name:        "user",
-	Aliases:     []string{"u"},
-	Value:       "",
-	Usage:       "User to run command within a service context",
-	Destination: &RemoteUser,
-}
-
-var GitName string
-var GitNameFlag = &cli.StringFlag{
-	Name:        "git-name",
-	Aliases:     []string{"gn"},
-	Value:       "",
-	Usage:       "Git (user) name to do commits with",
-	Destination: &GitName,
-}
-
-var GitEmail string
-var GitEmailFlag = &cli.StringFlag{
-	Name:        "git-email",
-	Aliases:     []string{"ge"},
-	Value:       "",
-	Usage:       "Git email name to do commits with",
-	Destination: &GitEmail,
-}
-
-var AllServices bool
-var AllServicesFlag = &cli.BoolFlag{
-	Name:        "all-services",
-	Aliases:     []string{"a"},
-	Usage:       "Restart all services",
-	Destination: &AllServices,
-}
-
-// SubCommandBefore wires up pre-action machinery (e.g. --debug handling).
-func SubCommandBefore(ctx context.Context, cmd *cli.Command) error {
-	if Debug {
-		log.SetLevel(log.DebugLevel)
-		log.SetOutput(os.Stderr)
-		log.SetReportCaller(true)
-	}
-
-	return nil
-}

cli/internal/command.go

@@ -14,14 +14,18 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/docker/api/types"
+	containertypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/docker/docker/pkg/archive"
 )
 
 // RunCmdRemote executes an abra.sh command in the target service
-func RunCmdRemote(cl *dockerClient.Client, app appPkg.App, abraSh, serviceName, cmdName, cmdArgs string) error {
+func RunCmdRemote(
+	cl *dockerClient.Client,
+	app appPkg.App,
+	disableTTY bool,
+	abraSh, serviceName, cmdName, cmdArgs, remoteUser string) error {
 	filters := filters.NewArgs()
 	filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), serviceName))
 
@@ -38,7 +42,7 @@ func RunCmdRemote(cl *dockerClient.Client, app appPkg.App, abraSh, serviceName,
 		return err
 	}
 
-	copyOpts := types.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
+	copyOpts := containertypes.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
 	if err := cl.CopyToContainer(context.Background(), targetContainer.ID, "/tmp", content, copyOpts); err != nil {
 		return err
 	}
@@ -51,7 +55,7 @@ func RunCmdRemote(cl *dockerClient.Client, app appPkg.App, abraSh, serviceName,
 
 	shell := "/bin/bash"
 	findShell := []string{"test", "-e", shell}
-	execCreateOpts := types.ExecConfig{
+	execCreateOpts := containertypes.ExecOptions{
 		AttachStderr: true,
 		AttachStdin:  true,
 		AttachStdout: true,
@@ -74,15 +78,17 @@ func RunCmdRemote(cl *dockerClient.Client, app appPkg.App, abraSh, serviceName,
 
 	log.Debugf("running command: %s", strings.Join(cmd, " "))
 
-	if RemoteUser != "" {
-		log.Debugf("running command with user %s", RemoteUser)
-		execCreateOpts.User = RemoteUser
+	if remoteUser != "" {
+		log.Debugf("running command with user %s", remoteUser)
+		execCreateOpts.User = remoteUser
 	}
 
 	execCreateOpts.Cmd = cmd
+
 	execCreateOpts.Tty = true
-	if Tty {
+	if disableTTY {
 		execCreateOpts.Tty = false
+		log.Debugf("not requesting a remote TTY")
 	}
 
 	if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {

cli/internal/deploy.go

@@ -3,10 +3,14 @@ package internal
 import (
 	"fmt"
 	"os"
+	"sort"
 	"strings"
 
 	appPkg "coopcloud.tech/abra/pkg/app"
+	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/charmbracelet/lipgloss"
 	dockerClient "github.com/docker/docker/client"
@@ -20,7 +24,8 @@ var borderStyle = lipgloss.NewStyle().
 
 var headerStyle = lipgloss.NewStyle().
 	Underline(true).
-	Bold(true)
+	Bold(true).
+	PaddingBottom(1)
 
 var leftStyle = lipgloss.NewStyle().
 	Bold(true)
@@ -32,18 +37,21 @@ func horizontal(left, mid, right string) string {
 	return lipgloss.JoinHorizontal(lipgloss.Left, left, mid, right)
 }
 
-// NewVersionOverview shows an upgrade or downgrade overview
-func NewVersionOverview(
+func formatComposeFiles(composeFiles string) string {
+	return strings.ReplaceAll(composeFiles, ":", "\n")
+}
+
+// DeployOverview shows a deployment overview
+func DeployOverview(
 	app appPkg.App,
+	deployedVersion string,
+	toDeployVersion string,
+	releaseNotes string,
 	warnMessages []string,
-	kind,
-	currentVersion,
-	chaosVersion,
-	newVersion,
-	releaseNotes string) error {
+) error {
 	deployConfig := "compose.yml"
 	if composeFiles, ok := app.Env["COMPOSE_FILE"]; ok {
-		deployConfig = strings.Join(strings.Split(composeFiles, ":"), "\n")
+		deployConfig = formatComposeFiles(composeFiles)
 	}
 
 	server := app.Server
@@ -51,32 +59,34 @@ func NewVersionOverview(
 		server = "local"
 	}
 
-	body := strings.Builder{}
-	body.WriteString(
-		borderStyle.Render(
-			lipgloss.JoinVertical(
-				lipgloss.Center,
-				headerStyle.Render(fmt.Sprintf("%s OVERVIEW", strings.ToUpper(kind))),
-				lipgloss.JoinVertical(
-					lipgloss.Left,
-					horizontal(leftStyle.Render("SERVER"), "   ", rightStyle.Render(server)),
-					horizontal(leftStyle.Render("DOMAIN"), "   ", rightStyle.Render(app.Domain)),
-					horizontal(leftStyle.Render("RECIPE"), "   ", rightStyle.Render(app.Recipe.Name)),
-					horizontal(leftStyle.Render("CONFIG"), "   ", rightStyle.Render(deployConfig)),
-					horizontal(leftStyle.Render("VERSION"), "  ", rightStyle.Render(currentVersion)),
-					horizontal(leftStyle.Render("CHAOS"), "    ", rightStyle.Render(chaosVersion)),
-					horizontal(leftStyle.Render("DEPLOY"), "   ", rightStyle.Padding(0).Render(newVersion)),
-				),
-			),
-		),
-	)
-	fmt.Println(body.String())
+	domain := app.Domain
+	if domain == "" {
+		domain = config.NO_DOMAIN_DEFAULT
+	}
 
-	if releaseNotes != "" && newVersion != "" {
-		fmt.Println()
+	envVersion := app.Recipe.EnvVersionRaw
+	if envVersion == "" {
+		envVersion = config.NO_VERSION_DEFAULT
+	}
+
+	rows := [][]string{
+		{"DOMAIN", domain},
+		{"RECIPE", app.Recipe.Name},
+		{"SERVER", server},
+		{"CONFIG", deployConfig},
+		{"", ""},
+		{"CURRENT DEPLOYMENT", formatter.BoldDirtyDefault(deployedVersion)},
+		{"ENV VERSION", formatter.BoldDirtyDefault(envVersion)},
+		{"NEW DEPLOYMENT", formatter.BoldDirtyDefault(toDeployVersion)},
+	}
+
+	deployType := getDeployType(deployedVersion, toDeployVersion)
+	overview := formatter.CreateOverview(fmt.Sprintf("%s OVERVIEW", deployType), rows)
+
+	fmt.Println(overview)
+
+	if releaseNotes != "" {
 		fmt.Print(releaseNotes)
-	} else {
-		warnMessages = append(warnMessages, fmt.Sprintf("no release notes available for %s", newVersion))
 	}
 
 	for _, msg := range warnMessages {
@@ -100,57 +110,34 @@ func NewVersionOverview(
 	return nil
 }
 
-// DeployOverview shows a deployment overview
-func DeployOverview(app appPkg.App, warnMessages []string, version, chaosVersion string) error {
-	deployConfig := "compose.yml"
-	if composeFiles, ok := app.Env["COMPOSE_FILE"]; ok {
-		deployConfig = strings.Join(strings.Split(composeFiles, ":"), "\n")
+func getDeployType(currentVersion, newVersion string) string {
+	if newVersion == config.NO_DOMAIN_DEFAULT {
+		return "UNDEPLOY"
 	}
-
-	server := app.Server
-	if app.Server == "default" {
-		server = "local"
+	if strings.Contains(newVersion, "+U") {
+		return "CHAOS DEPLOY"
 	}
-
-	body := strings.Builder{}
-	body.WriteString(
-		borderStyle.Render(
-			lipgloss.JoinVertical(
-				lipgloss.Center,
-				headerStyle.Render("DEPLOY OVERVIEW"),
-				lipgloss.JoinVertical(
-					lipgloss.Left,
-					horizontal(leftStyle.Render("SERVER"), "   ", rightStyle.Render(server)),
-					horizontal(leftStyle.Render("DOMAIN"), "   ", rightStyle.Render(app.Domain)),
-					horizontal(leftStyle.Render("RECIPE"), "   ", rightStyle.Render(app.Recipe.Name)),
-					horizontal(leftStyle.Render("CONFIG"), "   ", rightStyle.Render(deployConfig)),
-					horizontal(leftStyle.Render("VERSION"), "  ", rightStyle.Render(version)),
-					horizontal(leftStyle.Render("CHAOS"), "    ", rightStyle.Padding(0).Render(chaosVersion)),
-				),
-			),
-		),
-	)
-	fmt.Println(body.String())
-
-	for _, msg := range warnMessages {
-		log.Warn(msg)
+	if strings.Contains(currentVersion, "+U") {
+		return "UNCHAOS DEPLOY"
 	}
-
-	if NoInput {
-		return nil
+	if currentVersion == newVersion {
+		return "REDEPLOY"
 	}
-
-	response := false
-	prompt := &survey.Confirm{Message: "proceed?"}
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
+	if currentVersion == config.NO_VERSION_DEFAULT {
+		return "NEW DEPLOY"
 	}
-
-	if !response {
-		log.Fatal("deployment cancelled")
+	currentParsed, err := tagcmp.Parse(currentVersion)
+	if err != nil {
+		return "DEPLOY"
 	}
-
-	return nil
+	newParsed, err := tagcmp.Parse(newVersion)
+	if err != nil {
+		return "DEPLOY"
+	}
+	if currentParsed.IsLessThan(newParsed) {
+		return "UPGRADE"
+	}
+	return "DOWNGRADE"
 }
 
 // PostCmds parses a string of commands and executes them inside of the respective services
@@ -159,7 +146,7 @@ func DeployOverview(app appPkg.App, warnMessages []string, version, chaosVersion
 func PostCmds(cl *dockerClient.Client, app appPkg.App, commands string) error {
 	if _, err := os.Stat(app.Recipe.AbraShPath); err != nil {
 		if os.IsNotExist(err) {
-			return fmt.Errorf(fmt.Sprintf("%s does not exist for %s?", app.Recipe.AbraShPath, app.Name))
+			return fmt.Errorf("%s does not exist for %s?", app.Recipe.AbraShPath, app.Name)
 		}
 		return err
 	}
@@ -167,7 +154,7 @@ func PostCmds(cl *dockerClient.Client, app appPkg.App, commands string) error {
 	for _, command := range strings.Split(commands, "|") {
 		commandParts := strings.Split(command, " ")
 		if len(commandParts) < 2 {
-			return fmt.Errorf(fmt.Sprintf("not enough arguments: %s", command))
+			return fmt.Errorf("not enough arguments: %s", command)
 		}
 		targetServiceName := commandParts[0]
 		cmdName := commandParts[1]
@@ -194,15 +181,38 @@ func PostCmds(cl *dockerClient.Client, app appPkg.App, commands string) error {
 		}
 
 		if !matchingServiceName {
-			return fmt.Errorf(fmt.Sprintf("no service %s for %s?", targetServiceName, app.Name))
+			return fmt.Errorf("no service %s for %s?", targetServiceName, app.Name)
 		}
 
 		log.Debugf("running command %s %s within the context of %s_%s", cmdName, parsedCmdArgs, app.StackName(), targetServiceName)
 
-		Tty = true
-		if err := RunCmdRemote(cl, app, app.Recipe.AbraShPath, targetServiceName, cmdName, parsedCmdArgs); err != nil {
+		requestTTY := true
+		if err := RunCmdRemote(
+			cl,
+			app,
+			requestTTY,
+			app.Recipe.AbraShPath, targetServiceName, cmdName, parsedCmdArgs, ""); err != nil {
 			return err
 		}
 	}
 	return nil
 }
+
+// SortVersionsDesc sorts versions in descending order.
+func SortVersionsDesc(versions []string) []string {
+	var tags []tagcmp.Tag
+
+	for _, v := range versions {
+		parsed, _ := tagcmp.Parse(v) // skips unsupported tags
+		tags = append(tags, parsed)
+	}
+
+	sort.Sort(tagcmp.ByTagDesc(tags))
+
+	var desc []string
+	for _, t := range tags {
+		desc = append(desc, t.String())
+	}
+
+	return desc
+}

cli/internal/deploy_test.go

@@ -0,0 +1,17 @@
+package internal
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSortVersionsDesc(t *testing.T) {
+	versions := SortVersionsDesc([]string{
+		"0.2.3+1.2.2",
+		"1.0.0+2.2.2",
+	})
+
+	assert.Equal(t, "1.0.0+2.2.2", versions[0])
+	assert.Equal(t, "0.2.3+1.2.2", versions[1])
+}

cli/internal/ensure.go

@@ -0,0 +1,11 @@
+package internal
+
+import "coopcloud.tech/abra/pkg/recipe"
+
+func GetEnsureContext() recipe.EnsureContext {
+	return recipe.EnsureContext{
+		Chaos,
+		Offline,
+		IgnoreEnvVersion,
+	}
+}

cli/internal/errors.go

@@ -1,18 +0,0 @@
-package internal
-
-import (
-	"os"
-
-	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v3"
-)
-
-// ShowSubcommandHelpAndError exits the program on error, logs the error to the
-// terminal, and shows the help command.
-func ShowSubcommandHelpAndError(cmd *cli.Command, err interface{}) {
-	if err2 := cli.ShowSubcommandHelp(cmd); err2 != nil {
-		log.Error(err2)
-	}
-	log.Error(err)
-	os.Exit(1)
-}

cli/internal/list.go

@@ -1,10 +0,0 @@
-package internal
-
-// ReverseStringList reverses a list of a strings. Roll on Go generics.
-func ReverseStringList(strings []string) []string {
-	for i, j := 0, len(strings)-1; i < j; i, j = i+1, j-1 {
-		strings[i], strings[j] = strings[j], strings[i]
-	}
-
-	return strings
-}

cli/internal/validate.go

@@ -1,7 +1,6 @@
 package internal
 
 import (
-	"errors"
 	"strings"
 
 	"coopcloud.tech/abra/pkg/app"
@@ -9,41 +8,43 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/urfave/cli/v3"
 )
 
 // ValidateRecipe ensures the recipe arg is valid.
-func ValidateRecipe(cmd *cli.Command) recipe.Recipe {
-	recipeName := cmd.Args().First()
+func ValidateRecipe(args []string, cmdName string) recipe.Recipe {
+	var recipeName string
+	if len(args) > 0 {
+		recipeName = args[0]
+	}
 
-	if recipeName == "" && !NoInput {
-		var recipes []string
+	var recipes []string
 
-		catl, err := recipe.ReadRecipeCatalogue(Offline)
-		if err != nil {
-			log.Fatal(err)
-		}
+	catl, err := recipe.ReadRecipeCatalogue(Offline)
+	if err != nil {
+		log.Fatal(err)
+	}
 
-		knownRecipes := make(map[string]bool)
-		for name := range catl {
-			knownRecipes[name] = true
-		}
-
-		localRecipes, err := recipe.GetRecipesLocal()
-		if err != nil {
-			log.Fatal(err)
-		}
+	knownRecipes := make(map[string]bool)
+	for name := range catl {
+		knownRecipes[name] = true
+	}
 
+	localRecipes, err := recipe.GetRecipesLocal()
+	if err != nil {
+		log.Debugf("can't read local recipes: %s", err)
+	} else {
 		for _, recipeLocal := range localRecipes {
 			if _, ok := knownRecipes[recipeLocal]; !ok {
 				knownRecipes[recipeLocal] = true
 			}
 		}
+	}
 
-		for recipeName := range knownRecipes {
-			recipes = append(recipes, recipeName)
-		}
+	for recipeName := range knownRecipes {
+		recipes = append(recipes, recipeName)
+	}
 
+	if recipeName == "" && !NoInput {
 		prompt := &survey.Select{
 			Message: "Select recipe",
 			Options: recipes,
@@ -54,17 +55,23 @@ func ValidateRecipe(cmd *cli.Command) recipe.Recipe {
 	}
 
 	if recipeName == "" {
-		ShowSubcommandHelpAndError(cmd, errors.New("no recipe name provided"))
+		log.Fatal("no recipe name provided")
+	}
+
+	if _, ok := knownRecipes[recipeName]; !ok {
+		if !strings.Contains(recipeName, "/") {
+			log.Fatalf("no recipe '%s' exists?", recipeName)
+		}
 	}
 
 	chosenRecipe := recipe.Get(recipeName)
-	err := chosenRecipe.EnsureExists()
-	if err != nil {
+	if err := chosenRecipe.EnsureExists(); err != nil {
 		log.Fatal(err)
 	}
+
 	_, err = chosenRecipe.GetComposeConfig(nil)
 	if err != nil {
-		if cmd.Name == "generate" {
+		if cmdName == "generate" {
 			if strings.Contains(err.Error(), "missing a compose") {
 				log.Fatal(err)
 			}
@@ -83,13 +90,13 @@ func ValidateRecipe(cmd *cli.Command) recipe.Recipe {
 }
 
 // ValidateApp ensures the app name arg is valid.
-func ValidateApp(cmd *cli.Command) app.App {
-	appName := cmd.Args().First()
-
-	if appName == "" {
-		ShowSubcommandHelpAndError(cmd, errors.New("no app provided"))
+func ValidateApp(args []string) app.App {
+	if len(args) == 0 {
+		log.Fatal("no app provided")
 	}
 
+	appName := args[0]
+
 	app, err := app.Get(appName)
 	if err != nil {
 		log.Fatal(err)
@@ -101,8 +108,11 @@ func ValidateApp(cmd *cli.Command) app.App {
 }
 
 // ValidateDomain ensures the domain name arg is valid.
-func ValidateDomain(cmd *cli.Command) string {
-	domainName := cmd.Args().First()
+func ValidateDomain(args []string) string {
+	var domainName string
+	if len(args) > 0 {
+		domainName = args[0]
+	}
 
 	if domainName == "" && !NoInput {
 		prompt := &survey.Input{
@@ -115,7 +125,7 @@ func ValidateDomain(cmd *cli.Command) string {
 	}
 
 	if domainName == "" {
-		ShowSubcommandHelpAndError(cmd, errors.New("no domain provided"))
+		log.Fatal("no domain provided")
 	}
 
 	log.Debugf("validated %s as domain argument", domainName)
@@ -123,23 +133,12 @@ func ValidateDomain(cmd *cli.Command) string {
 	return domainName
 }
 
-// ValidateSubCmdFlags ensures flag order conforms to correct order
-func ValidateSubCmdFlags(cmd *cli.Command) bool {
-	for argIdx, arg := range cmd.Args().Slice() {
-		if !strings.HasPrefix(arg, "--") {
-			for _, flag := range cmd.Args().Slice()[argIdx:] {
-				if strings.HasPrefix(flag, "--") {
-					return false
-				}
-			}
-		}
-	}
-	return true
-}
-
 // ValidateServer ensures the server name arg is valid.
-func ValidateServer(cmd *cli.Command) string {
-	serverName := cmd.Args().First()
+func ValidateServer(args []string) string {
+	var serverName string
+	if len(args) > 0 {
+		serverName = args[0]
+	}
 
 	serverNames, err := config.ReadServerNames()
 	if err != nil {
@@ -164,11 +163,11 @@ func ValidateServer(cmd *cli.Command) string {
 	}
 
 	if serverName == "" {
-		ShowSubcommandHelpAndError(cmd, errors.New("no server provided"))
+		log.Fatal("no server provided")
 	}
 
 	if !matched {
-		ShowSubcommandHelpAndError(cmd, errors.New("server doesn't exist?"))
+		log.Fatal("server doesn't exist?")
 	}
 
 	log.Debugf("validated %s as server argument", serverName)

cli/recipe/diff.go

@@ -1,31 +1,29 @@
 package recipe
 
 import (
-	"context"
-
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	gitPkg "coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var recipeDiffCommand = cli.Command{
-	Name:          "diff",
-	Usage:         "Show unstaged changes in recipe config",
-	Description:   "This command requires /usr/bin/git.",
-	Aliases:       []string{"d"},
-	UsageText:     "abra recipe diff <recipe> [options]",
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.RecipeNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		r := internal.ValidateRecipe(cmd)
-
+var RecipeDiffCommand = &cobra.Command{
+	Use:     "diff <recipe> [flags]",
+	Aliases: []string{"d"},
+	Short:   "Show unstaged changes in recipe config",
+	Long:    "This command requires /usr/bin/git.",
+	Args:    cobra.MinimumNArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		r := internal.ValidateRecipe(args, cmd.Name())
 		if err := gitPkg.DiffUnstaged(r.Dir); err != nil {
 			log.Fatal(err)
 		}
-
-		return nil
 	},
 }

cli/recipe/fetch.go

@@ -1,34 +1,87 @@
 package recipe
 
 import (
-	"context"
+	"os"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/urfave/cli/v3"
+	"github.com/go-git/go-git/v5"
+	gitCfg "github.com/go-git/go-git/v5/config"
+	"github.com/spf13/cobra"
 )
 
-var recipeFetchCommand = cli.Command{
-	Name:          "fetch",
-	Usage:         "Fetch recipe(s)",
-	Aliases:       []string{"f"},
-	UsageText:     "abra recipe fetch [<recipe>] [options]",
-	Description:   "Retrieves all recipes if no <recipe> argument is passed",
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.RecipeNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		recipeName := cmd.Args().First()
-		r := recipe.Get(recipeName)
+var RecipeFetchCommand = &cobra.Command{
+	Use:     "fetch [recipe | --all] [flags]",
+	Aliases: []string{"f"},
+	Short:   "Clone recipe(s) locally",
+	Long:    `Using "--force/-f" Git syncs an existing recipe. It does not erase unstaged changes.`,
+	Args:    cobra.RangeArgs(0, 1),
+	Example: `  # fetch from recipe catalogue
+  abra recipe fetch gitea
+
+  # fetch from remote recipe
+  abra recipe fetch git.foo.org/recipes/myrecipe
+
+  # fetch with ssh remote for hacking
+  abra recipe fetch gitea --ssh`,
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		var recipeName string
+		if len(args) > 0 {
+			recipeName = args[0]
+		}
+
+		if recipeName == "" && !fetchAllRecipes {
+			log.Fatal("missing [recipe] or --all/-a")
+		}
+
+		if recipeName != "" && fetchAllRecipes {
+			log.Fatal("cannot use [recipe] and --all/-a together")
+		}
+
 		if recipeName != "" {
-			internal.ValidateRecipe(cmd)
-			if err := r.Ensure(false, false); err != nil {
-				log.Fatal(err)
+			r := recipe.Get(recipeName)
+			if _, err := os.Stat(r.Dir); !os.IsNotExist(err) {
+				if !force {
+					log.Warnf("%s is already fetched", r.Name)
+					return
+				}
 			}
-			return nil
+
+			r = internal.ValidateRecipe(args, cmd.Name())
+
+			if sshRemote {
+				if r.SSHURL == "" {
+					log.Warnf("unable to discover SSH remote for %s", r.Name)
+					return
+				}
+
+				repo, err := git.PlainOpen(r.Dir)
+				if err != nil {
+					log.Fatalf("unable to open %s: %s", r.Dir, err)
+				}
+
+				if err = repo.DeleteRemote("origin"); err != nil {
+					log.Fatalf("unable to remove default remote in %s: %s", r.Dir, err)
+				}
+
+				if _, err := repo.CreateRemote(&gitCfg.RemoteConfig{
+					Name: "origin",
+					URLs: []string{r.SSHURL},
+				}); err != nil {
+					log.Fatalf("unable to set SSH remote in %s: %s", r.Dir, err)
+				}
+			}
+
+			return
 		}
 
 		catalogue, err := recipe.ReadRecipeCatalogue(internal.Offline)
@@ -37,14 +90,45 @@ var recipeFetchCommand = cli.Command{
 		}
 
 		catlBar := formatter.CreateProgressbar(len(catalogue), "fetching latest recipes...")
+		ensureCtx := internal.GetEnsureContext()
 		for recipeName := range catalogue {
 			r := recipe.Get(recipeName)
-			if err := r.Ensure(false, false); err != nil {
+			if err := r.Ensure(ensureCtx); err != nil {
 				log.Error(err)
 			}
 			catlBar.Add(1)
 		}
-
-		return nil
 	},
 }
+
+var (
+	fetchAllRecipes bool
+	sshRemote       bool
+	force           bool
+)
+
+func init() {
+	RecipeFetchCommand.Flags().BoolVarP(
+		&fetchAllRecipes,
+		"all",
+		"a",
+		false,
+		"fetch all recipes",
+	)
+
+	RecipeFetchCommand.Flags().BoolVarP(
+		&sshRemote,
+		"ssh",
+		"s",
+		false,
+		"automatically set ssh remote",
+	)
+
+	RecipeFetchCommand.Flags().BoolVarP(
+		&force,
+		"force",
+		"f",
+		false,
+		"force re-fetch",
+	)
+}

cli/recipe/lint.go

@@ -1,33 +1,29 @@
 package recipe
 
 import (
-	"context"
-	"fmt"
-
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var recipeLintCommand = cli.Command{
-	Name:      "lint",
-	Usage:     "Lint a recipe",
-	Aliases:   []string{"l"},
-	UsageText: "abra recipe lint <recipe> [options]",
-	Flags: []cli.Flag{
-		internal.OnlyErrorFlag,
-		internal.ChaosFlag,
+var RecipeLintCommand = &cobra.Command{
+	Use:     "lint <recipe> [flags]",
+	Short:   "Lint a recipe",
+	Aliases: []string{"l"},
+	Args:    cobra.MinimumNArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.RecipeNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		recipe := internal.ValidateRecipe(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
 
-		if err := recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+		if err := recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
@@ -52,7 +48,7 @@ var recipeLintCommand = cli.Command{
 		var warnMessages []string
 		for level := range lint.LintRules {
 			for _, rule := range lint.LintRules[level] {
-				if internal.OnlyErrors && rule.Level != "error" {
+				if onlyError && rule.Level != "error" {
 					log.Debugf("skipping %s, does not have level \"error\"", rule.Ref)
 					continue
 				}
@@ -106,7 +102,9 @@ var recipeLintCommand = cli.Command{
 		}
 
 		if len(rows) > 0 {
-			fmt.Println(table)
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
+			}
 
 			for _, warnMsg := range warnMessages {
 				log.Warn(warnMsg)
@@ -116,7 +114,27 @@ var recipeLintCommand = cli.Command{
 				log.Warnf("critical errors present in %s config", recipe.Name)
 			}
 		}
-
-		return nil
 	},
 }
+
+var (
+	onlyError bool
+)
+
+func init() {
+	RecipeLintCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+
+	RecipeLintCommand.Flags().BoolVarP(
+		&onlyError,
+		"error",
+		"e",
+		false,
+		"only show errors",
+	)
+}

cli/recipe/list.go

@@ -1,7 +1,6 @@
 package recipe
 
 import (
-	"context"
 	"fmt"
 	"sort"
 	"strconv"
@@ -11,33 +10,18 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var pattern string
-var patternFlag = &cli.StringFlag{
-	Name:        "pattern",
-	Aliases:     []string{"p"},
-	Value:       "",
-	Usage:       "Simple string to filter recipes",
-	Destination: &pattern,
-}
-
-var recipeListCommand = cli.Command{
-	Name:      "list",
-	Usage:     "List recipes",
-	UsageText: "abra recipe list [options]",
-	Aliases:   []string{"ls"},
-	Flags: []cli.Flag{
-		internal.MachineReadableFlag,
-		patternFlag,
-	},
-	Before:   internal.SubCommandBefore,
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
+var RecipeListCommand = &cobra.Command{
+	Use:     "list",
+	Short:   "List recipes",
+	Aliases: []string{"ls"},
+	Args:    cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
 		catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
-			log.Fatal(err.Error())
+			log.Fatal(err)
 		}
 
 		recipes := catl.Flatten()
@@ -92,13 +76,34 @@ var recipeListCommand = cli.Command{
 					log.Fatal("unable to render to JSON: %s", err)
 				}
 				fmt.Println(out)
-				return nil
+				return
 			}
 
-			fmt.Println(table)
-			log.Infof("total recipes: %v", len(rows))
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
+			}
 		}
-
-		return nil
 	},
 }
+
+var (
+	pattern string
+)
+
+func init() {
+	RecipeListCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		"machine",
+		"m",
+		false,
+		"print machine-readable output",
+	)
+
+	RecipeListCommand.Flags().StringVarP(
+		&pattern,
+		"pattern",
+		"p",
+		"",
+		"filter by recipe",
+	)
+}

cli/recipe/new.go

@@ -2,19 +2,17 @@ package recipe
 
 import (
 	"bytes"
-	"context"
-	"errors"
 	"fmt"
 	"os"
 	"path"
 	"text/template"
 
-	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
 // recipeMetadata is the recipe metadata for the README.md
@@ -31,30 +29,22 @@ type recipeMetadata struct {
 	SSO         string
 }
 
-var recipeNewCommand = cli.Command{
-	Name:    "new",
+var RecipeNewCommand = &cobra.Command{
+	Use:     "new <recipe> [flags]",
 	Aliases: []string{"n"},
-	Flags: []cli.Flag{
-		internal.GitNameFlag,
-		internal.GitEmailFlag,
+	Short:   "Create a new recipe",
+	Long:    `A community managed recipe template is used.`,
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
 	},
-	Before:    internal.SubCommandBefore,
-	Usage:     "Create a new recipe",
-	UsageText: "abra recipe new <recipe> [options]",
-	Description: `Create a new recipe.
+	Run: func(cmd *cobra.Command, args []string) {
+		recipeName := args[0]
 
-Abra uses the built-in example repository which is available here:
-
-    https://git.coopcloud.tech/coop-cloud/example`,
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		recipeName := cmd.Args().First()
 		r := recipe.Get(recipeName)
-
-		if recipeName == "" {
-			internal.ShowSubcommandHelpAndError(cmd, errors.New("no recipe name provided"))
-		}
-
 		if _, err := os.Stat(r.Dir); !os.IsNotExist(err) {
 			log.Fatalf("%s recipe directory already exists?", r.Dir)
 		}
@@ -68,7 +58,7 @@ Abra uses the built-in example repository which is available here:
 		if err := os.RemoveAll(gitRepo); err != nil {
 			log.Fatal(err)
 		}
-		log.Debugf("removed example git repo in %s", gitRepo)
+		log.Debugf("removed .git repo in %s", gitRepo)
 
 		meta := newRecipeMeta(recipeName)
 
@@ -86,17 +76,14 @@ Abra uses the built-in example repository which is available here:
 			if err := os.WriteFile(path, templated.Bytes(), 0o644); err != nil {
 				log.Fatal(err)
 			}
-
 		}
 
-		if err := git.Init(r.Dir, true, internal.GitName, internal.GitEmail); err != nil {
+		if err := git.Init(r.Dir, true, gitName, gitEmail); err != nil {
 			log.Fatal(err)
 		}
 
 		log.Infof("new recipe '%s' created: %s", recipeName, path.Join(r.Dir))
 		log.Info("happy hacking 🎉")
-
-		return nil
 	},
 }
 
@@ -115,3 +102,26 @@ func newRecipeMeta(recipeName string) recipeMetadata {
 		SSO:         "No",
 	}
 }
+
+var (
+	gitName  string
+	gitEmail string
+)
+
+func init() {
+	RecipeNewCommand.Flags().StringVarP(
+		&gitName,
+		"git-name",
+		"N",
+		"",
+		"Git (user) name to do commits with",
+	)
+
+	RecipeNewCommand.Flags().StringVarP(
+		&gitEmail,
+		"git-email",
+		"e",
+		"",
+		"Git email name to do commits with",
+	)
+}

cli/recipe/recipe.go

@@ -1,16 +1,13 @@
 package recipe
 
-import (
-	"github.com/urfave/cli/v3"
-)
+import "github.com/spf13/cobra"
 
 // RecipeCommand defines all recipe related sub-commands.
-var RecipeCommand = cli.Command{
-	Name:      "recipe",
-	Aliases:   []string{"r"},
-	Usage:     "Manage recipes",
-	UsageText: "abra recipe [command] [arguments] [options]",
-	Description: `A recipe is a blueprint for an app.
+var RecipeCommand = &cobra.Command{
+	Use:     "recipe [cmd] [args] [flags]",
+	Aliases: []string{"r"},
+	Short:   "Manage recipes",
+	Long: `A recipe is a blueprint for an app.
 
 It is a bunch of config files which describe how to deploy and maintain an app.
 Recipes are maintained by the Co-op Cloud community and you can use Abra to
@@ -19,16 +16,4 @@ read them, deploy them and create apps for you.
 Anyone who uses a recipe can become a maintainer. Maintainers typically make
 sure the recipe is in good working order and the config upgraded in a timely
 manner.`,
-	Commands: []*cli.Command{
-		&recipeFetchCommand,
-		&recipeLintCommand,
-		&recipeListCommand,
-		&recipeNewCommand,
-		&recipeReleaseCommand,
-		&recipeSyncCommand,
-		&recipeUpgradeCommand,
-		&recipeVersionCommand,
-		&recipeResetCommand,
-		&recipeDiffCommand,
-	},
 }

cli/recipe/release.go

@@ -1,7 +1,6 @@
 package recipe
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"os"
@@ -19,15 +18,14 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
 	"github.com/go-git/go-git/v5"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var recipeReleaseCommand = cli.Command{
-	Name:      "release",
-	Aliases:   []string{"rl"},
-	Usage:     "Release a new recipe version",
-	UsageText: "abra recipe release <recipe> [<version>] [options]",
-	Description: `Create a new version of a recipe.
+var RecipeReleaseCommand = &cobra.Command{
+	Use:     "release <recipe> [version] [flags]",
+	Aliases: []string{"rl"},
+	Short:   "Release a new recipe version",
+	Long: `Create a new version of a recipe.
 
 These versions are then published on the Co-op Cloud recipe catalogue. These
 versions take the following form:
@@ -44,21 +42,25 @@ recipe updates are properly communicated. I.e. developers of an app might
 publish a minor version but that might lead to changes in the recipe which are
 major and therefore require intervention while doing the upgrade work.
 
-Publish your new release to git.coopcloud.tech with "-p/--publish". This
+Publish your new release to git.coopcloud.tech with "--publish/-p". This
 requires that you have permission to git push to these repositories and have
 your SSH keys configured on your account.`,
-	Flags: []cli.Flag{
-		internal.DryFlag,
-		internal.MajorFlag,
-		internal.MinorFlag,
-		internal.PatchFlag,
-		internal.PublishFlag,
+	Args: cobra.RangeArgs(1, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.RecipeNameComplete()
+		case 1:
+			return autocomplete.RecipeVersionComplete(args[0])
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.RecipeNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		recipe := internal.ValidateRecipe(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
 
 		imagesTmp, err := getImageVersions(recipe)
 		if err != nil {
@@ -75,7 +77,11 @@ your SSH keys configured on your account.`,
 			log.Fatalf("main app service version for %s is empty?", recipe.Name)
 		}
 
-		tagString := cmd.Args().Get(1)
+		var tagString string
+		if len(args) == 2 {
+			tagString = args[1]
+		}
+
 		if tagString != "" {
 			if _, err := tagcmp.Parse(tagString); err != nil {
 				log.Fatalf("cannot parse %s, invalid tag specified?", tagString)
@@ -133,7 +139,7 @@ your SSH keys configured on your account.`,
 			}
 		}
 
-		return nil
+		return
 	},
 }
 
@@ -246,7 +252,14 @@ func getTagCreateOptions(tag string) (git.CreateTagOptions, error) {
 // addReleaseNotes checks if the release/next release note exists and moves the
 // file to release/<tag>.
 func addReleaseNotes(recipe recipe.Recipe, tag string) error {
-	tagReleaseNotePath := path.Join(recipe.Dir, "release", tag)
+	releaseDir := path.Join(recipe.Dir, "release")
+	if _, err := os.Stat(releaseDir); errors.Is(err, os.ErrNotExist) {
+		if err := os.Mkdir(releaseDir, 0755); err != nil {
+			return err
+		}
+	}
+
+	tagReleaseNotePath := path.Join(releaseDir, tag)
 	if _, err := os.Stat(tagReleaseNotePath); err == nil {
 		// Release note for current tag already exist exists.
 		return nil
@@ -254,49 +267,55 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 		return err
 	}
 
-	nextReleaseNotePath := path.Join(recipe.Dir, "release", "next")
+	var addNextAsReleaseNotes bool
+
+	nextReleaseNotePath := path.Join(releaseDir, "next")
 	if _, err := os.Stat(nextReleaseNotePath); err == nil {
 		// release/next note exists. Move it to release/<tag>
 		if internal.Dry {
 			log.Debugf("dry run: move release note from 'next' to %s", tag)
 			return nil
 		}
+
 		if !internal.NoInput {
-			prompt := &survey.Input{
+			prompt := &survey.Confirm{
 				Message: "Use release note in release/next?",
 			}
-			var addReleaseNote bool
-			if err := survey.AskOne(prompt, &addReleaseNote); err != nil {
+
+			if err := survey.AskOne(prompt, &addNextAsReleaseNotes); err != nil {
 				return err
 			}
-			if !addReleaseNote {
+
+			if !addNextAsReleaseNotes {
 				return nil
 			}
 		}
-		err := os.Rename(nextReleaseNotePath, tagReleaseNotePath)
-		if err != nil {
+
+		if err := os.Rename(nextReleaseNotePath, tagReleaseNotePath); err != nil {
 			return err
 		}
-		err = gitPkg.Add(recipe.Dir, path.Join("release", "next"), internal.Dry)
-		if err != nil {
+
+		if err := gitPkg.Add(recipe.Dir, path.Join("release", "next"), internal.Dry); err != nil {
 			return err
 		}
-		err = gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry)
-		if err != nil {
+
+		if err := gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry); err != nil {
 			return err
 		}
 	} else if !errors.Is(err, os.ErrNotExist) {
 		return err
 	}
 
-	// No release note exists for the current release.
-	if internal.NoInput {
+	// NOTE(d1): No release note exists for the current release. Or, we've
+	// already used release/next as the release note
+	if internal.NoInput || addNextAsReleaseNotes {
 		return nil
 	}
 
 	prompt := &survey.Input{
 		Message: "Release Note (leave empty for no release note)",
 	}
+
 	var releaseNote string
 	if err := survey.AskOne(prompt, &releaseNote); err != nil {
 		return err
@@ -306,12 +325,11 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 		return nil
 	}
 
-	err := os.WriteFile(tagReleaseNotePath, []byte(releaseNote), 0o644)
-	if err != nil {
+	if err := os.WriteFile(tagReleaseNotePath, []byte(releaseNote), 0o644); err != nil {
 		return err
 	}
-	err = gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry)
-	if err != nil {
+
+	if err := gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry); err != nil {
 		return err
 	}
 
@@ -376,17 +394,17 @@ func pushRelease(recipe recipe.Recipe, tagString string) error {
 		return nil
 	}
 
-	if !internal.Publish && !internal.NoInput {
+	if !publish && !internal.NoInput {
 		prompt := &survey.Confirm{
 			Message: "publish new release?",
 		}
 
-		if err := survey.AskOne(prompt, &internal.Publish); err != nil {
+		if err := survey.AskOne(prompt, &publish); err != nil {
 			return err
 		}
 	}
 
-	if internal.Publish {
+	if publish {
 		if err := recipe.Push(internal.Dry); err != nil {
 			return err
 		}
@@ -546,3 +564,50 @@ func getLabelVersion(recipe recipe.Recipe, prompt bool) (string, error) {
 
 	return initTag, nil
 }
+
+var (
+	publish bool
+)
+
+func init() {
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&internal.Dry,
+		"dry-run",
+		"r",
+		false,
+		"report changes that would be made",
+	)
+
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&internal.Major,
+		"major",
+		"x",
+		false,
+		"increase the major part of the version",
+	)
+
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&internal.Minor,
+		"minor",
+		"y",
+		false,
+		"increase the minor part of the version",
+	)
+
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&internal.Patch,
+		"patch",
+		"z",
+		false,
+		"increase the patch part of the version",
+	)
+
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&publish,
+		"publish",
+		"p",
+		false,
+		"publish changes to git.coopcloud.tech",
+	)
+
+}

cli/recipe/reset.go

@@ -1,32 +1,27 @@
 package recipe
 
 import (
-	"context"
-
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/log"
-	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/go-git/go-git/v5"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var recipeResetCommand = cli.Command{
-	Name:          "reset",
-	Usage:         "Remove all unstaged changes from recipe config",
-	Description:   "WARNING: this will delete your changes. Be Careful.",
-	Aliases:       []string{"rs"},
-	UsageText:     "abra recipe reset <recipe> [options]",
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.RecipeNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		recipeName := cmd.Args().First()
-		r := recipe.Get(recipeName)
-
-		if recipeName != "" {
-			internal.ValidateRecipe(cmd)
-		}
+var RecipeResetCommand = &cobra.Command{
+	Use:     "reset <recipe> [flags]",
+	Aliases: []string{"rs"},
+	Short:   "Remove all unstaged changes from recipe config",
+	Long:    "WARNING: this will delete your changes. Be Careful.",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		r := internal.ValidateRecipe(args, cmd.Name())
 
 		repo, err := git.PlainOpen(r.Dir)
 		if err != nil {
@@ -47,7 +42,5 @@ var recipeResetCommand = cli.Command{
 		if err := worktree.Reset(opts); err != nil {
 			log.Fatal(err)
 		}
-
-		return nil
 	},
 }

cli/recipe/sync.go

@@ -1,7 +1,6 @@
 package recipe
 
 import (
-	"context"
 	"fmt"
 	"strconv"
 
@@ -13,34 +12,38 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-var recipeSyncCommand = cli.Command{
-	Name:      "sync",
-	Aliases:   []string{"s"},
-	Usage:     "Sync recipe version label",
-	UsageText: "abra recipe lint <recipe> [<version>] [options]",
-	Flags: []cli.Flag{
-		internal.DryFlag,
-		internal.MajorFlag,
-		internal.MinorFlag,
-		internal.PatchFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `Generate labels for the main recipe service.
+var RecipeSyncCommand = &cobra.Command{
+	Use:     "sync <recipe> [version] [flags]",
+	Aliases: []string{"s"},
+	Short:   "Sync recipe version label",
+	Long: `Generate labels for the main recipe service.
 
 By convention, the service named "app" using the following format:
 
     coop-cloud.${STACK_NAME}.version=<version>
 
-Where <version> can be specifed on the command-line or Abra can attempt to
+Where [version] can be specifed on the command-line or Abra can attempt to
 auto-generate it for you. The <recipe> configuration will be updated on the
 local file system.`,
-	ShellComplete: autocomplete.RecipeNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		recipe := internal.ValidateRecipe(cmd)
+	Args: cobra.RangeArgs(1, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.RecipeNameComplete()
+		case 1:
+			return autocomplete.RecipeVersionComplete(args[0])
+		default:
+			return nil, cobra.ShellCompDirectiveError
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
 
 		mainApp, err := internal.GetMainAppImage(recipe)
 		if err != nil {
@@ -59,7 +62,11 @@ local file system.`,
 			log.Fatal(err)
 		}
 
-		nextTag := cmd.Args().Get(1)
+		var nextTag string
+		if len(args) == 2 {
+			nextTag = args[1]
+		}
+
 		if len(tags) == 0 && nextTag == "" {
 			log.Warnf("no git tags found for %s", recipe.Name)
 			if internal.NoInput {
@@ -205,7 +212,39 @@ likely to change.
 				log.Fatal(err)
 			}
 		}
-
-		return nil
 	},
 }
+
+func init() {
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Dry,
+		"dry-run",
+		"r",
+		false,
+		"report changes that would be made",
+	)
+
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Major,
+		"major",
+		"x",
+		false,
+		"increase the major part of the version",
+	)
+
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Minor,
+		"minor",
+		"y",
+		false,
+		"increase the minor part of the version",
+	)
+
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Patch,
+		"patch",
+		"z",
+		false,
+		"increase the patch part of the version",
+	)
+}

cli/recipe/upgrade.go

@@ -2,7 +2,6 @@ package recipe
 
 import (
 	"bufio"
-	"context"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -20,7 +19,7 @@ import (
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
 type imgPin struct {
@@ -37,12 +36,11 @@ type anUpgrade struct {
 	UpgradeTags []string `json:"upgrades"`
 }
 
-var recipeUpgradeCommand = cli.Command{
-	Name:      "upgrade",
-	Aliases:   []string{"u"},
-	Usage:     "Upgrade recipe image tags",
-	UsageText: "abra recipe upgrade [<recipe>] [options]",
-	Description: `Upgrade a given <recipe> configuration.
+var RecipeUpgradeCommand = &cobra.Command{
+	Use:     "upgrade <recipe> [flags]",
+	Aliases: []string{"u"},
+	Short:   "Upgrade recipe image tags",
+	Long: `Upgrade a given <recipe> configuration.
 
 It will update the relevant compose file tags on the local file system.
 
@@ -55,20 +53,17 @@ make a seclection. Use the "?" key to see more help on navigating this
 interface.
 
 You may invoke this command in "wizard" mode and be prompted for input.`,
-	Flags: []cli.Flag{
-		internal.PatchFlag,
-		internal.MinorFlag,
-		internal.MajorFlag,
-		internal.MachineReadableFlag,
-		internal.AllTagsFlag,
+	Args: cobra.RangeArgs(0, 1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.RecipeNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		recipe := internal.ValidateRecipe(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
 
-		if err := recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+		if err := recipe.Ensure(internal.GetEnsureContext()); err != nil {
 			log.Fatal(err)
 		}
 
@@ -177,7 +172,7 @@ You may invoke this command in "wizard" mode and be prompted for input.`,
 
 			sort.Sort(tagcmp.ByTagDesc(compatible))
 
-			if len(compatible) == 0 && !internal.AllTags {
+			if len(compatible) == 0 && !allTags {
 				log.Info(fmt.Sprintf("no new versions available for %s, assuming %s is the latest (use -a/--all-tags to see all anyway)", image, tag))
 				continue // skip on to the next tag and don't update any compose files
 			}
@@ -231,7 +226,7 @@ You may invoke this command in "wizard" mode and be prompted for input.`,
 					for _, upTag := range compatible {
 						upElement, err := tag.UpgradeDelta(upTag)
 						if err != nil {
-							return err
+							return
 						}
 						delta := upElement.UpgradeType()
 						if delta <= bumpType {
@@ -245,9 +240,9 @@ You may invoke this command in "wizard" mode and be prompted for input.`,
 					}
 				} else {
 					msg := fmt.Sprintf("upgrade to which tag? (service: %s, image: %s, tag: %s)", service.Name, image, tag)
-					if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) || internal.AllTags {
+					if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) || allTags {
 						tag := img.(reference.NamedTagged).Tag()
-						if !internal.AllTags {
+						if !allTags {
 							log.Warn(fmt.Sprintf("unable to determine versioning semantics of %s, listing all tags", tag))
 						}
 						msg = fmt.Sprintf("upgrade to which tag? (service: %s, tag: %s)", service.Name, tag)
@@ -315,7 +310,7 @@ You may invoke this command in "wizard" mode and be prompted for input.`,
 
 				fmt.Println(string(jsonstring))
 
-				return nil
+				return
 			}
 
 			for _, upgrade := range upgradeList {
@@ -336,7 +331,51 @@ You may invoke this command in "wizard" mode and be prompted for input.`,
 				log.Fatal(err)
 			}
 		}
-
-		return nil
 	},
 }
+
+var (
+	allTags bool
+)
+
+func init() {
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&internal.Major,
+		"major",
+		"x",
+		false,
+		"increase the major part of the version",
+	)
+
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&internal.Minor,
+		"minor",
+		"y",
+		false,
+		"increase the minor part of the version",
+	)
+
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&internal.Patch,
+		"patch",
+		"z",
+		false,
+		"increase the patch part of the version",
+	)
+
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		"machine",
+		"m",
+		false,
+		"print machine-readable output",
+	)
+
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&allTags,
+		"all-tags",
+		"a",
+		false,
+		"list all tags, not just upgrades",
+	)
+}

cli/recipe/version.go

@@ -1,7 +1,6 @@
 package recipe
 
 import (
-	"context"
 	"fmt"
 	"sort"
 
@@ -10,34 +9,24 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"github.com/urfave/cli/v3"
+	"github.com/spf13/cobra"
 )
 
-func sortServiceByName(versions [][]string) func(i, j int) bool {
-	return func(i, j int) bool {
-		// NOTE(d1): corresponds to the `tableCol` definition below
-		if versions[i][1] == "app" {
-			return true
-		}
-		return versions[i][1] < versions[j][1]
-	}
-}
-
-var recipeVersionCommand = cli.Command{
-	Name:      "versions",
-	Aliases:   []string{"v"},
-	Usage:     "List recipe versions",
-	UsageText: "abra recipe version <recipe> [options]",
-	Flags: []cli.Flag{
-		internal.MachineReadableFlag,
+var RecipeVersionCommand = &cobra.Command{
+	Use:     "versions <recipe> [flags]",
+	Aliases: []string{"v"},
+	Short:   "List recipe versions",
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.RecipeNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
+	Run: func(cmd *cobra.Command, args []string) {
 		var warnMessages []string
 
-		recipe := internal.ValidateRecipe(cmd)
+		recipe := internal.ValidateRecipe(args, cmd.Name())
 
 		catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
@@ -48,10 +37,13 @@ var recipeVersionCommand = cli.Command{
 		if !ok {
 			warnMessages = append(warnMessages, "retrieved versions from local recipe repository")
 
-			recipeVersions, err := recipe.GetRecipeVersions()
+			recipeVersions, warnMsg, err := recipe.GetRecipeVersions()
 			if err != nil {
 				warnMessages = append(warnMessages, err.Error())
 			}
+			if len(warnMsg) > 0 {
+				warnMessages = append(warnMessages, warnMsg...)
+			}
 
 			recipeMeta = recipePkg.RecipeMeta{Versions: recipeVersions}
 		}
@@ -66,15 +58,32 @@ var recipeVersionCommand = cli.Command{
 				log.Fatal(err)
 			}
 
-			table.Headers("SERVICE", "NAME", "TAG")
+			table.Headers("SERVICE", "IMAGE", "TAG", "VERSION")
 
 			for version, meta := range recipeMeta.Versions[i] {
 				var allRows [][]string
 				var rows [][]string
 
 				for service, serviceMeta := range meta {
-					rows = append(rows, []string{service, serviceMeta.Image, serviceMeta.Tag})
-					allRows = append(allRows, []string{version, service, serviceMeta.Image, serviceMeta.Tag})
+					recipeVersion := version
+					if service != "app" {
+						recipeVersion = ""
+					}
+
+					rows = append(rows, []string{
+						service,
+						serviceMeta.Image,
+						serviceMeta.Tag,
+						recipeVersion,
+					})
+
+					allRows = append(allRows, []string{
+						version,
+						service,
+						serviceMeta.Image,
+						serviceMeta.Tag,
+						recipeVersion,
+					})
 				}
 
 				sort.Slice(rows, sortServiceByName(rows))
@@ -82,9 +91,9 @@ var recipeVersionCommand = cli.Command{
 				table.Rows(rows...)
 
 				if !internal.MachineReadable {
-					fmt.Println(table)
-					log.Infof("VERSION: %s", version)
-					fmt.Println()
+					if err := formatter.PrintTable(table); err != nil {
+						log.Fatal(err)
+					}
 					continue
 				}
 
@@ -106,7 +115,21 @@ var recipeVersionCommand = cli.Command{
 				log.Warn(warnMsg)
 			}
 		}
-
-		return nil
 	},
 }
+
+func sortServiceByName(versions [][]string) func(i, j int) bool {
+	return func(i, j int) bool {
+		return versions[i][0] < versions[j][0]
+	}
+}
+
+func init() {
+	RecipeVersionCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		"machine",
+		"m",
+		false,
+		"print machine-readable output",
+	)
+}

cli/run.go

@@ -0,0 +1,221 @@
+package cli
+
+import (
+	"fmt"
+	"os"
+
+	"coopcloud.tech/abra/cli/app"
+	"coopcloud.tech/abra/cli/catalogue"
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/cli/recipe"
+	"coopcloud.tech/abra/cli/server"
+	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/log"
+	charmLog "github.com/charmbracelet/log"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
+)
+
+func Run(version, commit string) {
+	rootCmd := &cobra.Command{
+		Use:     gotext.Get("abra [cmd] [args] [flags]"),
+		Short:   gotext.Get("The Co-op Cloud command-line utility belt 🎩🐇"),
+		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
+		ValidArgs: []string{
+			gotext.Get("app"),
+			gotext.Get("autocomplete"),
+			gotext.Get("catalogue"),
+			gotext.Get("man"),
+			gotext.Get("recipe"),
+			gotext.Get("server"),
+			gotext.Get("upgrade"),
+		},
+		PersistentPreRun: func(cmd *cobra.Command, args []string) {
+			dirs := []map[string]os.FileMode{
+				{config.ABRA_DIR: 0764},
+				{config.SERVERS_DIR: 0700},
+				{config.RECIPES_DIR: 0764},
+				{config.LOGS_DIR: 0764},
+			}
+
+			for _, dir := range dirs {
+				for path, perm := range dir {
+					if err := os.Mkdir(path, perm); err != nil {
+						if !os.IsExist(err) {
+							log.Fatal(err)
+						}
+						continue
+					}
+				}
+			}
+
+			log.Logger.SetStyles(charmLog.DefaultStyles())
+			charmLog.SetDefault(log.Logger)
+
+			if internal.MachineReadable {
+				log.SetOutput(os.Stderr)
+			}
+
+			if internal.Debug {
+				log.SetLevel(log.DebugLevel)
+				log.SetOutput(os.Stderr)
+				log.SetReportCaller(true)
+			}
+
+			log.Debugf(gotext.Get("abra version %s, commit %s", version, commit))
+		},
+	}
+
+	rootCmd.CompletionOptions.DisableDefaultCmd = true
+
+	manCommand := &cobra.Command{
+		Use:     gotext.Get("man [flags]"),
+		Aliases: []string{"m"},
+		Short:   gotext.Get("Generate manpage"),
+		Example: gotext.Get(`  # generate the man pages into /usr/local/share/man/man1
+  abra_path=$(which abra)  # pass abra absolute path to sudo below
+  sudo $abra_path man
+  sudo mandb
+
+  # read the man pages
+  man abra
+  man abra-app-deploy`),
+		Run: func(cmd *cobra.Command, args []string) {
+			header := &doc.GenManHeader{
+				Title:   "ABRA",
+				Section: "1",
+			}
+
+			manDir := "/usr/local/share/man/man1"
+			if _, err := os.Stat(manDir); os.IsNotExist(err) {
+				log.Fatal(gotext.Get("unable to proceed, %s does not exist?", manDir))
+			}
+
+			err := doc.GenManTree(rootCmd, header, manDir)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			log.Info(gotext.Get("don't forget to run 'sudo mandb'"))
+		},
+	}
+
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.Debug,
+		"debug",
+		"d",
+		false,
+		gotext.Get("show debug messages"),
+	)
+
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.NoInput,
+		"no-input",
+		"n",
+		false,
+		gotext.Get("toggle non-interactive mode"),
+	)
+
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.Offline,
+		"offline",
+		"o",
+		false,
+		gotext.Get("prefer offline & filesystem access"),
+	)
+
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.IgnoreEnvVersion,
+		"ignore-env-version",
+		"i",
+		false,
+		gotext.Get("ignore .env version checkout"),
+	)
+
+	catalogue.CatalogueCommand.AddCommand(
+		catalogue.CatalogueGenerateCommand,
+	)
+
+	server.ServerCommand.AddCommand(
+		server.ServerAddCommand,
+		server.ServerListCommand,
+		server.ServerPruneCommand,
+		server.ServerRemoveCommand,
+	)
+
+	recipe.RecipeCommand.AddCommand(
+		recipe.RecipeDiffCommand,
+		recipe.RecipeFetchCommand,
+		recipe.RecipeLintCommand,
+		recipe.RecipeListCommand,
+		recipe.RecipeNewCommand,
+		recipe.RecipeReleaseCommand,
+		recipe.RecipeResetCommand,
+		recipe.RecipeSyncCommand,
+		recipe.RecipeUpgradeCommand,
+		recipe.RecipeVersionCommand,
+	)
+
+	rootCmd.AddCommand(
+		UpgradeCommand,
+		AutocompleteCommand,
+		manCommand,
+		app.AppCommand,
+		catalogue.CatalogueCommand,
+		server.ServerCommand,
+		recipe.RecipeCommand,
+	)
+
+	app.AppCmdCommand.AddCommand(
+		app.AppCmdListCommand,
+	)
+
+	app.AppSecretCommand.AddCommand(
+		app.AppSecretGenerateCommand,
+		app.AppSecretInsertCommand,
+		app.AppSecretRmCommand,
+		app.AppSecretLsCommand,
+	)
+
+	app.AppVolumeCommand.AddCommand(
+		app.AppVolumeListCommand,
+		app.AppVolumeRemoveCommand,
+	)
+
+	app.AppBackupCommand.AddCommand(
+		app.AppBackupListCommand,
+		app.AppBackupDownloadCommand,
+		app.AppBackupCreateCommand,
+		app.AppBackupSnapshotsCommand,
+	)
+
+	app.AppCommand.AddCommand(
+		app.AppBackupCommand,
+		app.AppCheckCommand,
+		app.AppCmdCommand,
+		app.AppConfigCommand,
+		app.AppCpCommand,
+		app.AppDeployCommand,
+		app.AppListCommand,
+		app.AppLogsCommand,
+		app.AppNewCommand,
+		app.AppPsCommand,
+		app.AppRemoveCommand,
+		app.AppRestartCommand,
+		app.AppRestoreCommand,
+		app.AppRollbackCommand,
+		app.AppRunCommand,
+		app.AppSecretCommand,
+		app.AppServicesCommand,
+		app.AppUndeployCommand,
+		app.AppUpgradeCommand,
+		app.AppVolumeCommand,
+		app.AppLabelsCommand,
+		app.AppEnvCommand,
+	)
+
+	if err := rootCmd.Execute(); err != nil {
+		os.Exit(1)
+	}
+}

cli/server/add.go

@@ -1,12 +1,11 @@
 package server
 
 import (
-	"context"
-	"errors"
 	"os"
 	"path/filepath"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	contextPkg "coopcloud.tech/abra/pkg/context"
@@ -14,22 +13,119 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/server"
 	sshPkg "coopcloud.tech/abra/pkg/ssh"
-	"github.com/urfave/cli/v3"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
 )
 
-var local bool
-var localFlag = &cli.BoolFlag{
-	Name:        "local",
-	Aliases:     []string{"l"},
-	Usage:       "Use local server",
-	Destination: &local,
+var ServerAddCommand = &cobra.Command{
+	Use:     gotext.Get("add [[server] | --local] [flags]"),
+	Aliases: []string{"a"},
+	Short:   gotext.Get("Add a new server"),
+	Long: gotext.Get(`Add a new server to your configuration so that it can be managed by Abra.
+
+Abra relies on the standard SSH command-line and ~/.ssh/config for client
+connection details. You must configure an entry per-host in your ~/.ssh/config
+for each server:
+
+  Host 1312.net 1312
+    Hostname 1312.net
+    User antifa
+    Port 12345
+    IdentityFile ~/.ssh/antifa@somewhere
+
+If "--local" is passed, then Abra assumes that the current local server is
+intended as the target server. This is useful when you want to have your entire
+Co-op Cloud config located on the server itself, and not on your local
+developer machine. The domain is then set to "default".`),
+	Example: gotext.Get("  abra server add 1312.net"),
+	Args:    cobra.RangeArgs(0, 1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		if !local {
+			return autocomplete.ServerNameComplete()
+		}
+		return nil, cobra.ShellCompDirectiveDefault
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		if len(args) > 0 && local {
+			log.Fatal(gotext.Get("cannot use [server] and --local together"))
+		}
+
+		if len(args) == 0 && !local {
+			log.Fatal(gotext.Get("missing argument or --local/-l flag"))
+		}
+
+		name := "default"
+		if !local {
+			name = internal.ValidateDomain(args)
+		}
+
+		// NOTE(d1): reasonable 5 second timeout for connections which can't
+		// succeed. The connection is attempted twice, so this results in 10
+		// seconds.
+		timeout := client.WithTimeout(5)
+
+		if local {
+			created, err := createServerDir(name)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			log.Debug(gotext.Get("attempting to create client for %s", name))
+
+			if _, err := client.New(name, timeout); err != nil {
+				cleanUp(name)
+				log.Fatal(err)
+			}
+
+			if created {
+				log.Info(gotext.Get("local server successfully added"))
+			} else {
+				log.Warn(gotext.Get("local server already exists"))
+			}
+
+			return
+		}
+
+		_, err := createServerDir(name)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		created, err := newContext(name)
+		if err != nil {
+			cleanUp(name)
+			log.Fatal(gotext.Get("unable to create local context: %s", err))
+		}
+
+		log.Debug(gotext.Get("attempting to create client for %s", name))
+
+		if _, err := client.New(name, timeout); err != nil {
+			cleanUp(name)
+			log.Fatal(gotext.Get("ssh %s error: %s", name, sshPkg.Fatal(name, err)))
+		}
+
+		if created {
+			log.Info(gotext.Get("%s successfully added", name))
+
+			if _, err := dns.EnsureIPv4(name); err != nil {
+				log.Warn(gotext.Get("unable to resolve IPv4 for %s", name))
+			}
+
+			return
+		}
+
+		log.Warn(gotext.Get("%s already exists", name))
+	},
 }
 
 // cleanUp cleans up the partially created context/client details for a failed
 // "server add" attempt.
 func cleanUp(name string) {
 	if name != "default" {
-		log.Debugf("serverAdd: cleanUp: cleaning up context for %s", name)
+		log.Debug(gotext.Get("serverAdd: cleanUp: cleaning up context for %s", name))
 		if err := client.DeleteContext(name); err != nil {
 			log.Fatal(err)
 		}
@@ -38,16 +134,16 @@ func cleanUp(name string) {
 	serverDir := filepath.Join(config.SERVERS_DIR, name)
 	files, err := config.GetAllFilesInDirectory(serverDir)
 	if err != nil {
-		log.Fatalf("serverAdd: cleanUp: unable to list files in %s: %s", serverDir, err)
+		log.Fatal(gotext.Get("serverAdd: cleanUp: unable to list files in %s: %s", serverDir, err))
 	}
 
 	if len(files) > 0 {
-		log.Debugf("serverAdd: cleanUp: %s is not empty, aborting cleanup", serverDir)
+		log.Debug(gotext.Get("serverAdd: cleanUp: %s is not empty, aborting cleanup", serverDir))
 		return
 	}
 
 	if err := os.RemoveAll(serverDir); err != nil {
-		log.Fatalf("serverAdd: cleanUp: failed to remove %s: %s", serverDir, err)
+		log.Fatal(gotext.Get("serverAdd: cleanUp: failed to remove %s: %s", serverDir, err))
 	}
 }
 
@@ -64,12 +160,12 @@ func newContext(name string) (bool, error) {
 
 	for _, context := range contexts {
 		if context.Name == name {
-			log.Debugf("context for %s already exists", name)
+			log.Debug(gotext.Get("context for %s already exists", name))
 			return false, nil
 		}
 	}
 
-	log.Debugf("creating context with domain %s", name)
+	log.Debugf(gotext.Get("creating context with domain %s", name))
 
 	if err := client.CreateContext(name); err != nil {
 		return false, nil
@@ -85,7 +181,7 @@ func createServerDir(name string) (bool, error) {
 			return false, err
 		}
 
-		log.Debugf("server dir for %s already created", name)
+		log.Debug(gotext.Get("server dir for %s already created", name))
 
 		return false, nil
 	}
@@ -93,101 +189,16 @@ func createServerDir(name string) (bool, error) {
 	return true, nil
 }
 
-var serverAddCommand = cli.Command{
-	Name:      "add",
-	Aliases:   []string{"a"},
-	Usage:     "Add a new server",
-	UsageText: "abra server add <domain> [options]",
-	Description: `Add a new server to your configuration so that it can be managed by Abra.
+var (
+	local bool
+)
 
-Abra relies on the standard SSH command-line and ~/.ssh/config for client
-connection details. You must configure an entry per-host in your ~/.ssh/config
-for each server:
-
-  Host example.com example
-    Hostname example.com
-    User exampleUser
-    Port 12345
-    IdentityFile ~/.ssh/example@somewhere
-
-If "--local" is passed, then Abra assumes that the current local server is
-intended as the target server. This is useful when you want to have your entire
-Co-op Cloud config located on the server itself, and not on your local
-developer machine. The domain is then set to "default".`,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		localFlag,
-	},
-	Before:   internal.SubCommandBefore,
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		if cmd.Args().Len() > 0 && local || !internal.ValidateSubCmdFlags(cmd) {
-			err := errors.New("cannot use <name> and --local together")
-			internal.ShowSubcommandHelpAndError(cmd, err)
-		}
-
-		var name string
-		if local {
-			name = "default"
-		} else {
-			name = internal.ValidateDomain(cmd)
-		}
-
-		// NOTE(d1): reasonable 5 second timeout for connections which can't
-		// succeed. The connection is attempted twice, so this results in 10
-		// seconds.
-		timeout := client.WithTimeout(5)
-
-		if local {
-			created, err := createServerDir(name)
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			log.Debugf("attempting to create client for %s", name)
-
-			if _, err := client.New(name, timeout); err != nil {
-				cleanUp(name)
-				log.Fatal(err)
-			}
-
-			if created {
-				log.Info("local server successfully added")
-			} else {
-				log.Warn("local server already exists")
-			}
-
-			return nil
-		}
-
-		if _, err := dns.EnsureIPv4(name); err != nil {
-			log.Warn(err)
-		}
-
-		_, err := createServerDir(name)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		created, err := newContext(name)
-		if err != nil {
-			cleanUp(name)
-			log.Fatal(err)
-		}
-
-		log.Debugf("attempting to create client for %s", name)
-		if _, err := client.New(name, timeout); err != nil {
-			cleanUp(name)
-			log.Fatal(sshPkg.Fatal(name, err))
-		}
-
-		if created {
-			log.Infof("%s successfully added", name)
-		} else {
-			log.Warnf("%s already exists", name)
-		}
-
-		return nil
-	},
+func init() {
+	ServerAddCommand.Flags().BoolVarP(
+		&local,
+		"local",
+		"l",
+		false,
+		gotext.Get("use local server"),
+	)
 }

cli/server/list.go

@@ -1,7 +1,6 @@
 package server
 
 import (
-	"context"
 	"fmt"
 	"strings"
 
@@ -11,20 +10,16 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/cli/cli/connhelper/ssh"
-	"github.com/urfave/cli/v3"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
 )
 
-var serverListCommand = cli.Command{
-	Name:      "list",
-	Aliases:   []string{"ls"},
-	Usage:     "List managed servers",
-	UsageText: "abra server list [options]",
-	Flags: []cli.Flag{
-		internal.MachineReadableFlag,
-	},
-	Before:   internal.SubCommandBefore,
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
+var ServerListCommand = &cobra.Command{
+	Use:     gotext.Get("list [flags]"),
+	Aliases: []string{"ls"},
+	Short:   gotext.Get("List managed servers"),
+	Args:    cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
 		dockerContextStore := contextPkg.NewDefaultDockerContextStore()
 		contexts, err := dockerContextStore.Store.List()
 		if err != nil {
@@ -84,14 +79,26 @@ var serverListCommand = cli.Command{
 		if internal.MachineReadable {
 			out, err := formatter.ToJSON(headers, rows)
 			if err != nil {
-				log.Fatal("unable to render to JSON: %s", err)
+				log.Fatal(gotext.Get("unable to render to JSON: %s", err))
 			}
+
 			fmt.Println(out)
-			return nil
+
+			return
 		}
 
-		fmt.Println(table)
-
-		return nil
+		if err := formatter.PrintTable(table); err != nil {
+			log.Fatal(err)
+		}
 	},
 }
+
+func init() {
+	ServerListCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		"machine",
+		"m",
+		false,
+		gotext.Get("print machine-readable output"),
+	)
+}

cli/server/prune.go

@@ -1,100 +1,103 @@
 package server
 
 import (
-	"context"
-
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/urfave/cli/v3"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
 )
 
-var allFilter bool
+var ServerPruneCommand = &cobra.Command{
+	Use:     gotext.Get("prune <server> [flags]"),
+	Aliases: []string{"p"},
+	Short:   gotext.Get("Prune resources on a server"),
+	Long: gotext.Get(`Prunes unused containers, networks, and dangling images.
 
-var allFilterFlag = &cli.BoolFlag{
-	Name:        "all",
-	Aliases:     []string{"a"},
-	Usage:       "Remove all unused images not just dangling ones",
-	Destination: &allFilter,
-}
-
-var volumesFilter bool
-
-var volumesFilterFlag = &cli.BoolFlag{
-	Name:        "volumes",
-	Aliases:     []string{"v"},
-	Usage:       "Prune volumes. This will remove app data, Be Careful!",
-	Destination: &volumesFilter,
-}
-
-var serverPruneCommand = cli.Command{
-	Name:      "prune",
-	Aliases:   []string{"p"},
-	Usage:     "Prune resources on a server",
-	UsageText: "abra server prune <server> [options]",
-	Description: `Prunes unused containers, networks, and dangling images.
-
-Use "-v/--volumes" to remove volumes that are not associated with a deployed
-app. This can result in unwanted data loss if not used carefully.`,
-	Flags: []cli.Flag{
-		allFilterFlag,
-		volumesFilterFlag,
+Use "--volumes/-v" to remove volumes that are not associated with a deployed
+app. This can result in unwanted data loss if not used carefully.`),
+	Args: cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.ServerNameComplete()
 	},
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.ServerNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		serverName := internal.ValidateServer(cmd)
+	Run: func(cmd *cobra.Command, args []string) {
+		serverName := internal.ValidateServer(args)
 
 		cl, err := client.New(serverName)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		var args filters.Args
+		var filterArgs filters.Args
 
-		cr, err := cl.ContainersPrune(ctx, args)
+		cr, err := cl.ContainersPrune(cmd.Context(), filterArgs)
 		if err != nil {
 			log.Fatal(err)
 		}
 
 		cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
-		log.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
+		log.Info(gotext.Get("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed))
 
-		nr, err := cl.NetworksPrune(ctx, args)
+		nr, err := cl.NetworksPrune(cmd.Context(), filterArgs)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		log.Infof("networks pruned: %d", len(nr.NetworksDeleted))
+		log.Info(gotext.Get("networks pruned: %d", len(nr.NetworksDeleted)))
 
 		pruneFilters := filters.NewArgs()
 		if allFilter {
-			log.Debugf("removing all images, not only dangling ones")
+			log.Debug(gotext.Get("removing all images, not only dangling ones"))
 			pruneFilters.Add("dangling", "false")
 		}
 
-		ir, err := cl.ImagesPrune(ctx, pruneFilters)
+		ir, err := cl.ImagesPrune(cmd.Context(), pruneFilters)
 		if err != nil {
 			log.Fatal(err)
 		}
 
 		imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed)
-		log.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
+		log.Info(gotext.Get("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed))
 
 		if volumesFilter {
-			vr, err := cl.VolumesPrune(ctx, args)
+			vr, err := cl.VolumesPrune(cmd.Context(), filterArgs)
 			if err != nil {
 				log.Fatal(err)
 			}
 
 			volSpaceReclaimed := formatter.ByteCountSI(vr.SpaceReclaimed)
-			log.Infof("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed)
+			log.Info(gotext.Get("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed))
 		}
 
-		return nil
+		return
 	},
 }
+
+var (
+	allFilter     bool
+	volumesFilter bool
+)
+
+func init() {
+	ServerPruneCommand.Flags().BoolVarP(
+		&allFilter,
+		"all",
+		"a",
+		false,
+		gotext.Get("remove all unused images"),
+	)
+
+	ServerPruneCommand.Flags().BoolVarP(
+		&volumesFilter,
+		"volumes",
+		"v",
+		false,
+		gotext.Get("remove volumes"),
+	)
+}

cli/server/remove.go

@@ -1,7 +1,6 @@
 package server
 
 import (
-	"context"
 	"os"
 	"path/filepath"
 
@@ -10,24 +9,28 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v3"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
 )
 
-var serverRemoveCommand = cli.Command{
-	Name:      "remove",
-	Aliases:   []string{"rm"},
-	UsageText: "abra server remove <domain> [options]",
-	Usage:     "Remove a managed server",
-	Description: `Remove a managed server.
+var ServerRemoveCommand = &cobra.Command{
+	Use:     gotext.Get("remove <server> [flags]"),
+	Aliases: []string{"rm"},
+	Short:   gotext.Get("Remove a managed server"),
+	Long: gotext.Get(`Remove a managed server.
 
 Abra will remove the internal bookkeeping ($ABRA_DIR/servers/...) and
 underlying client connection context. This server will then be lost in time,
-like tears in rain.`,
-	Before:        internal.SubCommandBefore,
-	ShellComplete: autocomplete.ServerNameComplete,
-	HideHelp:      true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		serverName := internal.ValidateServer(cmd)
+like tears in rain.`),
+	Args: cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.ServerNameComplete()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		serverName := internal.ValidateServer(args)
 
 		if err := client.DeleteContext(serverName); err != nil {
 			log.Fatal(err)
@@ -37,8 +40,8 @@ like tears in rain.`,
 			log.Fatal(err)
 		}
 
-		log.Infof("%s is now lost in time, like tears in rain", serverName)
+		log.Info(gotext.Get("%s is now lost in time, like tears in rain", serverName))
 
-		return nil
+		return
 	},
 }

cli/server/server.go

@@ -1,19 +1,13 @@
 package server
 
 import (
-	"github.com/urfave/cli/v3"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
 )
 
 // ServerCommand defines the `abra server` command and its subcommands
-var ServerCommand = cli.Command{
-	Name:      "server",
-	Aliases:   []string{"s"},
-	Usage:     "Manage servers",
-	UsageText: "abra server [command] [arguments] [options]",
-	Commands: []*cli.Command{
-		&serverAddCommand,
-		&serverListCommand,
-		&serverRemoveCommand,
-		&serverPruneCommand,
-	},
+var ServerCommand = &cobra.Command{
+	Use:     gotext.Get("server [cmd] [args] [flags]"),
+	Aliases: []string{"s"},
+	Short:   gotext.Get("Manage servers"),
 }

cli/updater/updater.go

@@ -2,6 +2,7 @@ package updater
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strconv"
@@ -21,46 +22,26 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	dockerclient "github.com/docker/docker/client"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
 
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v3"
 )
 
 const SERVER = "localhost"
 
-var majorUpdate bool
-var majorFlag = &cli.BoolFlag{
-	Name:        "major",
-	Aliases:     []string{"m"},
-	Usage:       "Also check for major updates",
-	Destination: &majorUpdate,
-}
-
-var updateAll bool
-var allFlag = &cli.BoolFlag{
-	Name:        "all",
-	Aliases:     []string{"a"},
-	Usage:       "Update all deployed apps",
-	Destination: &updateAll,
-}
-
-// Notify checks for available upgrades
-var Notify = cli.Command{
-	Name:      "notify",
-	Aliases:   []string{"n"},
-	Usage:     "Check for available upgrades",
-	UsageText: "kadabra notify [options]",
-	Flags: []cli.Flag{
-		majorFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `Notify on new versions for deployed apps.
+// NotifyCommand checks for available upgrades.
+var NotifyCommand = &cobra.Command{
+	Use:     gotext.Get("notify [flags]"),
+	Aliases: []string{"n"},
+	Short:   gotext.Get("Check for available upgrades"),
+	Long: gotext.Get(`Notify on new versions for deployed apps.
 
 If a new patch/minor version is available, a notification is printed.
 
-Use "--major" to include new major versions.`,
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
+Use "--major/-m" to include new major versions.`),
+	Args: cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
 		cl, err := client.New("default")
 		if err != nil {
 			log.Fatal(err)
@@ -85,24 +66,15 @@ Use "--major" to include new major versions.`,
 				}
 			}
 		}
-
-		return nil
 	},
 }
 
-// UpgradeApp upgrades apps.
-var UpgradeApp = cli.Command{
-	Name:      "upgrade",
-	Aliases:   []string{"u"},
-	Usage:     "Upgrade apps",
-	UsageText: "kadabra notify <stack> <recipe> [options]",
-	Flags: []cli.Flag{
-		internal.ChaosFlag,
-		majorFlag,
-		allFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `Upgrade an app by specifying stack name and recipe. 
+// UpgradeCommand upgrades apps.
+var UpgradeCommand = &cobra.Command{
+	Use:     gotext.Get("upgrade [[stack] [recipe] | --all] [flags]"),
+	Aliases: []string{"u"},
+	Short:   gotext.Get("Upgrade apps"),
+	Long: gotext.Get(`Upgrade an app by specifying stack name and recipe. 
 
 Use "--all" to upgrade every deployed app.
 
@@ -110,25 +82,37 @@ For each app with auto updates enabled, the deployed version is compared with
 the current recipe catalogue version. If a new patch/minor version is
 available, the app is upgraded.
 
-To include major versions use the "--major" flag. You probably don't want that
-as it will break things. Only apps that are not deployed with "--chaos" are
-upgraded, to update chaos deployments use the "--chaos" flag. Use it with care.`,
-	HideHelp: true,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
+To include major versions use the "--major/-m" flag. You probably don't want
+that as it will break things. Only apps that are not deployed with "--chaos/-C"
+are upgraded, to update chaos deployments use the "--chaos/-C" flag. Use it
+with care.`),
+	Args: cobra.RangeArgs(0, 2),
+	// TODO(d1): complete stack/recipe
+	// ValidArgsFunction: func(
+	// 	cmd *cobra.Command,
+	// 	args []string,
+	// 	toComplete string) ([]string, cobra.ShellCompDirective) {
+	// },
+	Run: func(cmd *cobra.Command, args []string) {
 		cl, err := client.New("default")
 		if err != nil {
 			log.Fatal(err)
 		}
 
+		if !updateAll && len(args) != 2 {
+			log.Fatal(gotext.Get("missing arguments or --all/-a flag"))
+		}
+
 		if !updateAll {
-			stackName := cmd.Args().Get(0)
-			recipeName := cmd.Args().Get(1)
+			stackName := args[0]
+			recipeName := args[1]
+
 			err = tryUpgrade(cl, stackName, recipeName)
 			if err != nil {
 				log.Fatal(err)
 			}
 
-			return nil
+			return
 		}
 
 		stacks, err := stack.GetStacks(cl)
@@ -148,8 +132,6 @@ upgraded, to update chaos deployments use the "--chaos" flag. Use it with care.`
 				log.Fatal(err)
 			}
 		}
-
-		return nil
 	},
 }
 
@@ -170,7 +152,7 @@ func getLabel(cl *dockerclient.Client, stackName string, label string) (string,
 		}
 	}
 
-	log.Debugf("no %s label found for %s", label, stackName)
+	log.Debug(gotext.Get("no %s label found for %s", label, stackName))
 
 	return "", nil
 }
@@ -191,7 +173,7 @@ func getBoolLabel(cl *dockerclient.Client, stackName string, label string) (bool
 		return value, nil
 	}
 
-	log.Debugf("boolean label %s could not be found for %s, set default to false.", label, stackName)
+	log.Debug(gotext.Get("boolean label %s could not be found for %s, set default to false.", label, stackName))
 
 	return false, nil
 }
@@ -212,12 +194,12 @@ func getEnv(cl *dockerclient.Client, stackName string) (envfile.AppEnv, error) {
 		for _, envString := range envList {
 			splitString := strings.SplitN(envString, "=", 2)
 			if len(splitString) != 2 {
-				log.Debugf("can't separate key from value: %s (this variable is probably unset)", envString)
+				log.Debug(gotext.Get("can't separate key from value: %s (this variable is probably unset)", envString))
 				continue
 			}
 			k := splitString[0]
 			v := splitString[1]
-			log.Debugf("for %s read env %s with value: %s from docker service", stackName, k, v)
+			log.Debugf(gotext.Get("for %s read env %s with value: %s from docker service", stackName, k, v))
 			envMap[k] = v
 		}
 	}
@@ -239,14 +221,14 @@ func getLatestUpgrade(cl *dockerclient.Client, stackName string, recipeName stri
 	}
 
 	if len(availableUpgrades) == 0 {
-		log.Debugf("no available upgrades for %s", stackName)
+		log.Debugf(gotext.Get("no available upgrades for %s", stackName))
 		return "", nil
 	}
 
 	var chosenUpgrade string
 	if len(availableUpgrades) > 0 {
 		chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
-		log.Infof("%s (%s) can be upgraded from version %s to %s", stackName, recipeName, deployedVersion, chosenUpgrade)
+		log.Info(gotext.Get("%s (%s) can be upgraded from version %s to %s", stackName, recipeName, deployedVersion, chosenUpgrade))
 	}
 
 	return chosenUpgrade, nil
@@ -254,7 +236,7 @@ func getLatestUpgrade(cl *dockerclient.Client, stackName string, recipeName stri
 
 // getDeployedVersion returns the currently deployed version of an app.
 func getDeployedVersion(cl *dockerclient.Client, stackName string, recipeName string) (string, error) {
-	log.Debugf("retrieve deployed version whether %s is already deployed", stackName)
+	log.Debug(gotext.Get("retrieve deployed version whether %s is already deployed", stackName))
 
 	deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 	if err != nil {
@@ -262,11 +244,11 @@ func getDeployedVersion(cl *dockerclient.Client, stackName string, recipeName st
 	}
 
 	if !deployMeta.IsDeployed {
-		return "", fmt.Errorf("%s is not deployed?", stackName)
+		return "", errors.New(gotext.Get("%s is not deployed?", stackName))
 	}
 
 	if deployMeta.Version == "unknown" {
-		return "", fmt.Errorf("failed to determine deployed version of %s", stackName)
+		return "", errors.New(gotext.Get("failed to determine deployed version of %s", stackName))
 	}
 
 	return deployMeta.Version, nil
@@ -288,7 +270,7 @@ func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName
 	}
 
 	if len(versions) == 0 {
-		log.Warnf("no published releases for %s in the recipe catalogue?", recipeName)
+		log.Warn(gotext.Get("no published releases for %s in the recipe catalogue?", recipeName))
 		return nil, nil
 	}
 
@@ -309,12 +291,12 @@ func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName
 			return nil, err
 		}
 
-		if 0 < versionDelta.UpgradeType() && (versionDelta.UpgradeType() < 4 || majorUpdate) {
+		if 0 < versionDelta.UpgradeType() && (versionDelta.UpgradeType() < 4 || includeMajorUpdates) {
 			availableUpgrades = append(availableUpgrades, version)
 		}
 	}
 
-	log.Debugf("available updates for %s: %s", stackName, availableUpgrades)
+	log.Debug(gotext.Get("available updates for %s: %s", stackName, availableUpgrades))
 
 	return availableUpgrades, nil
 }
@@ -461,52 +443,110 @@ func upgrade(cl *dockerclient.Client, stackName, recipeName, upgradeVersion stri
 
 	log.Infof("upgrade %s (%s) to version %s", stackName, recipeName, upgradeVersion)
 
-	err = stack.RunDeploy(cl, deployOpts, compose, stackName, true)
+	serviceNames, err := appPkg.GetAppServiceNames(app.Name)
+	if err != nil {
+		return err
+	}
+
+	f, err := app.Filters(true, false, serviceNames...)
+	if err != nil {
+		return err
+	}
+
+	err = stack.RunDeploy(
+		cl,
+		deployOpts,
+		compose,
+		stackName,
+		app.Server,
+		true,
+		f,
+	)
 
 	return err
 }
 
-func newKadabraApp(version, commit string) *cli.Command {
-	app := &cli.Command{
-		Name:                   "kadabra",
-		Version:                fmt.Sprintf("%s-%s", version, commit[:7]),
-		Usage:                  "The Co-op Cloud auto-updater 🤖 🚀",
-		UsageText:              "kadabra [command] [options]",
-		UseShortOptionHandling: true,
-		HideHelpCommand:        true,
-		Flags: []cli.Flag{
-			// NOTE(d1): "GLOBAL OPTIONS" flags
-			internal.DebugFlag,
-		},
-		Commands: []*cli.Command{
-			&Notify,
-			&UpgradeApp,
+func newKadabraApp(version, commit string) *cobra.Command {
+	rootCmd := &cobra.Command{
+		Use:     "kadabra [cmd] [flags]",
+		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
+		Short:   "The Co-op Cloud auto-updater 🤖 🚀",
+		PersistentPreRun: func(cmd *cobra.Command, args []string) {
+			log.Logger.SetStyles(charmLog.DefaultStyles())
+			charmLog.SetDefault(log.Logger)
+
+			if internal.Debug {
+				log.SetLevel(log.DebugLevel)
+				log.SetOutput(os.Stderr)
+				log.SetReportCaller(true)
+			}
+
+			log.Debugf("kadabra version %s, commit %s", version, commit)
 		},
 	}
 
-	app.Before = func(ctx context.Context, cmd *cli.Command) error {
-		log.Logger.SetStyles(log.Styles())
-		charmLog.SetDefault(log.Logger)
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.Debug, "debug", "d", false,
+		"show debug messages",
+	)
 
-		log.Debugf("kadabra version %s, commit %s", version, commit)
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.NoInput, "no-input", "n", false,
+		"toggle non-interactive mode",
+	)
 
-		return nil
-	}
+	rootCmd.AddCommand(
+		NotifyCommand,
+		UpgradeCommand,
+	)
 
-	cli.HelpFlag = &cli.BoolFlag{
-		Name:    "help",
-		Aliases: []string{"h, H"},
-		Usage:   "Show help",
-	}
-
-	return app
+	return rootCmd
 }
 
 // RunApp runs CLI abra app.
 func RunApp(version, commit string) {
 	app := newKadabraApp(version, commit)
 
-	if err := app.Run(context.Background(), os.Args); err != nil {
+	if err := app.Execute(); err != nil {
 		log.Fatal(err)
 	}
 }
+
+var (
+	includeMajorUpdates bool
+	updateAll           bool
+)
+
+func init() {
+	NotifyCommand.Flags().BoolVarP(
+		&includeMajorUpdates,
+		"major",
+		"m",
+		false,
+		"check for major updates",
+	)
+
+	UpgradeCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		"chaos",
+		"C",
+		false,
+		"ignore uncommitted recipes changes",
+	)
+
+	UpgradeCommand.Flags().BoolVarP(
+		&includeMajorUpdates,
+		"major",
+		"m",
+		false,
+		"check for major updates",
+	)
+
+	UpgradeCommand.Flags().BoolVarP(
+		&updateAll,
+		"all",
+		"a",
+		false,
+		"update all deployed apps",
+	)
+}

cli/upgrade.go

@@ -0,0 +1,57 @@
+// Package cli provides the interface for the command-line.
+package cli
+
+import (
+	"fmt"
+	"os/exec"
+
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
+)
+
+// UpgradeCommand upgrades abra in-place.
+var UpgradeCommand = &cobra.Command{
+	Use:     gotext.Get("upgrade [flags]"),
+	Aliases: []string{"u"},
+	Short:   gotext.Get("Upgrade abra"),
+	Long: gotext.Get(`Upgrade abra in-place with the latest stable or release candidate.
+
+By default, the latest stable release is downloaded.
+
+Use "--rc/-r" to install the latest release candidate. Please bear in mind that
+it may contain absolutely catastrophic deal-breaker bugs. Thank you very much
+for the testing efforts 💗`),
+	Example: gotext.Get("  abra upgrade --rc"),
+	Args:    cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
+		mainURL := "https://install.abra.coopcloud.tech"
+		c := exec.Command("bash", "-c", fmt.Sprintf("wget -q -O- %s | bash", mainURL))
+
+		if releaseCandidate {
+			releaseCandidateURL := "https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/installer/installer"
+			c = exec.Command("bash", "-c", fmt.Sprintf("wget -q -O- %s | bash -s -- --rc", releaseCandidateURL))
+		}
+
+		log.Debugf(gotext.Get("attempting to run %s", c))
+
+		if err := internal.RunCmd(c); err != nil {
+			log.Fatal(err)
+		}
+	},
+}
+
+var (
+	releaseCandidate bool
+)
+
+func init() {
+	UpgradeCommand.Flags().BoolVarP(
+		&releaseCandidate,
+		"rc",
+		"r",
+		false,
+		gotext.Get("install release candidate (may contain bugs)"),
+	)
+}

cmd/abra/main.go

@@ -19,5 +19,5 @@ func main() {
 		Commit = "       "
 	}
 
-	cli.RunApp(Version, Commit)
+	cli.Run(Version, Commit)
 }

go.mod

@@ -1,139 +1,163 @@
 module coopcloud.tech/abra
 
-go 1.21
+go 1.24.0
 
-replace github.com/urfave/cli/v3 => github.com/urfave/cli/v3 v3.0.0-alpha9.1.0.20241019193437-5053ec708a44
+toolchain go1.24.1
 
 require (
-	coopcloud.tech/tagcmp v0.0.0-20230809071031-eb3e7758d4eb
-	git.coopcloud.tech/coop-cloud/godotenv v1.5.2-0.20231130100509-01bff8284355
+	coopcloud.tech/tagcmp v0.0.0-20250818180036-0ec1b205b5ca
+	git.coopcloud.tech/toolshed/godotenv v1.5.2-0.20250103171850-4d0ca41daa5c
 	github.com/AlecAivazis/survey/v2 v2.3.7
-	github.com/charmbracelet/lipgloss v0.11.1
-	github.com/charmbracelet/log v0.4.0
+	github.com/charmbracelet/bubbletea v1.3.6
+	github.com/charmbracelet/lipgloss v1.1.0
+	github.com/charmbracelet/log v0.4.2
 	github.com/distribution/reference v0.6.0
-	github.com/docker/cli v27.0.3+incompatible
-	github.com/docker/docker v27.0.3+incompatible
+	github.com/docker/cli v28.3.3+incompatible
+	github.com/docker/docker v28.3.3+incompatible
 	github.com/docker/go-units v0.5.0
-	github.com/go-git/go-git/v5 v5.12.0
-	github.com/google/go-cmp v0.6.0
-	github.com/moby/sys/signal v0.7.0
-	github.com/moby/term v0.5.0
+	github.com/go-git/go-git/v5 v5.16.2
+	github.com/google/go-cmp v0.7.0
+	github.com/leonelquinteros/gotext v1.7.2
+	github.com/moby/sys/signal v0.7.1
+	github.com/moby/term v0.5.2
 	github.com/pkg/errors v0.9.1
-	github.com/schollz/progressbar/v3 v3.14.4
-	github.com/urfave/cli/v3 v3.0.0-alpha9
-	golang.org/x/term v0.22.0
+	github.com/schollz/progressbar/v3 v3.18.0
+	golang.org/x/term v0.34.0
 	gopkg.in/yaml.v3 v3.0.1
-	gotest.tools/v3 v3.5.1
+	gotest.tools/v3 v3.5.2
 )
 
 require (
-	dario.cat/mergo v1.0.0 // indirect
-	github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 // indirect
-	github.com/BurntSushi/toml v1.4.0 // indirect
+	dario.cat/mergo v1.0.2 // indirect
+	github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 // indirect
+	github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect
+	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/Microsoft/go-winio v0.6.2 // indirect
-	github.com/ProtonMail/go-crypto v1.0.0 // indirect
+	github.com/ProtonMail/go-crypto v1.3.0 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
+	github.com/cenkalti/backoff/v5 v5.0.3 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/charmbracelet/x/ansi v0.1.3 // indirect
-	github.com/cloudflare/circl v1.3.9 // indirect
+	github.com/charmbracelet/colorprofile v0.3.2 // indirect
+	github.com/charmbracelet/x/ansi v0.10.1 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.13 // indirect
+	github.com/charmbracelet/x/term v0.2.1 // indirect
+	github.com/cloudflare/circl v1.6.1 // indirect
+	github.com/containerd/errdefs v1.0.0 // indirect
+	github.com/containerd/errdefs/pkg v0.3.0 // indirect
 	github.com/containerd/log v0.1.0 // indirect
-	github.com/cyphar/filepath-securejoin v0.2.5 // indirect
+	github.com/containerd/platforms v0.2.1 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
+	github.com/cyphar/filepath-securejoin v0.4.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/docker/distribution v2.8.3+incompatible // indirect
 	github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c // indirect
-	github.com/docker/go-connections v0.5.0 // indirect
+	github.com/docker/go-connections v0.6.0 // indirect
 	github.com/docker/go-metrics v0.0.1 // indirect
 	github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/ghodss/yaml v1.0.0 // indirect
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
-	github.com/go-git/go-billy/v5 v5.5.0 // indirect
+	github.com/go-git/go-billy/v5 v5.6.2 // indirect
 	github.com/go-logfmt/logfmt v0.6.0 // indirect
-	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/go-viper/mapstructure/v2 v2.0.0 // indirect
+	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1 // indirect
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/kevinburke/ssh_config v1.2.0 // indirect
-	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.15 // indirect
+	github.com/mattn/go-localereader v0.0.1 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
 	github.com/miekg/pkcs11 v1.1.1 // indirect
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/moby/docker-image-spec v1.3.1 // indirect
-	github.com/moby/sys/user v0.1.0 // indirect
+	github.com/moby/go-archive v0.1.0 // indirect
+	github.com/moby/sys/atomicwriter v0.1.0 // indirect
+	github.com/moby/sys/mountinfo v0.7.2 // indirect
+	github.com/moby/sys/user v0.4.0 // indirect
+	github.com/moby/sys/userns v0.1.0 // indirect
 	github.com/morikuni/aec v1.0.0 // indirect
-	github.com/muesli/termenv v0.15.2 // indirect
+	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
 	github.com/opencontainers/runc v1.1.13 // indirect
-	github.com/pjbgf/sha1cd v0.3.0 // indirect
+	github.com/opencontainers/runtime-spec v1.1.0 // indirect
+	github.com/pelletier/go-toml v1.9.5 // indirect
+	github.com/pjbgf/sha1cd v0.4.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.55.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/prometheus/client_model v0.6.2 // indirect
+	github.com/prometheus/common v0.65.0 // indirect
+	github.com/prometheus/procfs v0.17.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
-	github.com/skeema/knownhosts v1.2.2 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/skeema/knownhosts v1.3.1 // indirect
+	github.com/spf13/pflag v1.0.7 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
 	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 // indirect
-	go.opentelemetry.io/otel v1.28.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 // indirect
-	go.opentelemetry.io/otel/metric v1.28.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.28.0 // indirect
-	go.opentelemetry.io/otel/sdk/metric v1.28.0 // indirect
-	go.opentelemetry.io/otel/trace v1.28.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
-	golang.org/x/crypto v0.25.0 // indirect
-	golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 // indirect
-	golang.org/x/net v0.27.0 // indirect
-	golang.org/x/sync v0.7.0 // indirect
-	golang.org/x/text v0.16.0 // indirect
-	golang.org/x/time v0.5.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect
-	google.golang.org/grpc v1.65.0 // indirect
-	google.golang.org/protobuf v1.34.2 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0 // indirect
+	go.opentelemetry.io/otel v1.37.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.37.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0 // indirect
+	go.opentelemetry.io/otel/metric v1.37.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
+	go.opentelemetry.io/otel/sdk/metric v1.37.0 // indirect
+	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.7.1 // indirect
+	golang.org/x/crypto v0.41.0 // indirect
+	golang.org/x/exp v0.0.0-20250813145105-42675adae3e6 // indirect
+	golang.org/x/net v0.43.0 // indirect
+	golang.org/x/sync v0.16.0 // indirect
+	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/time v0.12.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250811230008-5f3141c8851a // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a // indirect
+	google.golang.org/grpc v1.74.2 // indirect
+	google.golang.org/protobuf v1.36.7 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 
 require (
-	github.com/containerd/containerd v1.7.19 // indirect
 	github.com/containers/image v3.0.2+incompatible
 	github.com/containers/storage v1.38.2 // indirect
 	github.com/decentral1se/passgen v1.0.1
-	github.com/docker/docker-credential-helpers v0.8.2 // indirect
+	github.com/docker/docker-credential-helpers v0.9.3 // indirect
 	github.com/fvbommel/sortorder v1.1.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/gorilla/mux v1.8.1 // indirect
-	github.com/hashicorp/go-retryablehttp v0.7.7
+	github.com/hashicorp/go-retryablehttp v0.7.8
 	github.com/moby/patternmatcher v0.6.0 // indirect
-	github.com/moby/sys/sequential v0.5.0 // indirect
-	github.com/opencontainers/image-spec v1.1.0 // indirect
-	github.com/prometheus/client_golang v1.19.1 // indirect
-	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
-	github.com/spf13/cobra v1.8.1 // indirect
-	github.com/stretchr/testify v1.9.0
+	github.com/moby/sys/sequential v0.6.0 // indirect
+	github.com/opencontainers/image-spec v1.1.1 // indirect
+	github.com/prometheus/client_golang v1.23.0 // indirect
+	github.com/sergi/go-diff v1.4.0 // indirect
+	github.com/spf13/cobra v1.9.1
+	github.com/stretchr/testify v1.10.0
 	github.com/theupdateframework/notary v0.7.0 // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
-	golang.org/x/sys v0.22.0
+	golang.org/x/sys v0.35.0
 )

go.sum

@@ -24,19 +24,27 @@ cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0Zeo
 cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
 coopcloud.tech/tagcmp v0.0.0-20230809071031-eb3e7758d4eb h1:Ws6WEwKXeaYEkfdkX6AqX1XLPuaCeyStEtxbmEJPllk=
 coopcloud.tech/tagcmp v0.0.0-20230809071031-eb3e7758d4eb/go.mod h1:ESVm0wQKcbcFi06jItF3rI7enf4Jt2PvbkWpDDHk1DQ=
-dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
-dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
+coopcloud.tech/tagcmp v0.0.0-20250427094623-9ea3bbbde8e5 h1:tphJCjFJw9fdjyKnbU0f7f3z5KtYE8VbUcAfu+oHKg8=
+coopcloud.tech/tagcmp v0.0.0-20250427094623-9ea3bbbde8e5/go.mod h1:ESVm0wQKcbcFi06jItF3rI7enf4Jt2PvbkWpDDHk1DQ=
+coopcloud.tech/tagcmp v0.0.0-20250818180036-0ec1b205b5ca h1:gSD53tBAsbIGq4SnFfq+mEep6foekQ2a5ea7b38qkm0=
+coopcloud.tech/tagcmp v0.0.0-20250818180036-0ec1b205b5ca/go.mod h1:ESVm0wQKcbcFi06jItF3rI7enf4Jt2PvbkWpDDHk1DQ=
+dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s=
+dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
+dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
+dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-git.coopcloud.tech/coop-cloud/godotenv v1.5.2-0.20231130100509-01bff8284355 h1:tCv2B4qoN6RMheKDnCzIafOkWS5BB1h7hwhmo+9bVeE=
-git.coopcloud.tech/coop-cloud/godotenv v1.5.2-0.20231130100509-01bff8284355/go.mod h1:Q8V1zbtPAlzYSr/Dvky3wS6x58IQAl3rot2me1oSO2Q=
+git.coopcloud.tech/toolshed/godotenv v1.5.2-0.20250103171850-4d0ca41daa5c h1:oeKnUB79PKYD8D0/unYuu7MRcWryQQWOns8+JL+acrs=
+git.coopcloud.tech/toolshed/godotenv v1.5.2-0.20250103171850-4d0ca41daa5c/go.mod h1:fQuhwrpg6qb9NlFXKYi/LysWu1wxjraS8sxyW12CUF0=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 h1:bvDV9vkmnHYOMsOr4WLk+Vo07yKIzd94sVoIqshQ4bU=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8=
+github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 h1:He8afgbRMd7mFxO99hRNu+6tazq8nFF9lIwo9JFroBk=
+github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8=
 github.com/AlecAivazis/survey/v2 v2.3.7 h1:6I/u8FvytdGsgonrYsVn2t8t4QiRnh6QSTqkkhIiSjQ=
 github.com/AlecAivazis/survey/v2 v2.3.7/go.mod h1:xUTIdE4KCOIjsBAE1JYsUPoCqYdZ1reCfTwbto0Fduo=
 github.com/Azure/azure-sdk-for-go v16.2.1+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
 github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8=
-github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
-github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg=
+github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
 github.com/Azure/go-autorest v10.8.1+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
 github.com/Azure/go-autorest v14.2.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
 github.com/Azure/go-autorest/autorest v0.11.1/go.mod h1:JFgpikqFJ/MleTTxwepExTKnFUKKszPS8UavbQYUMuw=
@@ -51,6 +59,8 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03
 github.com/BurntSushi/toml v1.0.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=
 github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
+github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/Microsoft/go-winio v0.4.11/go.mod h1:VhR8bwka0BXejwEJY73c50VrPtXAaKcyvVC4A4RozmA=
 github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA=
@@ -79,8 +89,10 @@ github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb0
 github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63nhn5WAunQHLTznkw5W8b1Xc0dNjp83s=
 github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/ProtonMail/go-crypto v1.0.0 h1:LRuvITjQWX+WIfr930YHG2HNfjR1uOfyf5vE0kC2U78=
-github.com/ProtonMail/go-crypto v1.0.0/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0=
+github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw=
+github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
+github.com/ProtonMail/go-crypto v1.3.0 h1:ILq8+Sf5If5DCpHQp4PbZdS1J7HDFRXz/+xKBiRGFrw=
+github.com/ProtonMail/go-crypto v1.3.0/go.mod h1:9whxjD8Rbs29b4XWbB8irEcE8KHMqaR2e7GWU1R+/PE=
 github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
 github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
 github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
@@ -103,6 +115,8 @@ github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:l
 github.com/aws/aws-sdk-go v1.15.11/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
+github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
 github.com/beorn7/perks v0.0.0-20150223135152-b965b613227f/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v0.0.0-20160804104726-4c0e84591b9a/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
@@ -125,24 +139,48 @@ github.com/bugsnag/osext v0.0.0-20130617224835-0dd3f918b21b h1:otBG+dV+YK+Soembj
 github.com/bugsnag/osext v0.0.0-20130617224835-0dd3f918b21b/go.mod h1:obH5gd0BsqsP2LwDJ9aOkm/6J86V6lyAXCoQWGw3K50=
 github.com/bugsnag/panicwrap v0.0.0-20151223152923-e2c28503fcd0 h1:nvj0OLI3YqYXer/kZD8Ri1aaunCxIEsOst1BVJswV0o=
 github.com/bugsnag/panicwrap v0.0.0-20151223152923-e2c28503fcd0/go.mod h1:D/8v3kj0zr8ZAKg1AQ6crr+5VwKN5eIywRkfhyM/+dE=
-github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
 github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw=
 github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
 github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
+github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
+github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/charmbracelet/lipgloss v0.11.1 h1:a8KgVPHa7kOoP95vm2tQQrjD2AKhbWmfr4uJ2RW6kNk=
-github.com/charmbracelet/lipgloss v0.11.1/go.mod h1:beLlcmkF7MWA+5UrKKIRo/VJ21xGXr7YJ9miWfdMRIU=
-github.com/charmbracelet/log v0.4.0 h1:G9bQAcx8rWA2T3pWvx7YtPTPwgqpk7D68BX21IRW8ZM=
-github.com/charmbracelet/log v0.4.0/go.mod h1:63bXt/djrizTec0l11H20t8FDSvA4CRZJ1KH22MdptM=
-github.com/charmbracelet/x/ansi v0.1.3 h1:RBh/eleNWML5R524mjUF0yVRePTwqN9tPtV+DPgO5Lw=
-github.com/charmbracelet/x/ansi v0.1.3/go.mod h1:dk73KoMTT5AX5BsX0KrqhsTqAnhZZoCBjs7dGWp4Ktw=
+github.com/charmbracelet/bubbletea v1.3.4 h1:kCg7B+jSCFPLYRA52SDZjr51kG/fMUEoPoZrkaDHyoI=
+github.com/charmbracelet/bubbletea v1.3.4/go.mod h1:dtcUCyCGEX3g9tosuYiut3MXgY/Jsv9nKVdibKKRRXo=
+github.com/charmbracelet/bubbletea v1.3.6 h1:VkHIxPJQeDt0aFJIsVxw8BQdh/F/L2KKZGsK6et5taU=
+github.com/charmbracelet/bubbletea v1.3.6/go.mod h1:oQD9VCRQFF8KplacJLo28/jofOI2ToOfGYeFgBBxHOc=
+github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
+github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
+github.com/charmbracelet/colorprofile v0.3.1 h1:k8dTHMd7fgw4bnFd7jXTLZrSU/CQrKnL3m+AxCzDz40=
+github.com/charmbracelet/colorprofile v0.3.1/go.mod h1:/GkGusxNs8VB/RSOh3fu0TJmQ4ICMMPApIIVn0KszZ0=
+github.com/charmbracelet/colorprofile v0.3.2 h1:9J27WdztfJQVAQKX2WOlSSRB+5gaKqqITmrvb1uTIiI=
+github.com/charmbracelet/colorprofile v0.3.2/go.mod h1:mTD5XzNeWHj8oqHb+S1bssQb7vIHbepiebQ2kPKVKbI=
+github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
+github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
+github.com/charmbracelet/log v0.4.1 h1:6AYnoHKADkghm/vt4neaNEXkxcXLSV2g1rdyFDOpTyk=
+github.com/charmbracelet/log v0.4.1/go.mod h1:pXgyTsqsVu4N9hGdHmQ0xEA4RsXof402LX9ZgiITn2I=
+github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
+github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
+github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE=
+github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q=
+github.com/charmbracelet/x/ansi v0.10.1 h1:rL3Koar5XvX0pHGfovN03f5cxLbCF2YvLeyz7D2jVDQ=
+github.com/charmbracelet/x/ansi v0.10.1/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
+github.com/charmbracelet/x/cellbuf v0.0.13 h1:/KBBKHuVRbq1lYx5BzEHBAFBP8VcQzJejZ/IA3iR28k=
+github.com/charmbracelet/x/cellbuf v0.0.13/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
+github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a h1:G99klV19u0QnhiizODirwVksQB91TJKV/UaTnACcG30=
+github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
+github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
+github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
 github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw=
 github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M=
 github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E=
+github.com/chengxilo/virtualterm v1.0.4 h1:Z6IpERbRVlfB8WkOmtbHiDbBANU7cimRIof7mk9/PwM=
+github.com/chengxilo/virtualterm v1.0.4/go.mod h1:DyxxBZz/x1iqJjFxTFcr6/x+jSpqN0iwWCOK1q10rlY=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
@@ -155,9 +193,10 @@ github.com/cilium/ebpf v0.7.0/go.mod h1:/oI2+1shJiTGAMgl6/RgJr36Eo1jzrRcAWbcXO2u
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cloudflare/cfssl v0.0.0-20180223231731-4e2dcbde5004 h1:lkAMpLVBDaj17e85keuznYcH5rqI438v41pKcBl4ZxQ=
 github.com/cloudflare/cfssl v0.0.0-20180223231731-4e2dcbde5004/go.mod h1:yMWuSON2oQp+43nFtAV/uvKQIFpSPerB57DCt9t8sSA=
-github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=
-github.com/cloudflare/circl v1.3.9 h1:QFrlgFYf2Qpi8bSpVPK1HBvWpx16v/1TZivyo7pGuBE=
-github.com/cloudflare/circl v1.3.9/go.mod h1:PDRU+oXvdD7KCtgKxW95M5Z8BpSCJXQORiZFnBQS5QU=
+github.com/cloudflare/circl v1.6.0 h1:cr5JKic4HI+LkINy2lg3W2jF8sHCVTBncJr5gIIq7qk=
+github.com/cloudflare/circl v1.6.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
+github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0=
+github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
@@ -196,8 +235,6 @@ github.com/containerd/containerd v1.5.0-beta.4/go.mod h1:GmdgZd2zA2GYIBZ0w09Zvgq
 github.com/containerd/containerd v1.5.0-rc.0/go.mod h1:V/IXoMqNGgBlabz3tHD2TWDoTJseu1FGOKuoA4nNb2s=
 github.com/containerd/containerd v1.5.1/go.mod h1:0DOxVqwDy2iZvrZp2JUx/E+hS0UNTVn7dJnIOwtYR4g=
 github.com/containerd/containerd v1.5.7/go.mod h1:gyvv6+ugqY25TiXxcZC3L5yOeYgEw0QMhscqVp1AR9c=
-github.com/containerd/containerd v1.7.19 h1:/xQ4XRJ0tamDkdzrrBAUy/LE5nCcxFKdBm4EcPrSMEE=
-github.com/containerd/containerd v1.7.19/go.mod h1:h4FtNYUUMB4Phr6v+xG89RYKj9XccvbNSCKjdufCrkc=
 github.com/containerd/continuity v0.0.0-20190426062206-aaeac12a7ffc/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
 github.com/containerd/continuity v0.0.0-20190815185530-f2a389ac0a02/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
 github.com/containerd/continuity v0.0.0-20191127005431-f65d91d395eb/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
@@ -205,6 +242,10 @@ github.com/containerd/continuity v0.0.0-20200710164510-efbc4488d8fe/go.mod h1:cE
 github.com/containerd/continuity v0.0.0-20201208142359-180525291bb7/go.mod h1:kR3BEg7bDFaEddKm54WSmrol1fKWDU1nKYkgrcgZT7Y=
 github.com/containerd/continuity v0.0.0-20210208174643-50096c924a4e/go.mod h1:EXlVlkqNba9rJe3j7w3Xa924itAMLgZH4UD/Q4PExuQ=
 github.com/containerd/continuity v0.1.0/go.mod h1:ICJu0PwR54nI0yPEnJ6jcS+J7CZAUXrLh8lPo2knzsM=
+github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG8PI=
+github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M=
+github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE=
+github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk=
 github.com/containerd/fifo v0.0.0-20180307165137-3d5202aec260/go.mod h1:ODA38xgv3Kuk8dQz2ZQXpnv/UZZUHUCL7pnLehbXgQI=
 github.com/containerd/fifo v0.0.0-20190226154929-a9fb20d87448/go.mod h1:ODA38xgv3Kuk8dQz2ZQXpnv/UZZUHUCL7pnLehbXgQI=
 github.com/containerd/fifo v0.0.0-20200410184934-f15a3290365b/go.mod h1:jPQ2IAeZRCYxpS/Cm1495vGFww6ecHmMk1YJH2Q5ln0=
@@ -227,6 +268,8 @@ github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3
 github.com/containerd/nri v0.0.0-20201007170849-eb1350a75164/go.mod h1:+2wGSDGFYfE5+So4M5syatU0N0f0LbWpuqyMi4/BE8c=
 github.com/containerd/nri v0.0.0-20210316161719-dbaa18c31c14/go.mod h1:lmxnXF6oMkbqs39FiCt1s0R2HSMhcLel9vNL3m4AaeY=
 github.com/containerd/nri v0.1.0/go.mod h1:lmxnXF6oMkbqs39FiCt1s0R2HSMhcLel9vNL3m4AaeY=
+github.com/containerd/platforms v0.2.1 h1:zvwtM3rz2YHPQsF2CHYM8+KtB5dvhISiXh5ZpSBQv6A=
+github.com/containerd/platforms v0.2.1/go.mod h1:XHCb+2/hzowdiut9rkudds9bE5yJ7npe7dG/wG+uFPw=
 github.com/containerd/stargz-snapshotter/estargz v0.4.1/go.mod h1:x7Q9dg9QYb4+ELgxmo4gBUeJB0tl5dqH1Sdz0nJU1QM=
 github.com/containerd/stargz-snapshotter/estargz v0.11.0/go.mod h1:/KsZXsJRllMbTKFfG0miFQWViQKdI9+9aSXs+HN0+ac=
 github.com/containerd/ttrpc v0.0.0-20190828154514-0e0f228740de/go.mod h1:PvCDdDGpgqzQIzDW1TphrGLssLDZp2GuS+X5DkEJB8o=
@@ -273,7 +316,10 @@ github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfc
 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
-github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.6 h1:XJtiaUW6dEEqVuZiMTn1ldk455QWwEIsMIJlo5vtkx0=
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/cpuguy83/go-md2man/v2 v2.0.7 h1:zbFlGlXEAKlwXpmvle3d8Oe3YnkKIK4xSRTd3sHPnBo=
+github.com/cpuguy83/go-md2man/v2 v2.0.7/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
@@ -281,8 +327,8 @@ github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY=
 github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
 github.com/cyphar/filepath-securejoin v0.2.2/go.mod h1:FpkQEhXnPnOthhzymB7CGsFk2G9VLXONKD9G7QGMM+4=
 github.com/cyphar/filepath-securejoin v0.2.3/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4=
-github.com/cyphar/filepath-securejoin v0.2.5 h1:6iR5tXJ/e6tJZzzdMc1km3Sa7RRIVBKAK32O2s7AYfo=
-github.com/cyphar/filepath-securejoin v0.2.5/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4=
+github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s=
+github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
 github.com/d2g/dhcp4 v0.0.0-20170904100407-a1d1b6c41b1c/go.mod h1:Ct2BUK8SB0YC1SMSibvLzxjeJLnrYEVLULFNiHY9YfQ=
 github.com/d2g/dhcp4client v1.0.0/go.mod h1:j0hNfjhrt2SxUOw55nL0ATM/z4Yt3t2Kd1mW34z5W5s=
 github.com/d2g/dhcp4server v0.0.0-20181031114812-7d4a0a7f59a5/go.mod h1:Eo87+Kg/IX2hfWJfwxMzLyuSZyxSoAug2nGa1G2QAi8=
@@ -301,24 +347,30 @@ github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5Qvfr
 github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
 github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
 github.com/docker/cli v0.0.0-20191017083524-a8ff7f821017/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
-github.com/docker/cli v27.0.3+incompatible h1:usGs0/BoBW8MWxGeEtqPMkzOY56jZ6kYlSN5BLDioCQ=
-github.com/docker/cli v27.0.3+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v28.0.1+incompatible h1:g0h5NQNda3/CxIsaZfH4Tyf6vpxFth7PYl3hgCPOKzs=
+github.com/docker/cli v28.0.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v28.3.3+incompatible h1:fp9ZHAr1WWPGdIWBM1b3zLtgCF+83gRdVMTJsUeiyAo=
+github.com/docker/cli v28.3.3+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
 github.com/docker/distribution v0.0.0-20190905152932-14b96e55d84c/go.mod h1:0+TTO4EOBfRPhZXAeF1Vu+W3hHZ8eLp8PgKVZlcvtFY=
 github.com/docker/distribution v2.7.1-0.20190205005809-0d3efadf0154+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/distribution v2.8.3+incompatible h1:AtKxIZ36LoNK51+Z6RpzLpddBirtxJnzDrHLEKxTAYk=
 github.com/docker/distribution v2.8.3+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/docker v1.4.2-0.20190924003213-a8608b5b67c7/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
-github.com/docker/docker v27.0.3+incompatible h1:aBGI9TeQ4MPlhquTQKq9XbK79rKFVwXNUAYz9aXyEBE=
-github.com/docker/docker v27.0.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v28.0.1+incompatible h1:FCHjSRdXhNRFjlHMTv4jUNlIBbTeRjrWfeFuJp7jpo0=
+github.com/docker/docker v28.0.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v28.3.3+incompatible h1:Dypm25kh4rmk49v1eiVbsAtpAsYURjYkaKubwuBdxEI=
+github.com/docker/docker v28.3.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/docker-credential-helpers v0.6.3/go.mod h1:WRaJzqw3CTB9bk10avuGsjVBZsD05qeibJ1/TYlvc0Y=
-github.com/docker/docker-credential-helpers v0.8.2 h1:bX3YxiGzFP5sOXWc3bTPEXdEaZSeVMrFgOr3T+zrFAo=
-github.com/docker/docker-credential-helpers v0.8.2/go.mod h1:P3ci7E3lwkZg6XiHdRKft1KckHiO9a2rNtyFbZ/ry9M=
+github.com/docker/docker-credential-helpers v0.9.3 h1:gAm/VtF9wgqJMoxzT3Gj5p4AqIjCBS4wrsOh9yRqcz8=
+github.com/docker/docker-credential-helpers v0.9.3/go.mod h1:x+4Gbw9aGmChi3qTLZj8Dfn0TD20M/fuWy0E5+WDeCo=
 github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c h1:lzqkGL9b3znc+ZUgi7FlLnqjQhcXxkNM/quxIjBVMD0=
 github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c/go.mod h1:CADgU4DSXK5QUlFslkQu2yW2TKzFZcXq/leZfM0UH5Q=
 github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
 github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
 github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
+github.com/docker/go-connections v0.6.0 h1:LlMG9azAe1TqfR7sO+NJttz1gy6KO7VJBh+pMmjSD94=
+github.com/docker/go-connections v0.6.0/go.mod h1:AahvXYshr6JgfUJGdDCs2b5EZG/vmaMAntpSFH5BFKE=
 github.com/docker/go-events v0.0.0-20170721190031-9461782956ad/go.mod h1:Uw6UezgYA44ePAFQYUehOuCzmy5zmg/+nl2ZfMWGkpA=
 github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c/go.mod h1:Uw6UezgYA44ePAFQYUehOuCzmy5zmg/+nl2ZfMWGkpA=
 github.com/docker/go-metrics v0.0.0-20180209012529-399ea8c73916/go.mod h1:/u0gXw0Gay3ceNrsHubL3BtdOL2fHf93USgMTe0W5dI=
@@ -336,8 +388,8 @@ github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:Htrtb
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dvsekhvalnov/jose2go v0.0.0-20170216131308-f21a8cedbbae/go.mod h1:7BvyPhdbLxMXIYTFPLsyJRFMsKmOZnQmzh6Gb+uquuM=
 github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
-github.com/elazarl/goproxy v0.0.0-20230808193330-2592e75ae04a h1:mATvB/9r/3gvcejNsXKSkQ6lcIaNec2nyfOdlTBR2lU=
-github.com/elazarl/goproxy v0.0.0-20230808193330-2592e75ae04a/go.mod h1:Ro8st/ElPeALwNFlcTpWmkr6IoMFfkjXAvTHpevnDsM=
+github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o=
+github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE=
 github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
 github.com/emicklei/go-restful v2.9.5+incompatible/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
 github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
@@ -348,6 +400,8 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m
 github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5/go.mod h1:a2zkGnVExMxdzMo3M0Hi/3sEU+cWnZpSni0O6/Yb/P0=
 github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
@@ -368,16 +422,18 @@ github.com/garyburd/redigo v0.0.0-20150301180006-535138d7bcd7/go.mod h1:NR3MbYis
 github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/gliderlabs/ssh v0.3.7 h1:iV3Bqi942d9huXnzEF2Mt+CY9gLu8DNM4Obd+8bODRE=
-github.com/gliderlabs/ssh v0.3.7/go.mod h1:zpHEXBstFnQYtGnB8k8kQLol82umzn/2/snG7alWVD8=
+github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
+github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
-github.com/go-git/go-billy/v5 v5.5.0 h1:yEY4yhzCDuMGSv83oGxiBotRzhwhNr8VZyphhiu+mTU=
-github.com/go-git/go-billy/v5 v5.5.0/go.mod h1:hmexnoNsr2SJU1Ju67OaNz5ASJY3+sHgFRpCtpDCKow=
+github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=
+github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=
 github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
 github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
-github.com/go-git/go-git/v5 v5.12.0 h1:7Md+ndsjrzZxbddRDZjF14qK+NN56sy6wkqaVrjZtys=
-github.com/go-git/go-git/v5 v5.12.0/go.mod h1:FTM9VKtnI2m65hNI/TenDDDnUf2Q9FHnXYjuz9i5OEY=
+github.com/go-git/go-git/v5 v5.14.0 h1:/MD3lCrGjCen5WfEAzKg00MJJffKhC8gzS80ycmCi60=
+github.com/go-git/go-git/v5 v5.14.0/go.mod h1:Z5Xhoia5PcWA3NF8vRLURn9E5FRhSl7dGj9ItW3Wk5k=
+github.com/go-git/go-git/v5 v5.16.2 h1:fT6ZIOjE5iEnkzKyxTHK1W4HGAsPhqEqiSAssSO77hM=
+github.com/go-git/go-git/v5 v5.16.2/go.mod h1:4Ge4alE/5gPs30F2H1esi2gPd69R0C39lolkucHBOp8=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
@@ -393,6 +449,8 @@ github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTg
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
 github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0=
@@ -409,8 +467,10 @@ github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh
 github.com/go-sql-driver/mysql v1.3.0 h1:pgwjLi/dvffoP9aabwkT3AKpXQM93QARkjFhDDqC1UE=
 github.com/go-sql-driver/mysql v1.3.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-viper/mapstructure/v2 v2.0.0 h1:dhn8MZ1gZ0mzeodTG3jt5Vj/o87xZKuNAprG2mQfMfc=
-github.com/go-viper/mapstructure/v2 v2.0.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/go-viper/mapstructure/v2 v2.2.1 h1:ZAaOCxANMuZx5RCeg0mBdEZk7DZasvvZIxtHqx8aGss=
+github.com/go-viper/mapstructure/v2 v2.2.1/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
+github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
 github.com/godbus/dbus v0.0.0-20151105175453-c7fdd8b5cd55/go.mod h1:/YcGZj5zSblfDWMMoOzV4fas9FZnQYTkDnsGvmh2Grw=
 github.com/godbus/dbus v0.0.0-20180201030542-885f9cc04c9c/go.mod h1:/YcGZj5zSblfDWMMoOzV4fas9FZnQYTkDnsGvmh2Grw=
 github.com/godbus/dbus v0.0.0-20190422162347-ade71ed3457e/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4=
@@ -434,8 +494,8 @@ github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4er
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
@@ -474,8 +534,8 @@ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/go-containerregistry v0.5.1/go.mod h1:Ct15B4yir3PLOP5jsy0GNeYVaIZs/MK/Jz5any1wFW0=
 github.com/google/go-intervals v0.0.2/go.mod h1:MkaR3LNRfeKLPmqgJYs4E66z5InYjmCjbbr4TQlcT6Y=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
@@ -515,9 +575,12 @@ github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
 github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo=
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 h1:bkypFPDjIYGfCYD5mRBvpqxfYX1YCS1PXdKYWi8FsN0=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0/go.mod h1:P+Lt/0by1T8bfcF3z737NnSbmxQAppXMRziHUxPOC8k=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 h1:5ZPtiqj0JL5oKWmcsq4VMaAW5ukBEgSGXEN89zeH1Jo=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3/go.mod h1:ndYquD05frm2vACXE1nsccT4oJzjhw2arTS2cpUD1PI=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1 h1:X5VWvz21y3gzm9Nw/kaUeku/1+uBhcekkmy4IkffJww=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1/go.mod h1:Zanoh4+gvIgluNqcfMVTJueD4wSS5hT7zTt4Mrutd90=
 github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8=
 github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4=
 github.com/hashicorp/errwrap v0.0.0-20141028054710-7554cd9344ce/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
@@ -531,6 +594,8 @@ github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHh
 github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
 github.com/hashicorp/go-retryablehttp v0.7.7 h1:C8hUCYzor8PIfXHa4UrZkU4VvK8o9ISHxT2Q8+VepXU=
 github.com/hashicorp/go-retryablehttp v0.7.7/go.mod h1:pkQpWZeYWskR+D1tR2O5OcBFOxfA7DoAO6xtkuQnHTk=
+github.com/hashicorp/go-retryablehttp v0.7.8 h1:ylXZWnqa7Lhqpk0L1P1LzDtGcCR0rPVUrx/c8Unxc48=
+github.com/hashicorp/go-retryablehttp v0.7.8/go.mod h1:rjiScheydd+CxvumBsIrFKlx3iS0jrZ7LvzFGFmuKbw=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
@@ -568,7 +633,6 @@ github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/X
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/juju/loggo v0.0.0-20190526231331-6e530bcce5d8/go.mod h1:vgyd7OREkbtVEN/8IXZe5Ooef3LQePvuBm9UWj6ZL8U=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
-github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213/go.mod h1:vNUNkEQ1e29fT/6vq2aBdFsgNPmy8qMdSay1npru+Sw=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
 github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
@@ -580,8 +644,8 @@ github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+o
 github.com/klauspost/compress v1.11.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.11.13/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.14.2/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
@@ -597,6 +661,10 @@ github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/leonelquinteros/gotext v1.7.2 h1:bDPndU8nt+/kRo1m4l/1OXiiy2v7Z7dfPQ9+YP7G1Mc=
+github.com/leonelquinteros/gotext v1.7.2/go.mod h1:9/haCkm5P7Jay1sxKDGJ5WIg4zkz8oZKw4ekNpALob8=
 github.com/lib/pq v0.0.0-20150723085316-0dad96c0b94f/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/linuxkit/virtsock v0.0.0-20201010232012-f8cee7dfc7a3/go.mod h1:3r6x7q95whyfWQpmGZTu3gk3v2YkMi05HEzl7Tf7YEo=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
@@ -611,16 +679,17 @@ github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7
 github.com/marstr/guid v1.1.0/go.mod h1:74gB1z2wpxxInTG6yaqA7KrtM0NZ+RbrcqDvYHefzho=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
+github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
 github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-shellwords v1.0.3/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o=
 github.com/mattn/go-shellwords v1.0.6/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o=
 github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
@@ -646,24 +715,34 @@ github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RR
 github.com/mitchellh/osext v0.0.0-20151018003038-5e2d6d41470f/go.mod h1:OkQIRizQZAeMln+1tSwduZz7+Af5oFlKirV/MSYes2A=
 github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
 github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
+github.com/moby/go-archive v0.1.0 h1:Kk/5rdW/g+H8NHdJW2gsXyZ7UnzvJNOy6VKJqueWdcQ=
+github.com/moby/go-archive v0.1.0/go.mod h1:G9B+YoujNohJmrIYFBpSd54GTUB4lt9S+xVQvsJyFuo=
 github.com/moby/locker v1.0.1/go.mod h1:S7SDdo5zpBK84bzzVlKr2V0hz+7x9hWbYC/kq7oQppc=
 github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk=
 github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc=
+github.com/moby/sys/atomicwriter v0.1.0 h1:kw5D/EqkBwsBFi0ss9v1VG3wIkVhzGvLklJ+w3A14Sw=
+github.com/moby/sys/atomicwriter v0.1.0/go.mod h1:Ul8oqv2ZMNHOceF643P6FKPXeCmYtlQMvpizfsSoaWs=
 github.com/moby/sys/mountinfo v0.4.0/go.mod h1:rEr8tzG/lsIZHBtN/JjGG+LMYx9eXgW2JI+6q0qou+A=
 github.com/moby/sys/mountinfo v0.4.1/go.mod h1:rEr8tzG/lsIZHBtN/JjGG+LMYx9eXgW2JI+6q0qou+A=
 github.com/moby/sys/mountinfo v0.5.0/go.mod h1:3bMD3Rg+zkqx8MRYPi7Pyb0Ie97QEBmdxbhnCLlSvSU=
 github.com/moby/sys/mountinfo v0.6.2 h1:BzJjoreD5BMFNmD9Rus6gdd1pLuecOFPt8wC+Vygl78=
 github.com/moby/sys/mountinfo v0.6.2/go.mod h1:IJb6JQeOklcdMU9F5xQ8ZALD+CUr5VlGpwtX+VE0rpI=
-github.com/moby/sys/sequential v0.5.0 h1:OPvI35Lzn9K04PBbCLW0g4LcFAJgHsvXsRyewg5lXtc=
-github.com/moby/sys/sequential v0.5.0/go.mod h1:tH2cOOs5V9MlPiXcQzRC+eEyab644PWKGRYaaV5ZZlo=
-github.com/moby/sys/signal v0.7.0 h1:25RW3d5TnQEoKvRbEKUGay6DCQ46IxAVTT9CUMgmsSI=
-github.com/moby/sys/signal v0.7.0/go.mod h1:GQ6ObYZfqacOwTtlXvcmh9A26dVRul/hbOZn88Kg8Tg=
+github.com/moby/sys/mountinfo v0.7.2 h1:1shs6aH5s4o5H2zQLn796ADW1wMrIwHsyJ2v9KouLrg=
+github.com/moby/sys/mountinfo v0.7.2/go.mod h1:1YOa8w8Ih7uW0wALDUgT1dTTSBrZ+HiBLGws92L2RU4=
+github.com/moby/sys/sequential v0.6.0 h1:qrx7XFUd/5DxtqcoH1h438hF5TmOvzC/lspjy7zgvCU=
+github.com/moby/sys/sequential v0.6.0/go.mod h1:uyv8EUTrca5PnDsdMGXhZe6CCe8U/UiTWd+lL+7b/Ko=
+github.com/moby/sys/signal v0.7.1 h1:PrQxdvxcGijdo6UXXo/lU/TvHUWyPhj7UOpSo8tuvk0=
+github.com/moby/sys/signal v0.7.1/go.mod h1:Se1VGehYokAkrSQwL4tDzHvETwUZlnY7S5XtQ50mQp8=
 github.com/moby/sys/symlink v0.1.0/go.mod h1:GGDODQmbFOjFsXvfLVn3+ZRxkch54RkSiGqsZeMYowQ=
-github.com/moby/sys/user v0.1.0 h1:WmZ93f5Ux6het5iituh9x2zAG7NFY9Aqi49jjE1PaQg=
-github.com/moby/sys/user v0.1.0/go.mod h1:fKJhFOnsCN6xZ5gSfbM6zaHGgDJMrqt9/reuj4T7MmU=
+github.com/moby/sys/user v0.3.0 h1:9ni5DlcW5an3SvRSx4MouotOygvzaXbaSrc/wGDFWPo=
+github.com/moby/sys/user v0.3.0/go.mod h1:bG+tYYYJgaMtRKgEmuueC0hJEAZWwtIbZTB+85uoHjs=
+github.com/moby/sys/user v0.4.0 h1:jhcMKit7SA80hivmFJcbB1vqmw//wU61Zdui2eQXuMs=
+github.com/moby/sys/user v0.4.0/go.mod h1:bG+tYYYJgaMtRKgEmuueC0hJEAZWwtIbZTB+85uoHjs=
+github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g=
+github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28=
 github.com/moby/term v0.0.0-20200312100748-672ec06f55cd/go.mod h1:DdlQx2hp0Ss5/fLikoLlEeIYiATotOjgB//nb973jeo=
-github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
-github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
+github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ=
+github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
@@ -672,8 +751,12 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY
 github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
 github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
 github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ=
-github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo=
-github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
+github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
 github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
@@ -700,8 +783,8 @@ github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1Cpa
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.9.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
 github.com/onsi/gomega v1.10.3/go.mod h1:V9xEwhxec5O8UDM77eCW8vLymOMltsqPVYWrpDsH8xc=
-github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI=
-github.com/onsi/gomega v1.27.10/go.mod h1:RsS8tutOdbdgzbPtzzATp12yT7kM5I5aElG3evPbQ0M=
+github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
+github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
 github.com/opencontainers/go-digest v0.0.0-20170106003457-a6d0ee40d420/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
 github.com/opencontainers/go-digest v0.0.0-20180430190053-c9281466c8b2/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
 github.com/opencontainers/go-digest v1.0.0-rc1/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
@@ -710,8 +793,8 @@ github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
 github.com/opencontainers/image-spec v1.0.0/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0=
 github.com/opencontainers/image-spec v1.0.1/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0=
-github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
-github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
+github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040=
+github.com/opencontainers/image-spec v1.1.1/go.mod h1:qpqAh3Dmcf36wStyyWU+kCeDgrGnAve2nCC8+7h8Q0M=
 github.com/opencontainers/runc v0.0.0-20190115041553-12f6a991201f/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
 github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
 github.com/opencontainers/runc v1.0.0-rc8.0.20190926000215-3e425f80a8c9/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
@@ -741,8 +824,10 @@ github.com/pelletier/go-toml v1.8.1/go.mod h1:T2/BmBdy8dvIRq1a/8aqjN41wvWlN4lrap
 github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8=
 github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
 github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
-github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4=
-github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI=
+github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
+github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
+github.com/pjbgf/sha1cd v0.4.0 h1:NXzbL1RvjTUi6kgYZCX3fPwwl27Q1LJndxtUDVfJGRY=
+github.com/pjbgf/sha1cd v0.4.0/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1-0.20171018195549-f15c970de5b7/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -758,8 +843,10 @@ github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDf
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
-github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
+github.com/prometheus/client_golang v1.21.1 h1:DOvXXTqVzvkIewV/CDPFdejpMCGeMcbGCQ8YOmu+Ibk=
+github.com/prometheus/client_golang v1.21.1/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg=
+github.com/prometheus/client_golang v1.23.0 h1:ust4zpdl9r4trLY/gSjlm07PuiBq2ynaXXlptpfy8Uc=
+github.com/prometheus/client_golang v1.23.0/go.mod h1:i/o0R9ByOnHX0McrTMTyhYvKE4haaf2mW08I+jGAjEE=
 github.com/prometheus/client_model v0.0.0-20171117100541-99fa1f4be8e5/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
@@ -767,14 +854,18 @@ github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:
 github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
 github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
+github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
 github.com/prometheus/common v0.0.0-20180110214958-89604d197083/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
-github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
-github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
+github.com/prometheus/common v0.63.0 h1:YR/EIY1o3mEFP/kZCD7iDMnLPlGyuU2Gb3HIcXnA98k=
+github.com/prometheus/common v0.63.0/go.mod h1:VVFF/fBIoToEnWRVkYoXEkq3R3paCoxG9PXP74SnV18=
+github.com/prometheus/common v0.65.0 h1:QDwzd+G1twt//Kwj/Ww6E9FQq1iVMmODnILtW1t2VzE=
+github.com/prometheus/common v0.65.0/go.mod h1:0gZns+BLRQ3V6NdaerOhMbwwRbNh9hkGINtQAsP5GS8=
 github.com/prometheus/procfs v0.0.0-20180125133057-cb4147076ac7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
@@ -788,6 +879,8 @@ github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4O
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
 github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0=
+github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
@@ -795,19 +888,23 @@ github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUc
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
-github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/safchain/ethtool v0.0.0-20190326074333-42ed695e3de8/go.mod h1:Z0q5wiBQGYcxhMZ6gUqHn6pYNLypFAvaL3UvgZLR0U4=
 github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
-github.com/schollz/progressbar/v3 v3.14.4 h1:W9ZrDSJk7eqmQhd3uxFNNcTr0QL+xuGNI9dEMrw0r74=
-github.com/schollz/progressbar/v3 v3.14.4/go.mod h1:aT3UQ7yGm+2ZjeXPqsjTenwL3ddUiuZ0kfQ/2tHlyNI=
+github.com/schollz/progressbar/v3 v3.18.0 h1:uXdoHABRFmNIjUfte/Ex7WtuyVslrw2wVPQmCN62HpA=
+github.com/schollz/progressbar/v3 v3.18.0/go.mod h1:IsO3lpbaGuzh8zIMzgY3+J8l4C8GjO0Y9S69eFvNsec=
 github.com/sclevine/spec v1.2.0/go.mod h1:W4J29eT/Kzv7/b9IWLB055Z+qvVC9vt0Arko24q7p+U=
 github.com/seccomp/libseccomp-golang v0.9.1/go.mod h1:GbW5+tmTXfcxTToHLXlScSlAvWlF4P2Ca7zGrPiEpWo=
 github.com/seccomp/libseccomp-golang v0.9.2-0.20210429002308-3879420cc921/go.mod h1:JA8cRccbGaA1s33RQf7Y1+q9gHmZX1yB/z9WDN1C6fg=
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
+github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw=
+github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.0.4-0.20170822132746-89742aefa4b2/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
 github.com/sirupsen/logrus v1.0.6/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
@@ -819,8 +916,8 @@ github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic
 github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/skeema/knownhosts v1.2.2 h1:Iug2P4fLmDw9f41PB6thxUkNUkJzB5i+1/exaj40L3A=
-github.com/skeema/knownhosts v1.2.2/go.mod h1:xYbVRSPxqBZFrdmDyMmsOs+uX1UZC3nTN3ThzgDxUwo=
+github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=
+github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
@@ -835,8 +932,8 @@ github.com/spf13/cobra v0.0.1/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3
 github.com/spf13/cobra v0.0.2-0.20171109065643-2da4a54c5cee/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
 github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
 github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
-github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
-github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
+github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
+github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
 github.com/spf13/jwalterweatherman v0.0.0-20141219030609-3d60171a6431/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
@@ -845,8 +942,11 @@ github.com/spf13/pflag v1.0.0/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnIn
 github.com/spf13/pflag v1.0.1-0.20171106142849-4c012f6dcd95/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
+github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.7 h1:vN6T9TfwStFPFM5XzjsvmzZkLuaLX+HS+0SeFLRgU6M=
+github.com/spf13/pflag v1.0.7/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v0.0.0-20150530192845-be5ff3e4840c/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM=
 github.com/spf13/viper v1.4.0 h1:yXHLWeravcrgGyFSyCgdYpXQ9dR9c/WED3pg1RhxqEU=
 github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
@@ -862,8 +962,8 @@ github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81P
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/syndtr/gocapability v0.0.0-20170704070218-db04d3cc01c8/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
 github.com/syndtr/gocapability v0.0.0-20180916011248-d98352740cb2/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
 github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635 h1:kdXcSzyDtseVEc4yCz2qF8ZrQvIDBJLl4S1c3GCXmoI=
@@ -881,8 +981,6 @@ github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijb
 github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/urfave/cli v1.22.4/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
-github.com/urfave/cli/v3 v3.0.0-alpha9.1.0.20241019193437-5053ec708a44 h1:BeSTAZEDkDVNv9EOrycIGCkEg+6EhRRgSsbdc93Q3OM=
-github.com/urfave/cli/v3 v3.0.0-alpha9.1.0.20241019193437-5053ec708a44/go.mod h1:FnIeEMYu+ko8zP1F9Ypr3xkZMIDqW3DR92yUtY39q1Y=
 github.com/vbatts/tar-split v0.11.2/go.mod h1:vV3ZuO2yWSVsz+pfFzDG/upWH1JhjOiEaWq6kXyQ3VI=
 github.com/vishvananda/netlink v0.0.0-20181108222139-023a6dafdcdf/go.mod h1:+SR5DhBJrl6ZM7CoCKvpw5BKroDKQ+PJqOg65H/2ktk=
 github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
@@ -903,6 +1001,8 @@ github.com/xeipuuv/gojsonschema v0.0.0-20180618132009-1d523034197f/go.mod h1:5yf
 github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
 github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -921,29 +1021,51 @@ go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 h1:4K4tsIXefpVJtvA/8srF4V4y0akAoPHkIslgAkjixJA=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0/go.mod h1:jjdQuTGVsXV4vSs+CJ2qYDeDPf9yIJV23qlIzBm73Vg=
-go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo=
-go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 h1:U2guen0GhqH8o/G2un8f/aG/y++OuW6MyCo6hT9prXk=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0/go.mod h1:yeGZANgEcpdx/WK0IvvRFC+2oLiMS2u4L/0Rj2M2Qr0=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 h1:3Q/xZUyC1BBkualc9ROb4G8qkH90LXEIICcs5zv1OYY=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0/go.mod h1:s75jGIWA9OfCMzF0xr+ZgfrB5FEbbV7UuYo32ahUiFI=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 h1:R3X6ZXmNPRR8ul6i3WgFURCHzaXjHdm0karRG/+dj3s=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0/go.mod h1:QWFXnDavXWwMx2EEcZsf3yxgEKAqsxQ+Syjp+seyInw=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.60.0 h1:sbiXRNDSWJOTobXh5HyQKjq6wUC5tNybqjIqDpAY4CU=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.60.0/go.mod h1:69uWxva0WgAA/4bu2Yy70SLDBwZXuQ6PbBpbsa5iZrQ=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0 h1:Hf9xI/XLML9ElpiHVDNwvqI0hIFlzV8dgIr35kV1kRU=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0/go.mod h1:NfchwuyNoMcZ5MLHwPrODwUF1HWCXWrL31s8gSAdIKY=
+go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ=
+go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y=
+go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
+go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.35.0 h1:QcFwRrZLc82r8wODjvyCbP7Ifp3UANaBSmhDSFjnqSc=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.35.0/go.mod h1:CXIWhUomyWBG/oY2/r/kLp6K/cmx9e/7DLpBuuGdLCA=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.37.0 h1:zG8GlgXCJQd5BU98C0hZnBbElszTmUgCNCfYneaDL0A=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.37.0/go.mod h1:hOfBCz8kv/wuq73Mx2H2QnWokh/kHZxkh6SNF2bdKtw=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.35.0 h1:1fTNlAIJZGWLP5FVu0fikVry1IsiUnXjf7QFvoNN3Xw=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.35.0/go.mod h1:zjPK58DtkqQFn+YUMbx0M2XV3QgKU0gS9LeGohREyK4=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0 h1:Ahq7pZmv87yiyn3jeFz/LekZmPLLdKejuO3NcK9MssM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0/go.mod h1:MJTqhM0im3mRLw1i8uGHnCvUEeS7VwRyxlLC78PA18M=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.35.0 h1:m639+BofXTvcY1q8CGs4ItwQarYtJPOWmVobfM1HpVI=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.35.0/go.mod h1:LjReUci/F4BUyv+y4dwnq3h/26iNOeC3wAIqgvTIZVo=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0 h1:EtFWSnwW9hGObjkIdmlnWSydO+Qs8OwzfzXLUPg4xOc=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0/go.mod h1:QjUEoiGCPkvFZ/MjK6ZZfNOS6mfVEVKYE99dFhuN2LI=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0 h1:IeMeyr1aBvBiPVYihXIaeIZba6b8E1bYp7lbdxK8CQg=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0/go.mod h1:oVdCUtjq9MK9BlS7TtucsQwUcXcymNiEDjgDD2jMtZU=
-go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bOeuA5Q=
-go.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s=
-go.opentelemetry.io/otel/sdk v1.28.0 h1:b9d7hIry8yZsgtbmM0DKyPWMMUMlK9NEKuIG4aBqWyE=
-go.opentelemetry.io/otel/sdk v1.28.0/go.mod h1:oYj7ClPUA7Iw3m+r7GeEjz0qckQRJK2B8zjcZEfu7Pg=
-go.opentelemetry.io/otel/sdk/metric v1.28.0 h1:OkuaKgKrgAbYrrY0t92c+cC+2F6hsFNnCQArXCKlg08=
-go.opentelemetry.io/otel/sdk/metric v1.28.0/go.mod h1:cWPjykihLAPvXKi4iZc1dpER3Jdq2Z0YLse3moQUCpg=
-go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+lkx9g=
-go.opentelemetry.io/otel/trace v1.28.0/go.mod h1:jPyXzNPg6da9+38HEwElrQiHlVMTnVfM3/yv2OlIHaI=
+go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M=
+go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE=
+go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
+go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
+go.opentelemetry.io/otel/sdk v1.35.0 h1:iPctf8iprVySXSKJffSS79eOjl9pvxV9ZqOWT0QejKY=
+go.opentelemetry.io/otel/sdk v1.35.0/go.mod h1:+ga1bZliga3DxJ3CQGg3updiaAJoNECOgJREo9KHGQg=
+go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
+go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
+go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o=
+go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w=
+go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
+go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
+go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs=
+go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc=
+go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
+go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
-go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0=
-go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8=
+go.opentelemetry.io/proto/otlp v1.5.0 h1:xJvq7gMzB31/d406fB8U5CBdyQGw4P399D1aQWU/3i4=
+go.opentelemetry.io/proto/otlp v1.5.0/go.mod h1:keN8WnHxOy8PG0rQZjJJ5A2ebUoafqWp0eVQ4yIXvJ4=
+go.opentelemetry.io/proto/otlp v1.7.1 h1:gTOMpGDb0WTBOP8JaO72iL3auEZhVmAQg4ipjOVAtj4=
+go.opentelemetry.io/proto/otlp v1.7.1/go.mod h1:b2rVh6rfI/s2pHWNlB7ILJcRALpcNDzKhACevjI+ZnE=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
@@ -968,10 +1090,10 @@ golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWP
 golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
-golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
-golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
-golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
+golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -982,8 +1104,12 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 h1:yixxcjnhBmY0nkL253HFVIm0JsFHwrHdT3Yh6szTnfY=
-golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXyeI3r5MFf+NT2An6/9dOA95KSI=
+golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 h1:nDVHiLt8aIbd/VzvPWN6kSOPE7+F/fNFDSXLVYkE/Iw=
+golang.org/x/exp v0.0.0-20250305212735-054e65f0b394/go.mod h1:sIifuuw/Yco/y6yb6+bDNfyeQ/MdPUy/hKEMYQV17cM=
+golang.org/x/exp v0.0.0-20250811191247-51f88131bc50 h1:3yiSh9fhy5/RhCSntf4Sy0Tnx50DmMpQ4MQdKKk4yg4=
+golang.org/x/exp v0.0.0-20250811191247-51f88131bc50/go.mod h1:rT6SFzZ7oxADUDx58pcaKFTcZ+inxAa9fTrYx/uVYwg=
+golang.org/x/exp v0.0.0-20250813145105-42675adae3e6 h1:SbTAbRFnd5kjQXbczszQ0hdk3ctwYf3qBNH9jIsGclE=
+golang.org/x/exp v0.0.0-20250813145105-42675adae3e6/go.mod h1:4QTo5u+SEIbbKW1RacMZq1YEfOBqeXa19JeshGi+zc4=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -1006,7 +1132,6 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1048,11 +1173,10 @@ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96b
 golang.org/x/net v0.0.0-20210825183410-e898025ed96a/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
-golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
-golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
+golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=
+golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -1070,9 +1194,10 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -1142,6 +1267,7 @@ golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210906170528-6f6e22806c34/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211116061358-0a5406a5449c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -1149,23 +1275,19 @@ golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
-golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
-golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
-golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk=
-golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
+golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
+golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
+golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
+golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -1175,18 +1297,20 @@ golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20200630173020-3af7569d3a1e/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
-golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0=
+golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
+golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
+golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181011042414-1f849cf54d09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -1232,7 +1356,6 @@ golang.org/x/tools v0.0.0-20200916195026-c9a70fc28ce3/go.mod h1:z6u4i615ZeAfBE4X
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -1281,10 +1404,14 @@ google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfG
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/genproto v0.0.0-20200527145253-8367513e4ece/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
 google.golang.org/genproto v0.0.0-20201110150050-8816d57aaa9a/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094 h1:0+ozOGcrp+Y8Aq8TLNN2Aliibms5LEzsq99ZZmAGYm0=
-google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094/go.mod h1:fJ/e3If/Q67Mj99hin0hMhiNyCRmt6BQ2aWIJshUSJw=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 h1:BwIjyKYGsK9dMCBOorzRri8MQwmi7mT9rGHsCEinZkA=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
+google.golang.org/genproto/googleapis/api v0.0.0-20250313205543-e70fdf4c4cb4 h1:IFnXJq3UPB3oBREOodn1v1aGQeZYQclEmvWRMN0PSsY=
+google.golang.org/genproto/googleapis/api v0.0.0-20250313205543-e70fdf4c4cb4/go.mod h1:c8q6Z6OCqnfVIqUFJkCzKcrj8eCvUrz+K4KRzSTuANg=
+google.golang.org/genproto/googleapis/api v0.0.0-20250811230008-5f3141c8851a h1:DMCgtIAIQGZqJXMVzJF4MV8BlWoJh2ZuFiRdAleyr58=
+google.golang.org/genproto/googleapis/api v0.0.0-20250811230008-5f3141c8851a/go.mod h1:y2yVLIE/CSMCPXaHnSKXxu1spLPnglFLegmgdY23uuE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250313205543-e70fdf4c4cb4 h1:iK2jbkWL86DXjEx0qiHcRE9dE4/Ahua5k6V8OWFb//c=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250313205543-e70fdf4c4cb4/go.mod h1:LuRYeWDFV6WOn90g357N17oMCaxpgCnbi/44qJvDn2I=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a h1:tPE/Kp+x9dMSwUm/uM0JKK0IfdiJkwAbSMSeZBXXJXc=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a/go.mod h1:gw1tLEfykwDz2ET4a12jcXt4couGAm7IwsVaTy0Sflo=
 google.golang.org/grpc v0.0.0-20160317175043-d3ddb4469d5a/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.0.5/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
@@ -1304,8 +1431,10 @@ google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTp
 google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
 google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
 google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
-google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=
-google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ=
+google.golang.org/grpc v1.71.0 h1:kF77BGdPTQ4/JZWMlb9VpJ5pa25aqvVqogsxNHHdeBg=
+google.golang.org/grpc v1.71.0/go.mod h1:H0GRtasmQOh9LkFoCPDu3ZrwUtD1YGE+b2vYBYd/8Ec=
+google.golang.org/grpc v1.74.2 h1:WoosgB65DlWVC9FqI82dGsZhWFNBSLjQ84bjROOpMu4=
+google.golang.org/grpc v1.74.2/go.mod h1:CtQ+BGjaAIXHs/5YS3i473GqwBBa1zGQNevxdeBEXrM=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -1319,8 +1448,10 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
+google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
+google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/cenkalti/backoff.v2 v2.2.1 h1:eJ9UAg01/HIHG987TwxvnzK2MgxXq97YY6rYDpY9aII=
@@ -1360,11 +1491,12 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8=
-gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU=
-gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

locales/default.pot

@@ -0,0 +1,12 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: \n"
+"X-Generator: xgotext\n"
+
+#: app.go:11
+msgid "Manage apps"
+msgstr ""

locales/es/LC_MESSAGES/default.po

@@ -0,0 +1,20 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-08-04 14:15+0000\n"
+"PO-Revision-Date: 2025-08-04 14:15+0000\n"
+"Last-Translator: 3wordchant <3wc.coopcloud@doesthisthing.work>\n"
+"Language-Team: Spanish <https://translate.coopcloud.tech/projects/"
+"co-op-cloud/abra/es/>\n"
+"Language: es\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: ENCODING\n"
+"Plural-Forms: nplurals=2; plural=n != 1;\n"
+"X-Generator: Weblate 5.12.2\n"
+
+#: app.go:11
+msgid "Manage apps"
+msgstr "Gestionar aplicaciones"

pkg/app/app.go

@@ -36,7 +36,7 @@ func Get(appName string) (App, error) {
 		return App{}, err
 	}
 
-	log.Debugf("retrieved %s for %s", app, appName)
+	log.Debugf("loaded app %s: %s", appName, app)
 
 	return app, nil
 }
@@ -91,6 +91,17 @@ type App struct {
 	Path   string
 }
 
+// String outputs a human-friendly string representation.
+func (a App) String() string {
+	out := fmt.Sprintf("{name: %s, ", a.Name)
+	out += fmt.Sprintf("recipe: %s, ", a.Recipe)
+	out += fmt.Sprintf("domain: %s, ", a.Domain)
+	out += fmt.Sprintf("env %s, ", a.Env)
+	out += fmt.Sprintf("server %s, ", a.Server)
+	out += fmt.Sprintf("path %s}", a.Path)
+	return out
+}
+
 // Type aliases to make code hints easier to understand
 
 // AppName is AppName
@@ -235,8 +246,6 @@ func ReadAppEnvFile(appFile AppFile, name AppName) (App, error) {
 		return App{}, fmt.Errorf("env file for %s couldn't be read: %s", name, err.Error())
 	}
 
-	log.Debugf("read env %s from %s", env, appFile.Path)
-
 	app, err := NewApp(env, name, appFile)
 	if err != nil {
 		return App{}, fmt.Errorf("env file for %s has issues: %s", name, err.Error())
@@ -417,7 +426,9 @@ func GetAppStatuses(apps []App, MachineReadable bool) (map[string]map[string]str
 	for server := range servers {
 		cl, err := client.New(server)
 		if err != nil {
-			return statuses, err
+			log.Warn(err)
+			ch <- stack.StackStatus{}
+			continue
 		}
 
 		go func(s string) {
@@ -494,13 +505,13 @@ func GetAppComposeConfig(recipe string, opts stack.Deploy, appEnv envfile.AppEnv
 func ExposeAllEnv(stackName string, compose *composetypes.Config, appEnv envfile.AppEnv) {
 	for _, service := range compose.Services {
 		if service.Name == "app" {
-			log.Debugf("add the following environment to the app service config of %s:", stackName)
+			log.Debugf("adding env vars to %s service config", stackName)
 			for k, v := range appEnv {
 				_, exists := service.Environment[k]
 				if !exists {
 					value := v
 					service.Environment[k] = &value
-					log.Debugf("add env var: %s value: %s to %s", k, value, stackName)
+					log.Debugf("%s: %s: %s", stackName, k, value)
 				}
 			}
 		}
@@ -569,16 +580,19 @@ func ReadAbraShCmdNames(abraSh string) ([]string, error) {
 	return cmdNames, nil
 }
 
-func (a App) WriteRecipeVersion(version string, dryRun bool) error {
+// Wipe removes the version from the app .env file.
+func (a App) WipeRecipeVersion() error {
 	file, err := os.Open(a.Path)
 	if err != nil {
 		return err
 	}
 	defer file.Close()
 
-	skipped := false
-	scanner := bufio.NewScanner(file)
-	lines := []string{}
+	var (
+		lines   []string
+		scanner = bufio.NewScanner(file)
+	)
+
 	for scanner.Scan() {
 		line := scanner.Text()
 		if !strings.HasPrefix(line, "RECIPE=") && !strings.HasPrefix(line, "TYPE=") {
@@ -591,13 +605,58 @@ func (a App) WriteRecipeVersion(version string, dryRun bool) error {
 			continue
 		}
 
-		if strings.Contains(line, version) {
+		splitted := strings.Split(line, ":")
+		lines = append(lines, splitted[0])
+	}
+
+	if err := scanner.Err(); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := os.WriteFile(a.Path, []byte(strings.Join(lines, "\n")), os.ModePerm); err != nil {
+		log.Fatal(err)
+	}
+
+	log.Debugf("version wiped from %s.env", a.Domain)
+
+	return nil
+}
+
+// WriteRecipeVersion writes the recipe version to the app .env file.
+func (a App) WriteRecipeVersion(version string, dryRun bool) error {
+	file, err := os.Open(a.Path)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	var (
+		dirtyVersion string
+		skipped      bool
+		lines        []string
+		scanner      = bufio.NewScanner(file)
+	)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		if !strings.HasPrefix(line, "RECIPE=") && !strings.HasPrefix(line, "TYPE=") {
+			lines = append(lines, line)
+			continue
+		}
+
+		if strings.HasPrefix(line, "#") {
+			lines = append(lines, line)
+			continue
+		}
+
+		if strings.Contains(line, version) && !a.Recipe.Dirty && !strings.HasSuffix(line, config.DIRTY_DEFAULT) {
 			skipped = true
 			lines = append(lines, line)
 			continue
 		}
 
 		splitted := strings.Split(line, ":")
+
 		line = fmt.Sprintf("%s:%s", splitted[0], version)
 		lines = append(lines, line)
 	}
@@ -606,6 +665,10 @@ func (a App) WriteRecipeVersion(version string, dryRun bool) error {
 		log.Fatal(err)
 	}
 
+	if a.Recipe.Dirty && dirtyVersion != "" {
+		version = dirtyVersion
+	}
+
 	if !dryRun {
 		if err := os.WriteFile(a.Path, []byte(strings.Join(lines, "\n")), os.ModePerm); err != nil {
 			log.Fatal(err)
@@ -615,7 +678,7 @@ func (a App) WriteRecipeVersion(version string, dryRun bool) error {
 	}
 
 	if !skipped {
-		log.Infof("version %s saved to %s.env", version, a.Domain)
+		log.Debugf("version %s saved to %s.env", version, a.Domain)
 	} else {
 		log.Debugf("skipping version %s write as already exists in %s.env", version, a.Domain)
 	}

pkg/app/app_test.go

@@ -198,3 +198,29 @@ func compareFilter(t *testing.T, f1 filters.Args, f2 map[string]map[string]bool)
 		t.Errorf("filters mismatch (-want +got):\n%s", diff)
 	}
 }
+
+func TestWriteRecipeVersionOverwrite(t *testing.T) {
+	app, err := appPkg.GetApp(testPkg.ExpectedAppFiles, testPkg.AppName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	defer t.Cleanup(func() {
+		if err := app.WipeRecipeVersion(); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	assert.Equal(t, "", app.Recipe.EnvVersion)
+
+	if err := app.WriteRecipeVersion("foo", false); err != nil {
+		t.Fatal(err)
+	}
+
+	app, err = appPkg.GetApp(testPkg.ExpectedAppFiles, testPkg.AppName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, "foo", app.Recipe.EnvVersion)
+}

pkg/app/compose.go

@@ -16,7 +16,7 @@ func SetRecipeLabel(compose *composetypes.Config, stackName string, recipe strin
 		if service.Name == "app" {
 			log.Debugf("set recipe label 'coop-cloud.%s.recipe' to %s for %s", stackName, recipe, stackName)
 			labelKey := fmt.Sprintf("coop-cloud.%s.recipe", stackName)
-			AddLabel(service, labelKey, recipe)
+			service.Deploy.Labels[labelKey] = recipe
 		}
 	}
 }
@@ -28,7 +28,7 @@ func SetChaosLabel(compose *composetypes.Config, stackName string, chaos bool) {
 		if service.Name == "app" {
 			log.Debugf("set label 'coop-cloud.%s.chaos' to %v for %s", stackName, chaos, stackName)
 			labelKey := fmt.Sprintf("coop-cloud.%s.chaos", stackName)
-			AddLabel(service, labelKey, strconv.FormatBool(chaos))
+			service.Deploy.Labels[labelKey] = strconv.FormatBool(chaos)
 		}
 	}
 }
@@ -39,7 +39,17 @@ func SetChaosVersionLabel(compose *composetypes.Config, stackName string, chaosV
 		if service.Name == "app" {
 			log.Debugf("set label 'coop-cloud.%s.chaos-version' to %v for %s", stackName, chaosVersion, stackName)
 			labelKey := fmt.Sprintf("coop-cloud.%s.chaos-version", stackName)
-			AddLabel(service, labelKey, chaosVersion)
+			service.Deploy.Labels[labelKey] = chaosVersion
+		}
+	}
+}
+
+func SetVersionLabel(compose *composetypes.Config, stackName string, version string) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			log.Debugf("set label 'coop-cloud.%s.version' to %v for %s", stackName, version, stackName)
+			labelKey := fmt.Sprintf("coop-cloud.%s.version", stackName)
+			service.Deploy.Labels[labelKey] = version
 		}
 	}
 }
@@ -56,7 +66,7 @@ func SetUpdateLabel(compose *composetypes.Config, stackName string, appEnv envfi
 			}
 			log.Debugf("set label 'coop-cloud.%s.autoupdate' to %s for %s", stackName, enable_auto_update, stackName)
 			labelKey := fmt.Sprintf("coop-cloud.%s.autoupdate", stackName)
-			AddLabel(service, labelKey, enable_auto_update)
+			service.Deploy.Labels[labelKey] = enable_auto_update
 		}
 	}
 }
@@ -86,10 +96,3 @@ func GetTimeoutFromLabel(compose *composetypes.Config, stackName string) (int, e
 	}
 	return timeout, err
 }
-
-func AddLabel(service composetypes.ServiceConfig, labelKey string, value string) {
-	if service.Deploy.Labels == nil {
-		service.Deploy.Labels = composetypes.Labels{}
-	}
-	service.Deploy.Labels[labelKey] = value
-}

pkg/autocomplete/autocomplete.go

@@ -1,103 +1,124 @@
 package autocomplete
 
 import (
-	"context"
-	"fmt"
+	"sort"
 
 	"coopcloud.tech/abra/pkg/app"
-	"coopcloud.tech/abra/pkg/log"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/urfave/cli/v3"
+	"github.com/leonelquinteros/gotext"
+	"github.com/spf13/cobra"
 )
 
 // AppNameComplete copletes app names.
-func AppNameComplete(ctx context.Context, cmd *cli.Command) {
-	appNames, err := app.GetAppNames()
+func AppNameComplete() ([]string, cobra.ShellCompDirective) {
+	appFiles, err := app.LoadAppFiles("")
 	if err != nil {
-		log.Warn(err)
+		err := gotext.Get("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
 
-	if cmd.NArg() > 0 {
-		return
+	var appNames []string
+	for appName := range appFiles {
+		appNames = append(appNames, appName)
 	}
 
-	for _, a := range appNames {
-		fmt.Println(a)
-	}
+	return appNames, cobra.ShellCompDirectiveDefault
 }
 
-func ServiceNameComplete(appName string) {
+func ServiceNameComplete(appName string) ([]string, cobra.ShellCompDirective) {
 	serviceNames, err := app.GetAppServiceNames(appName)
 	if err != nil {
-		return
-	}
-	for _, s := range serviceNames {
-		fmt.Println(s)
+		err := gotext.Get("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
+
+	return serviceNames, cobra.ShellCompDirectiveDefault
 }
 
 // RecipeNameComplete completes recipe names.
-func RecipeNameComplete(ctx context.Context, cmd *cli.Command) {
+func RecipeNameComplete() ([]string, cobra.ShellCompDirective) {
 	catl, err := recipe.ReadRecipeCatalogue(false)
 	if err != nil {
-		log.Warn(err)
-	}
-
-	if cmd.NArg() > 0 {
-		return
+		err := gotext.Get("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
 
+	var recipeNames []string
 	for name := range catl {
-		fmt.Println(name)
+		recipeNames = append(recipeNames, name)
 	}
+
+	return recipeNames, cobra.ShellCompDirectiveDefault
 }
 
 // RecipeVersionComplete completes versions for the recipe.
-func RecipeVersionComplete(recipeName string) {
-	catl, err := recipe.ReadRecipeCatalogue(false)
+func RecipeVersionComplete(recipeName string) ([]string, cobra.ShellCompDirective) {
+	catl, err := recipe.ReadRecipeCatalogue(true)
 	if err != nil {
-		log.Warn(err)
+		err := gotext.Get("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
 
+	var recipeVersions []string
 	for _, v := range catl[recipeName].Versions {
 		for v2 := range v {
-			fmt.Println(v2)
+			recipeVersions = append(recipeVersions, v2)
 		}
 	}
+
+	return recipeVersions, cobra.ShellCompDirectiveDefault
 }
 
 // ServerNameComplete completes server names.
-func ServerNameComplete(ctx context.Context, cmd *cli.Command) {
+func ServerNameComplete() ([]string, cobra.ShellCompDirective) {
 	files, err := app.LoadAppFiles("")
 	if err != nil {
-		log.Fatal(err)
-	}
-
-	if cmd.NArg() > 0 {
-		return
+		err := gotext.Get("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
 
+	var serverNames []string
 	for _, appFile := range files {
-		fmt.Println(appFile.Server)
+		serverNames = append(serverNames, appFile.Server)
 	}
+
+	return serverNames, cobra.ShellCompDirectiveDefault
 }
 
-// SubcommandComplete completes sub-commands.
-func SubcommandComplete(ctx context.Context, cmd *cli.Command) {
-	if cmd.NArg() > 0 {
-		return
+// CommandNameComplete completes recipe commands.
+func CommandNameComplete(appName string) ([]string, cobra.ShellCompDirective) {
+	app, err := app.Get(appName)
+	if err != nil {
+		err := gotext.Get("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
 
-	subcmds := []string{
-		"app",
-		"autocomplete",
-		"catalogue",
-		"recipe",
-		"server",
-		"upgrade",
+	cmdNames, err := appPkg.ReadAbraShCmdNames(app.Recipe.AbraShPath)
+	if err != nil {
+		err := gotext.Get("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
 
-	for _, cmd := range subcmds {
-		fmt.Println(cmd)
-	}
+	sort.Strings(cmdNames)
+
+	return cmdNames, cobra.ShellCompDirectiveDefault
+}
+
+// SecretsComplete completes recipe secrets.
+func SecretComplete(recipeName string) ([]string, cobra.ShellCompDirective) {
+	r := recipe.Get(recipeName)
+
+	config, err := r.GetComposeConfig(nil)
+	if err != nil {
+		err := gotext.Get("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
+	}
+
+	var secretNames []string
+	for name := range config.Secrets {
+		secretNames = append(secretNames, name)
+	}
+
+	return secretNames, cobra.ShellCompDirectiveDefault
 }

pkg/catalogue/catalogue.go

@@ -1,6 +1,7 @@
 package catalogue
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"path"
@@ -10,19 +11,19 @@ import (
 	gitPkg "coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
+	"github.com/leonelquinteros/gotext"
 )
 
 // EnsureCatalogue ensures that the catalogue is cloned locally & present.
 func EnsureCatalogue() error {
 	catalogueDir := path.Join(config.ABRA_DIR, "catalogue")
 	if _, err := os.Stat(catalogueDir); err != nil && os.IsNotExist(err) {
-		log.Warnf("local recipe catalogue is missing, retrieving now")
+		log.Debug(gotext.Get("catalogue is missing, retrieving now"))
+
 		url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, config.CATALOGUE_JSON_REPO_NAME)
 		if err := gitPkg.Clone(catalogueDir, url); err != nil {
 			return err
 		}
-
-		log.Debugf("cloned catalogue repository to %s", catalogueDir)
 	}
 
 	return nil
@@ -36,8 +37,7 @@ func EnsureIsClean() error {
 	}
 
 	if !isClean {
-		msg := "%s has locally unstaged changes? please commit/remove your changes before proceeding"
-		return fmt.Errorf(msg, config.CATALOGUE_DIR)
+		return errors.New(gotext.Get("%s has locally unstaged changes? please commit/remove your changes before proceeding", config.CATALOGUE_DIR))
 	}
 
 	return nil
@@ -56,8 +56,7 @@ func EnsureUpToDate() error {
 	}
 
 	if len(remotes) == 0 {
-		msg := "cannot ensure %s is up-to-date, no git remotes configured"
-		log.Debugf(msg, config.CATALOGUE_DIR)
+		log.Debug(gotext.Get("cannot ensure %s is up-to-date, no git remotes configured", config.CATALOGUE_DIR))
 		return nil
 	}
 
@@ -82,7 +81,7 @@ func EnsureUpToDate() error {
 		}
 	}
 
-	log.Debugf("fetched latest git changes for %s", config.CATALOGUE_DIR)
+	log.Debug(gotext.Get("fetched latest git changes for %s", config.CATALOGUE_DIR))
 
 	return nil
 }

pkg/client/client.go

@@ -4,7 +4,6 @@ package client
 import (
 	"context"
 	"errors"
-	"fmt"
 	"net/http"
 	"os"
 	"time"
@@ -14,6 +13,7 @@ import (
 	sshPkg "coopcloud.tech/abra/pkg/ssh"
 	commandconnPkg "coopcloud.tech/abra/pkg/upstream/commandconn"
 	"github.com/docker/docker/client"
+	"github.com/leonelquinteros/gotext"
 )
 
 // Conf is a Docker client configuration.
@@ -41,7 +41,7 @@ func New(serverName string, opts ...Opt) (*client.Client, error) {
 	if serverName != "default" {
 		context, err := GetContext(serverName)
 		if err != nil {
-			return nil, fmt.Errorf("unknown server, run \"abra server add %s\"?", serverName)
+			return nil, errors.New(gotext.Get("unknown server, run \"abra server add %s\"?", serverName))
 		}
 
 		ctxEndpoint, err := contextPkg.GetContextEndpoint(context)
@@ -85,7 +85,7 @@ func New(serverName string, opts ...Opt) (*client.Client, error) {
 		return nil, err
 	}
 
-	log.Debugf("created client for %s", serverName)
+	log.Debug(gotext.Get("created client for %s", serverName))
 
 	info, err := cl.Info(context.Background())
 	if err != nil {
@@ -94,10 +94,10 @@ func New(serverName string, opts ...Opt) (*client.Client, error) {
 
 	if info.Swarm.LocalNodeState == "inactive" {
 		if serverName != "default" {
-			return cl, fmt.Errorf("swarm mode not enabled on %s?", serverName)
+			return cl, errors.New(gotext.Get("swarm mode not enabled on %s?", serverName))
 		}
 
-		return cl, errors.New("swarm mode not enabled on local server?")
+		return cl, errors.New(gotext.Get("swarm mode not enabled on local server?"))
 	}
 
 	return cl, nil

pkg/client/configs.go

@@ -0,0 +1,39 @@
+package client
+
+import (
+	"context"
+	"errors"
+
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/docker/docker/client"
+	"github.com/leonelquinteros/gotext"
+)
+
+func GetConfigs(cl *client.Client, ctx context.Context, server string, fs filters.Args) ([]swarm.Config, error) {
+	configList, err := cl.ConfigList(ctx, swarm.ConfigListOptions{Filters: fs})
+	if err != nil {
+		return configList, err
+	}
+
+	return configList, nil
+}
+
+func GetConfigNames(configs []swarm.Config) []string {
+	var confNames []string
+
+	for _, conf := range configs {
+		confNames = append(confNames, conf.Spec.Name)
+	}
+
+	return confNames
+}
+
+func RemoveConfigs(cl *client.Client, ctx context.Context, configNames []string, force bool) error {
+	for _, confName := range configNames {
+		if err := cl.ConfigRemove(context.Background(), confName); err != nil {
+			return errors.New(gotext.Get("conf %s: %s", confName, err))
+		}
+	}
+	return nil
+}

pkg/client/context.go

@@ -10,6 +10,7 @@ import (
 	dConfig "github.com/docker/cli/cli/config"
 	"github.com/docker/cli/cli/context/docker"
 	contextStore "github.com/docker/cli/cli/context/store"
+	"github.com/leonelquinteros/gotext"
 )
 
 type Context = contextStore.Metadata
@@ -22,7 +23,7 @@ func CreateContext(contextName string) error {
 		return err
 	}
 
-	log.Debugf("created the %s context", contextName)
+	log.Debug(gotext.Get("created the %s context", contextName))
 
 	return nil
 }
@@ -62,7 +63,7 @@ func createContext(name string, host string) error {
 
 func DeleteContext(name string) error {
 	if name == "default" {
-		return errors.New("context 'default' cannot be removed")
+		return errors.New(gotext.Get("context 'default' cannot be removed"))
 	}
 
 	if _, err := GetContext(name); err != nil {

pkg/client/registry.go

@@ -2,11 +2,13 @@ package client
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"github.com/containers/image/docker"
 	"github.com/containers/image/types"
 	"github.com/distribution/reference"
+	"github.com/leonelquinteros/gotext"
 )
 
 // GetRegistryTags retrieves all tags of an image from a container registry.
@@ -15,7 +17,7 @@ func GetRegistryTags(img reference.Named) ([]string, error) {
 
 	ref, err := docker.ParseReference(fmt.Sprintf("//%s", img))
 	if err != nil {
-		return tags, fmt.Errorf("failed to parse image %s, saw: %s", img, err.Error())
+		return tags, errors.New(gotext.Get("failed to parse image %s, saw: %s", img, err.Error()))
 	}
 
 	ctx := context.Background()

pkg/client/volumes.go

@@ -2,6 +2,7 @@ package client
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"time"
 
@@ -9,6 +10,7 @@ import (
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/volume"
 	"github.com/docker/docker/client"
+	"github.com/leonelquinteros/gotext"
 )
 
 func GetVolumes(cl *client.Client, ctx context.Context, server string, fs filters.Args) ([]*volume.Volume, error) {
@@ -54,9 +56,9 @@ func retryFunc(retries int, fn func() error) error {
 		}
 		if i+1 < retries {
 			sleep := time.Duration(i+1) * time.Duration(i+1)
-			log.Infof("%s: waiting %d seconds before next retry", err, sleep)
+			log.Infof(gotext.Get("%s: waiting %d seconds before next retry", err, sleep))
 			time.Sleep(sleep * time.Second)
 		}
 	}
-	return fmt.Errorf("%d retries failed", retries)
+	return errors.New(gotext.Get("%d retries failed", retries))
 }

pkg/config/abra.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 
 	"coopcloud.tech/abra/pkg/log"
+	"github.com/leonelquinteros/gotext"
 	"gopkg.in/yaml.v3"
 )
 
@@ -16,13 +17,13 @@ func LoadAbraConfig() Abra {
 	wd, _ := os.Getwd()
 	configFile := findAbraConfig(wd)
 	if configFile == "" {
-		log.Debugf("no config file found")
+		log.Debug(gotext.Get("no config file found"))
 		return Abra{}
 	}
 	data, err := os.ReadFile(configFile)
 	if err != nil {
 		// Do nothing, when an error occurs
-		log.Debugf("error reading config file: %s", err)
+		log.Debug(gotext.Get("error reading config file: %s", err))
 		return Abra{}
 	}
 
@@ -30,10 +31,10 @@ func LoadAbraConfig() Abra {
 	err = yaml.Unmarshal(data, &config)
 	if err != nil {
 		// Do nothing, when an error occurs
-		log.Debugf("error loading config file: %s", err)
+		log.Debug(gotext.Get("error loading config file: %s", err))
 		return Abra{}
 	}
-	log.Debugf("config file loaded from: %s", configFile)
+	log.Debug(gotext.Get("config file loaded from: %s", configFile))
 	config.configPath = filepath.Dir(configFile)
 	return config
 }
@@ -73,39 +74,50 @@ type Abra struct {
 // 3. use $HOME/.abra when above two options failed
 func (a Abra) GetAbraDir() string {
 	if dir, exists := os.LookupEnv("ABRA_DIR"); exists && dir != "" {
-		log.Debug("read abra dir from $ABRA_DIR")
+		log.Debug(gotext.Get("read abra dir from $ABRA_DIR"))
 		return dir
 	}
 	if a.AbraDir != "" {
-		log.Debug("read abra dir from config file")
+		log.Debug(gotext.Get("read abra dir from config file"))
 		if path.IsAbs(a.AbraDir) {
 			return a.AbraDir
 		}
 		// Make the path absolute
 		return path.Join(a.configPath, a.AbraDir)
 	}
-	log.Debug("using default abra dir")
+	log.Debug(gotext.Get("using default abra dir"))
 	return os.ExpandEnv("$HOME/.abra")
 }
 
 func (a Abra) GetServersDir() string   { return path.Join(a.GetAbraDir(), "servers") }
 func (a Abra) GetRecipesDir() string   { return path.Join(a.GetAbraDir(), "recipes") }
-func (a Abra) GetVendorDir() string    { return path.Join(a.GetAbraDir(), "vendor") }
-func (a Abra) GetBackupDir() string    { return path.Join(a.GetAbraDir(), "backups") }
+func (a Abra) GetLogsDir() string      { return path.Join(a.GetAbraDir(), "logs") }
 func (a Abra) GetCatalogueDir() string { return path.Join(a.GetAbraDir(), "catalogue") }
 
 var config = LoadAbraConfig()
 
 var (
-	ABRA_DIR                 = config.GetAbraDir()
-	SERVERS_DIR              = config.GetServersDir()
-	RECIPES_DIR              = config.GetRecipesDir()
-	VENDOR_DIR               = config.GetVendorDir()
-	BACKUP_DIR               = config.GetBackupDir()
-	CATALOGUE_DIR            = config.GetCatalogueDir()
-	RECIPES_JSON             = path.Join(config.GetCatalogueDir(), "recipes.json")
-	REPOS_BASE_URL           = "https://git.coopcloud.tech/coop-cloud"
-	CATALOGUE_JSON_REPO_NAME = "recipes-catalogue-json"
-	SSH_URL_TEMPLATE         = "ssh://git@git.coopcloud.tech:2222/coop-cloud/%s.git"
-	CHAOS_DEFAULT            = "false"
+	ABRA_DIR                  = config.GetAbraDir()
+	SERVERS_DIR               = config.GetServersDir()
+	RECIPES_DIR               = config.GetRecipesDir()
+	LOGS_DIR                  = config.GetLogsDir()
+	CATALOGUE_DIR             = config.GetCatalogueDir()
+	RECIPES_JSON              = path.Join(config.GetCatalogueDir(), "recipes.json")
+	REPOS_BASE_URL            = "https://git.coopcloud.tech/coop-cloud"
+	CATALOGUE_JSON_REPO_NAME  = "recipes-catalogue-json"
+	TOOLSHED_SSH_URL_TEMPLATE = "ssh://git@git.coopcloud.tech:2222/toolshed/%s.git"
+	RECIPES_SSH_URL_TEMPLATE  = "ssh://git@git.coopcloud.tech:2222/coop-cloud/%s.git"
+
+	// NOTE(d1): please note, this was done purely out of laziness on our part
+	// AFAICR. it's easy to punt the value into the label because that is what is
+	// expects. it's not particularly useful in terms of UI/UX but hey, nobody
+	// complained yet!
+	CHAOS_DEFAULT = "false"
+
+	DIRTY_DEFAULT = "+U"
+
+	NO_DOMAIN_DEFAULT  = "N/A"
+	NO_VERSION_DEFAULT = "N/A"
+
+	UNKNOWN_DEFAULT = "unknown"
 )

pkg/config/env.go

@@ -1,7 +1,7 @@
 package config
 
 import (
-	"fmt"
+	"errors"
 	"io/fs"
 	"io/ioutil"
 	"os"
@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"coopcloud.tech/abra/pkg/log"
+	"github.com/leonelquinteros/gotext"
 )
 
 const MAX_SANITISED_APP_NAME_LENGTH = 45
@@ -26,9 +27,16 @@ func GetServers() ([]string, error) {
 		return servers, err
 	}
 
-	log.Debugf("retrieved %v servers: %s", len(servers), servers)
+	var filtered []string
+	for _, s := range servers {
+		if !strings.HasPrefix(s, ".") {
+			filtered = append(filtered, s)
+		}
+	}
 
-	return servers, nil
+	log.Debug(gotext.Get("retrieved %v servers: %s", len(filtered), filtered))
+
+	return filtered, nil
 }
 
 // ReadServerNames retrieves all server names.
@@ -39,7 +47,7 @@ func ReadServerNames() ([]string, error) {
 		return nil, err
 	}
 
-	log.Debugf("read %s from %s", strings.Join(serverNames, ","), SERVERS_DIR)
+	log.Debug(gotext.Get("read %s from %s", strings.Join(serverNames, ","), SERVERS_DIR))
 
 	return serverNames, nil
 }
@@ -63,7 +71,7 @@ func GetAllFilesInDirectory(directory string) ([]fs.FileInfo, error) {
 
 		realPath, err := filepath.EvalSymlinks(filePath)
 		if err != nil {
-			log.Warnf("broken symlink in your abra config folders: %s", filePath)
+			log.Warnf(gotext.Get("broken symlink in your abra config folders: %s", filePath))
 		} else {
 			realFile, err := os.Stat(realPath)
 			if err != nil {
@@ -87,7 +95,7 @@ func GetAllFoldersInDirectory(directory string) ([]string, error) {
 		return nil, err
 	}
 	if len(files) == 0 {
-		return nil, fmt.Errorf("directory is empty: %s", directory)
+		return nil, errors.New(gotext.Get("directory is empty: %s", directory))
 	}
 
 	for _, file := range files {
@@ -96,7 +104,7 @@ func GetAllFoldersInDirectory(directory string) ([]string, error) {
 			filePath := path.Join(directory, file.Name())
 			realDir, err := filepath.EvalSymlinks(filePath)
 			if err != nil {
-				log.Warnf("broken symlink in your abra config folders: %s", filePath)
+				log.Warnf(gotext.Get("broken symlink in your abra config folders: %s", filePath))
 			} else if stat, err := os.Stat(realDir); err == nil && stat.IsDir() {
 				// path is a directory
 				folders = append(folders, file.Name())

pkg/container/container.go

@@ -2,6 +2,7 @@ package container
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strings"
 
@@ -12,6 +13,7 @@ import (
 	containerTypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/client"
+	"github.com/leonelquinteros/gotext"
 )
 
 // GetContainer retrieves a container. If noInput is false and the retrievd
@@ -26,7 +28,7 @@ func GetContainer(c context.Context, cl *client.Client, filters filters.Args, no
 
 	if len(containers) == 0 {
 		filter := filters.Get("name")[0]
-		return types.Container{}, fmt.Errorf("no containers matching the %v filter found?", filter)
+		return types.Container{}, errors.New(gotext.Get("no containers matching the %v filter found?", filter))
 	}
 
 	if len(containers) > 1 {
@@ -35,19 +37,19 @@ func GetContainer(c context.Context, cl *client.Client, filters filters.Args, no
 			containerName := strings.Join(container.Names, " ")
 			trimmed := strings.TrimPrefix(containerName, "/")
 			created := formatter.HumanDuration(container.Created)
-			containersRaw = append(containersRaw, fmt.Sprintf("%s (created %v)", trimmed, created))
+			containersRaw = append(containersRaw, gotext.Get("%s (created %v)", trimmed, created))
 		}
 
 		if noInput {
-			err := fmt.Errorf("expected 1 container but found %v: %s", len(containers), strings.Join(containersRaw, " "))
+			err := errors.New(gotext.Get("expected 1 container but found %v: %s", len(containers), strings.Join(containersRaw, " ")))
 			return types.Container{}, err
 		}
 
-		log.Warnf("ambiguous container list received, prompting for input")
+		log.Warnf(gotext.Get("ambiguous container list received, prompting for input"))
 
 		var response string
 		prompt := &survey.Select{
-			Message: "which container are you looking for?",
+			Message: gotext.Get("which container are you looking for?"),
 			Options: containersRaw,
 		}
 
@@ -64,7 +66,7 @@ func GetContainer(c context.Context, cl *client.Client, filters filters.Args, no
 			}
 		}
 
-		log.Fatal("failed to match chosen container")
+		log.Fatal(gotext.Get("failed to match chosen container"))
 	}
 
 	return containers[0], nil
@@ -79,5 +81,6 @@ func GetContainerFromStackAndService(cl *client.Client, stack, service string) (
 	if err != nil {
 		return types.Container{}, err
 	}
+
 	return container, nil
 }

pkg/context/context.go

@@ -8,6 +8,7 @@ import (
 	"github.com/docker/cli/cli/context"
 	contextStore "github.com/docker/cli/cli/context/store"
 	cliflags "github.com/docker/cli/cli/flags"
+	"github.com/leonelquinteros/gotext"
 )
 
 func NewDefaultDockerContextStore() *command.ContextStoreWithDefault {
@@ -30,7 +31,7 @@ func NewDefaultDockerContextStore() *command.ContextStoreWithDefault {
 func GetContextEndpoint(ctx contextStore.Metadata) (string, error) {
 	endpointmeta, ok := ctx.Endpoints["docker"].(context.EndpointMetaBase)
 	if !ok {
-		err := errors.New("context lacks Docker endpoint")
+		err := errors.New(gotext.Get("context lacks Docker endpoint"))
 		return "", err
 	}
 	return endpointmeta.Host, nil

pkg/dns/dns.go

@@ -1,20 +1,21 @@
 package dns
 
 import (
-	"fmt"
+	"errors"
 	"net"
+
+	"github.com/leonelquinteros/gotext"
 )
 
 // EnsureIPv4 ensures that an ipv4 address is set for a domain name
 func EnsureIPv4(domainName string) (string, error) {
 	ipv4, err := net.ResolveIPAddr("ip4", domainName)
 	if err != nil {
-		return "", fmt.Errorf("unable to resolve ipv4 address for %s, %s", domainName, err)
+		return "", errors.New(gotext.Get("%s: unable to resolve IPv4 address: %s", domainName, err))
 	}
 
-	// NOTE(d1): e.g. when there is only an ipv6 record available
 	if ipv4 == nil {
-		return "", fmt.Errorf("unable to resolve ipv4 address for %s", domainName)
+		return "", errors.New(gotext.Get("%s: no IPv4 available", domainName))
 	}
 
 	return ipv4.String(), nil
@@ -34,7 +35,7 @@ func EnsureDomainsResolveSameIPv4(domainName, server string) (string, error) {
 	}
 
 	if domainIPv4 == "" {
-		return ipv4, fmt.Errorf("cannot resolve ipv4 for %s?", domainName)
+		return ipv4, errors.New(gotext.Get("cannot resolve ipv4 for %s?", domainName))
 	}
 
 	serverIPv4, err := EnsureIPv4(server)
@@ -43,12 +44,16 @@ func EnsureDomainsResolveSameIPv4(domainName, server string) (string, error) {
 	}
 
 	if serverIPv4 == "" {
-		return ipv4, fmt.Errorf("cannot resolve ipv4 for %s?", server)
+		return ipv4, errors.New(gotext.Get("cannot resolve ipv4 for %s?", server))
 	}
 
 	if domainIPv4 != serverIPv4 {
-		err := "app domain %s (%s) does not appear to resolve to app server %s (%s)?"
-		return ipv4, fmt.Errorf(err, domainName, domainIPv4, server, serverIPv4)
+		return ipv4, errors.New(
+			gotext.Get(
+				"app domain %s (%s) does not appear to resolve to app server %s (%s)?",
+				domainName, domainIPv4, server, serverIPv4,
+			),
+		)
 	}
 
 	return ipv4, nil

pkg/dns/dns_test.go

@@ -17,8 +17,8 @@ func TestEnsureDomainsResolveSameIPv4(t *testing.T) {
 		// within the federation. if you're here because of a failing test, try
 		// `dig +short <domain>` to ensure stuff matches first! If flakyness
 		// becomes an issue we can look into mocking
+		{"docs.coopcloud.tech", "swarm-0.coopcloud.tech", true},
 		{"docs.coopcloud.tech", "coopcloud.tech", true},
-		{"docs.coopcloud.tech", "swarm.autonomic.zone", true},
 
 		// NOTE(d1): special case handling for "--local"
 		{"", "default", true},

pkg/envfile/envfile.go

@@ -2,20 +2,16 @@ package envfile
 
 import (
 	"bufio"
-	"fmt"
+	"errors"
 	"os"
 	"regexp"
 	"strings"
 
 	"coopcloud.tech/abra/pkg/log"
-	"git.coopcloud.tech/coop-cloud/godotenv"
+	"git.coopcloud.tech/toolshed/godotenv"
+	"github.com/leonelquinteros/gotext"
 )
 
-// envVarModifiers is a list of env var modifier strings. These are added to
-// env vars as comments and modify their processing by Abra, e.g. determining
-// how long secrets should be.
-var envVarModifiers = []string{"length"}
-
 // AppEnv is a map of the values in an apps env config
 type AppEnv = map[string]string
 
@@ -31,8 +27,6 @@ func ReadEnv(filePath string) (AppEnv, error) {
 		return nil, err
 	}
 
-	log.Debugf("read %s from %s", envVars, filePath)
-
 	return envVars, nil
 }
 
@@ -45,7 +39,7 @@ func ReadEnvWithModifiers(filePath string) (AppEnv, AppModifiers, error) {
 		return nil, mods, err
 	}
 
-	log.Debugf("read %s from %s", envVars, filePath)
+	log.Debug(gotext.Get("read %s from %s", envVars, filePath))
 
 	return envVars, mods, nil
 }
@@ -76,16 +70,16 @@ func ReadAbraShEnvVars(abraSh string) (map[string]string, error) {
 			envVarDef := splitVals[len(splitVals)-1]
 			keyVal := strings.Split(envVarDef, "=")
 			if len(keyVal) != 2 {
-				return envVars, fmt.Errorf("couldn't parse %s", txt)
+				return envVars, errors.New(gotext.Get("couldn't parse %s", txt))
 			}
 			envVars[keyVal[0]] = keyVal[1]
 		}
 	}
 
 	if len(envVars) > 0 {
-		log.Debugf("read %s from %s", envVars, abraSh)
+		log.Debug(gotext.Get("read %s from %s", envVars, abraSh))
 	} else {
-		log.Debugf("read 0 env var exports from %s", abraSh)
+		log.Debug(gotext.Get("read 0 env var exports from %s", abraSh))
 	}
 
 	return envVars, nil

pkg/envfile/envfile_test.go

@@ -192,7 +192,7 @@ func TestEnvVarCommentsRemoved(t *testing.T) {
 
 	envVar, exists = envSample["SECRET_TEST_PASS_TWO_VERSION"]
 	if !exists {
-		t.Fatal("WITH_COMMENT env var should be present in .env.sample")
+		t.Fatal("SECRET_TEST_PASS_TWO_VERSION env var should be present in .env.sample")
 	}
 
 	if strings.Contains(envVar, "length") {

pkg/formatter/formatter.go

@@ -11,13 +11,18 @@ import (
 	"github.com/charmbracelet/lipgloss"
 	"github.com/charmbracelet/lipgloss/table"
 	"github.com/docker/go-units"
+	"github.com/leonelquinteros/gotext"
 	"golang.org/x/term"
 
+	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/schollz/progressbar/v3"
 )
 
 var BoldStyle = lipgloss.NewStyle().
+	Bold(true)
+
+var BoldUnderlineStyle = lipgloss.NewStyle().
 	Bold(true).
 	Underline(true)
 
@@ -38,38 +43,139 @@ func RemoveSha(str string) string {
 func HumanDuration(timestamp int64) string {
 	date := time.Unix(timestamp, 0)
 	now := time.Now().UTC()
-	return units.HumanDuration(now.Sub(date)) + " ago"
+	return units.HumanDuration(now.Sub(date)) + gotext.Get(" ago")
 }
 
 // CreateTable prepares a table layout for output.
 func CreateTable() (*table.Table, error) {
+	var (
+		renderer    = lipgloss.NewRenderer(os.Stdout)
+		headerStyle = renderer.NewStyle().Bold(true).Align(lipgloss.Center)
+		cellStyle   = renderer.NewStyle().Padding(0, 1)
+		borderStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("63"))
+	)
+
 	table := table.New().
 		Border(lipgloss.ThickBorder()).
-		BorderStyle(
-			lipgloss.NewStyle().
-				Foreground(lipgloss.Color("63")),
-		)
+		BorderStyle(borderStyle).
+		StyleFunc(func(row, col int) lipgloss.Style {
+			var style lipgloss.Style
 
+			switch {
+			case row == table.HeaderRow:
+				return headerStyle
+			default:
+				style = cellStyle
+			}
+
+			return style
+		})
+
+	return table, nil
+}
+
+func PrintTable(t *table.Table) error {
 	if isAbraCI, ok := os.LookupEnv("ABRA_CI"); ok && isAbraCI == "1" {
 		// NOTE(d1): no width limits for CI testing since we test against outputs
-		log.Debug("detected ABRA_CI=1")
-		return table, nil
+		log.Debug(gotext.Get("detected ABRA_CI=1"))
+		fmt.Println(t)
+		return nil
 	}
 
+	tWidth, _ := lipgloss.Size(t.String())
+
 	width, _, err := term.GetSize(0)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	if width-10 < 79 {
-		// NOTE(d1): maintain standard minimum width
-		table.Width(79)
-	} else {
-		// NOTE(d1): tests show that this produces stable border drawing
-		table.Width(width - 10)
+	if tWidth > width {
+		t.Width(width - 10)
 	}
 
-	return table, nil
+	fmt.Println(t)
+
+	return nil
+}
+
+// horizontal is a JoinHorizontal helper function.
+func horizontal(left, mid, right string) string {
+	return lipgloss.JoinHorizontal(lipgloss.Right, left, mid, right)
+}
+
+func CreateOverview(header string, rows [][]string) string {
+	var borderStyle = lipgloss.NewStyle().
+		BorderStyle(lipgloss.ThickBorder()).
+		Padding(0, 1, 0, 1).
+		BorderForeground(lipgloss.Color("63"))
+
+	var headerStyle = lipgloss.NewStyle().
+		Underline(true).
+		Bold(true).
+		PaddingBottom(1)
+
+	var leftStyle = lipgloss.NewStyle()
+	var rightStyle = lipgloss.NewStyle()
+
+	var longest int
+	for _, row := range rows {
+		if len(row[0]) > longest {
+			longest = len(row[0])
+		}
+	}
+
+	var renderedRows []string
+	for _, row := range rows {
+		if len(row) < 2 {
+			continue
+		}
+
+		if len(row) > 2 {
+			panic(gotext.Get("CreateOverview: only accepts rows of len == 2"))
+		}
+
+		lenOffset := 4
+		if len(row[0]) < longest {
+			lenOffset += longest - len(row[0])
+		}
+
+		offset := ""
+		for range lenOffset {
+			offset = offset + " "
+		}
+
+		rendered := horizontal(leftStyle.Render(row[0]), offset, rightStyle.Render(row[1]))
+
+		if row[1] == "---" {
+			rendered = horizontal(
+				leftStyle.
+					Bold(true).
+					Underline(true).
+					PaddingTop(1).
+					Render(row[0]),
+				offset,
+				rightStyle.Render(""),
+			)
+		}
+
+		renderedRows = append(renderedRows, rendered)
+	}
+
+	body := strings.Builder{}
+	body.WriteString(
+		borderStyle.Render(
+			lipgloss.JoinVertical(
+				lipgloss.Center,
+				headerStyle.Render(header),
+				lipgloss.JoinVertical(
+					lipgloss.Left,
+					renderedRows...,
+				),
+			),
+		),
+	)
+
+	return body.String()
 }
 
 // ToJSON converts a lipgloss.Table to JSON representation. It's not a robust
@@ -112,7 +218,6 @@ func CreateProgressbar(length int, title string) *progressbar.ProgressBar {
 		progressbar.OptionClearOnFinish(),
 		progressbar.OptionSetPredictTime(false),
 		progressbar.OptionShowCount(),
-		progressbar.OptionFullWidth(),
 		progressbar.OptionSetDescription(title),
 	)
 }
@@ -130,7 +235,7 @@ func StripTagMeta(image string) string {
 	}
 
 	if originalImage != image {
-		log.Debugf("stripped %s to %s for parsing", originalImage, image)
+		log.Debug(gotext.Get("stripped %s to %s for parsing", originalImage, image))
 	}
 
 	return image
@@ -153,3 +258,18 @@ func ByteCountSI(b uint64) string {
 
 	return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "kMGTPE"[exp])
 }
+
+// BoldDirtyDefault ensures a dirty modifier is rendered in bold.
+func BoldDirtyDefault(v string) string {
+	if strings.HasSuffix(v, config.DIRTY_DEFAULT) {
+		vBold := BoldStyle.Render(config.DIRTY_DEFAULT)
+		v = strings.Replace(v, config.DIRTY_DEFAULT, vBold, 1)
+	}
+
+	return v
+}
+
+// AddDirtyMarker adds the dirty marker to a version string.
+func AddDirtyMarker(v string) string {
+	return fmt.Sprintf("%s%s", v, config.DIRTY_DEFAULT)
+}

pkg/formatter/formatter_test.go

@@ -0,0 +1,11 @@
+package formatter
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBoldDirtyDefault(t *testing.T) {
+	assert.Equal(t, "foo", BoldDirtyDefault("foo"))
+}

pkg/git/add.go

@@ -3,6 +3,7 @@ package git
 import (
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
+	"github.com/leonelquinteros/gotext"
 )
 
 // Add adds a file to the git index.
@@ -18,7 +19,7 @@ func Add(repoPath, path string, dryRun bool) error {
 	}
 
 	if dryRun {
-		log.Debugf("dry run: adding %s", path)
+		log.Debug(gotext.Get("dry run: adding %s", path))
 	} else {
 		worktree.Add(path)
 	}

pkg/git/branch.go

@@ -1,11 +1,13 @@
 package git
 
 import (
+	"errors"
 	"fmt"
 
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/leonelquinteros/gotext"
 )
 
 // Check if a branch exists in a repo. Use this and not repository.Branch(),
@@ -63,7 +65,7 @@ func GetDefaultBranch(repo *git.Repository, repoPath string) (plumbing.Reference
 
 	if !HasBranch(repo, "master") {
 		if !HasBranch(repo, "main") {
-			return "", fmt.Errorf("failed to select default branch in %s", repoPath)
+			return "", errors.New(gotext.Get("failed to select default branch in %s", repoPath))
 		}
 		branch = "main"
 	}
@@ -90,11 +92,11 @@ func CheckoutDefaultBranch(repo *git.Repository, repoPath string) (plumbing.Refe
 	}
 
 	if err := worktree.Checkout(checkOutOpts); err != nil {
-		log.Debugf("failed to check out %s in %s", branch, repoPath)
+		log.Debug(gotext.Get("failed to check out %s in %s", branch, repoPath))
 		return branch, err
 	}
 
-	log.Debugf("successfully checked out %v in %s", branch, repoPath)
+	log.Debug(gotext.Get("successfully checked out %v in %s", branch, repoPath))
 
 	return branch, nil
 }

pkg/git/clone.go

@@ -1,49 +1,107 @@
 package git
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"os"
-	"path/filepath"
+	"os/signal"
 	"strings"
 
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/leonelquinteros/gotext"
 )
 
-// Clone runs a git clone which accounts for different default branches.
+// gitCloneIgnoreErr checks whether we can ignore a git clone error or not.
+func gitCloneIgnoreErr(err error) bool {
+	if strings.Contains(err.Error(), "authentication required") {
+		return true
+	}
+
+	if strings.Contains(err.Error(), "remote repository is empty") {
+		return true
+	}
+
+	return false
+}
+
+// Clone runs a git clone which accounts for different default branches. This
+// function respects Ctrl+C (SIGINT) calls from the user, cancelling the
+// context and deleting the (typically) half-baked clone of the repository.
+// This avoids broken state for future clone / recipe ops.
 func Clone(dir, url string) error {
-	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		log.Debugf("%s does not exist, attempting to git clone from %s", dir, url)
+	ctx := context.Background()
+	ctx, cancelCtx := context.WithCancel(ctx)
 
-		_, err := git.PlainClone(dir, false, &git.CloneOptions{
-			URL:           url,
-			Tags:          git.AllTags,
-			ReferenceName: plumbing.ReferenceName("refs/heads/master"),
-			SingleBranch:  true,
-		})
-		if err != nil {
-			log.Debugf("cloning %s default branch failed, attempting from main branch", url)
+	sigIntCh := make(chan os.Signal, 1)
+	signal.Notify(sigIntCh, os.Interrupt)
+	defer func() {
+		signal.Stop(sigIntCh)
+		cancelCtx()
+	}()
 
-			_, err := git.PlainClone(dir, false, &git.CloneOptions{
+	errCh := make(chan error)
+
+	go func() {
+		if _, err := os.Stat(dir); os.IsNotExist(err) {
+			log.Debug(gotext.Get("git clone: %s", url))
+
+			_, err := git.PlainCloneContext(ctx, dir, false, &git.CloneOptions{
 				URL:           url,
 				Tags:          git.AllTags,
 				ReferenceName: plumbing.ReferenceName("refs/heads/main"),
 				SingleBranch:  true,
 			})
+
+			if err != nil && gitCloneIgnoreErr(err) {
+				log.Debug(gotext.Get("git clone: %s cloned successfully", dir))
+				errCh <- nil
+			}
+
+			if err := ctx.Err(); err != nil {
+				errCh <- errors.New(gotext.Get("git clone %s: cancelled due to interrupt", dir))
+			}
+
 			if err != nil {
-				if strings.Contains(err.Error(), "authentication required") {
-					name := filepath.Base(dir)
-					return fmt.Errorf("unable to clone %s, does %s exist?", name, url)
+				log.Debug(gotext.Get("git clone: main branch failed, attempting master branch"))
+
+				_, err := git.PlainCloneContext(ctx, dir, false, &git.CloneOptions{
+					URL:           url,
+					Tags:          git.AllTags,
+					ReferenceName: plumbing.ReferenceName("refs/heads/master"),
+					SingleBranch:  true,
+				})
+
+				if err != nil && gitCloneIgnoreErr(err) {
+					log.Debug(gotext.Get("git clone: %s cloned successfully", dir))
+					errCh <- nil
 				}
 
-				return err
+				if err != nil {
+					errCh <- err
+				}
 			}
+
+			log.Debug(gotext.Get("git clone: %s cloned successfully", dir))
+		} else {
+			log.Debug(gotext.Get("git clone: %s already exists", dir))
 		}
 
-		log.Debugf("%s has been git cloned successfully", dir)
-	} else {
-		log.Debugf("%s already exists", dir)
+		errCh <- nil
+	}()
+
+	select {
+	case <-sigIntCh:
+		cancelCtx()
+		fmt.Println() // NOTE(d1): newline after ^C
+		if err := os.RemoveAll(dir); err != nil {
+			return errors.New(gotext.Get("unable to clean up git clone of %s: %s", dir, err))
+		}
+		return errors.New(gotext.Get("git clone %s: cancelled due to interrupt", dir))
+	case err := <-errCh:
+		return err
 	}
 
 	return nil

pkg/git/clone_test.go

@@ -0,0 +1,48 @@
+package git
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"syscall"
+	"testing"
+
+	"coopcloud.tech/abra/pkg/config"
+)
+
+func TestClone(t *testing.T) {
+	dir := path.Join(config.RECIPES_DIR, "gitea")
+	os.RemoveAll(dir)
+
+	gitURL := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, "gitea")
+	if err := Clone(dir, gitURL); err != nil {
+		t.Fatalf("unable to git clone gitea: %s", err)
+	}
+
+	if _, err := os.Stat(dir); err != nil && os.IsNotExist(err) {
+		t.Fatal("gitea repo was not cloned successfully")
+	}
+}
+
+func TestCancelGitClone(t *testing.T) {
+	dir := path.Join(config.RECIPES_DIR, "gitea")
+	os.RemoveAll(dir)
+
+	go func() {
+		p, err := os.FindProcess(os.Getpid())
+		if err != nil {
+			t.Fatalf("unable to find current process: %s", err)
+		}
+
+		p.Signal(syscall.SIGINT)
+	}()
+
+	gitURL := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, "gitea")
+	if err := Clone(dir, gitURL); err == nil {
+		t.Fatal("cloning should have been interrupted")
+	}
+
+	if _, err := os.Stat(dir); err != nil && !os.IsNotExist(err) {
+		t.Fatal("recipe repo was not deleted")
+	}
+}

pkg/git/commit.go

@@ -1,16 +1,17 @@
 package git
 
 import (
-	"fmt"
+	"errors"
 
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
+	"github.com/leonelquinteros/gotext"
 )
 
 // Commit runs a git commit
 func Commit(repoPath, commitMessage string, dryRun bool) error {
 	if commitMessage == "" {
-		return fmt.Errorf("no commit message specified?")
+		return errors.New(gotext.Get("no commit message specified?"))
 	}
 
 	commitRepo, err := git.PlainOpen(repoPath)
@@ -38,9 +39,9 @@ func Commit(repoPath, commitMessage string, dryRun bool) error {
 		if err != nil {
 			return err
 		}
-		log.Debug("git changes commited")
+		log.Debug(gotext.Get("git changes commited"))
 	} else {
-		log.Debug("dry run: no changes commited")
+		log.Debug(gotext.Get("dry run: no changes commited"))
 	}
 
 	return nil

pkg/git/common.go

@@ -1,14 +1,16 @@
 package git
 
 import (
-	"fmt"
+	"errors"
 	"os"
+
+	"github.com/leonelquinteros/gotext"
 )
 
 // EnsureGitRepo ensures a git repo .git folder exists
 func EnsureGitRepo(repoPath string) error {
 	if _, err := os.Stat(repoPath); os.IsNotExist(err) {
-		return fmt.Errorf("no .git directory in %s?", repoPath)
+		return errors.New(gotext.Get("no .git directory in %s?", repoPath))
 	}
 	return nil
 }

pkg/git/diff.go

@@ -5,6 +5,7 @@ import (
 	"os/exec"
 
 	"coopcloud.tech/abra/pkg/log"
+	"github.com/leonelquinteros/gotext"
 )
 
 // getGitDiffArgs builds the `git diff` invocation args. It removes the usage
@@ -26,7 +27,7 @@ func getGitDiffArgs(repoPath string) []string {
 // skips if it cannot find the command on the system.
 func DiffUnstaged(path string) error {
 	if _, err := exec.LookPath("git"); err != nil {
-		log.Warnf("unable to locate git command, cannot output diff")
+		log.Warnf(gotext.Get("unable to locate git command, cannot output diff"))
 		return nil
 	}
 

pkg/git/init.go

@@ -1,44 +1,76 @@
 package git
 
 import (
-	"fmt"
+	"errors"
 
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/object"
+	"github.com/leonelquinteros/gotext"
 )
 
 // Init inits a new repo and commits all the stuff if you want
 func Init(repoPath string, commit bool, gitName, gitEmail string) error {
-	if _, err := git.PlainInit(repoPath, false); err != nil {
-		return fmt.Errorf("git init: %s", err)
+	repo, err := git.PlainInit(repoPath, false)
+	if err != nil {
+		return errors.New(gotext.Get("git init: %s", err))
 	}
-	log.Debugf("initialised new git repo in %s", repoPath)
+
+	if err = SwitchToMain(repo); err != nil {
+		return errors.New(gotext.Get("git branch rename: %s", err))
+	}
+
+	log.Debug(gotext.Get("initialised new git repo in %s", repoPath))
 
 	if commit {
 		commitRepo, err := git.PlainOpen(repoPath)
 		if err != nil {
-			return fmt.Errorf("git open: %s", err)
+			return errors.New(gotext.Get("git open: %s", err))
 		}
 
 		commitWorktree, err := commitRepo.Worktree()
 		if err != nil {
-			return fmt.Errorf("git worktree: %s", err)
+			return errors.New(gotext.Get("git worktree: %s", err))
 		}
 
 		if err := commitWorktree.AddWithOptions(&git.AddOptions{All: true}); err != nil {
-			return fmt.Errorf("git add: %s", err)
+			return errors.New(gotext.Get("git add: %s", err))
 		}
 
 		var author *object.Signature
 		if gitName != "" && gitEmail != "" {
 			author = &object.Signature{Name: gitName, Email: gitEmail}
 		}
+
 		if _, err = commitWorktree.Commit("init", &git.CommitOptions{Author: author}); err != nil {
-			return fmt.Errorf("git commit: %s", err)
+			return errors.New(gotext.Get("git commit: %s", err))
 		}
-		log.Debugf("init committed all files for new git repo in %s", repoPath)
+
+		log.Debug(gotext.Get("init committed all files for new git repo in %s", repoPath))
 	}
 
 	return nil
 }
+
+// SwitchToMain sets the default branch to "main".
+func SwitchToMain(repo *git.Repository) error {
+	ref := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.ReferenceName("refs/heads/main"))
+	if err := repo.Storer.SetReference(ref); err != nil {
+		return errors.New(gotext.Get("set reference: %s", err))
+	}
+
+	cfg, err := repo.Config()
+	if err != nil {
+		return errors.New(gotext.Get("repo config: %s", err))
+	}
+
+	cfg.Init.DefaultBranch = "main"
+	if err := repo.SetConfig(cfg); err != nil {
+		return errors.New(gotext.Get("repo set config: %s", err))
+	}
+
+	log.Debug(gotext.Get("set 'main' as the default branch"))
+
+	return nil
+}

pkg/git/init_test.go

@@ -0,0 +1,35 @@
+package git
+
+import (
+	"testing"
+
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/storage/memory"
+)
+
+func TestSwitchToMain(t *testing.T) {
+	repo, err := git.Init(memory.NewStorage(), nil)
+	if err != nil {
+		t.Fatalf("failed to create in-memory repository: %v", err)
+	}
+	if err = SwitchToMain(repo); err != nil {
+		t.Fatalf("SwitchToMain failed: %v", err)
+	}
+
+	ref, err := repo.Reference(plumbing.HEAD, false)
+	if err != nil {
+		t.Fatalf("failed to get HEAD reference: %v", err)
+	}
+	if ref.Target().String() != "refs/heads/main" {
+		t.Errorf("expected HEAD to point to 'refs/heads/main', got %s", ref.Target().String())
+	}
+
+	cfg, err := repo.Config()
+	if err != nil {
+		t.Fatalf("failed to get repository config: %v", err)
+	}
+	if cfg.Init.DefaultBranch != "main" {
+		t.Errorf("expected default branch to be 'main', got %s", cfg.Init.DefaultBranch)
+	}
+}

pkg/git/push.go

@@ -4,12 +4,13 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/config"
+	"github.com/leonelquinteros/gotext"
 )
 
 // Push pushes the latest changes & optionally tags to the default remote
 func Push(repoDir string, remote string, tags bool, dryRun bool) error {
 	if dryRun {
-		log.Debugf("dry run: no git changes pushed in %s", repoDir)
+		log.Debug(gotext.Get("dry run: no git changes pushed in %s", repoDir))
 		return nil
 	}
 
@@ -27,7 +28,7 @@ func Push(repoDir string, remote string, tags bool, dryRun bool) error {
 		return err
 	}
 
-	log.Debugf("git changes pushed")
+	log.Debug(gotext.Get("git changes pushed"))
 
 	if tags {
 		opts.RefSpecs = append(opts.RefSpecs, config.RefSpec("+refs/tags/*:refs/tags/*"))
@@ -36,7 +37,7 @@ func Push(repoDir string, remote string, tags bool, dryRun bool) error {
 			return err
 		}
 
-		log.Debugf("git tags pushed")
+		log.Debug(gotext.Get("git tags pushed"))
 	}
 
 	return nil

pkg/git/read.go

@@ -1,6 +1,7 @@
 package git
 
 import (
+	"errors"
 	"io/ioutil"
 	"os"
 	"os/user"
@@ -11,18 +12,23 @@ import (
 	"github.com/go-git/go-git/v5"
 	gitConfigPkg "github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/plumbing/format/gitignore"
+	"github.com/leonelquinteros/gotext"
 )
 
 // IsClean checks if a repo has unstaged changes
 func IsClean(repoPath string) (bool, error) {
 	repo, err := git.PlainOpen(repoPath)
 	if err != nil {
-		return false, err
+		if errors.Is(err, git.ErrRepositoryNotExists) {
+			return false, git.ErrRepositoryNotExists
+		}
+
+		return false, errors.New(gotext.Get("unable to open %s: %s", repoPath, err))
 	}
 
 	worktree, err := repo.Worktree()
 	if err != nil {
-		return false, err
+		return false, errors.New(gotext.Get("unable to open worktree of %s: %s", repoPath, err))
 	}
 
 	patterns, err := GetExcludesFiles()
@@ -36,13 +42,14 @@ func IsClean(repoPath string) (bool, error) {
 
 	status, err := worktree.Status()
 	if err != nil {
-		return false, err
+		return false, errors.New(gotext.Get("unable to query status of %s: %s", repoPath, err))
 	}
 
 	if status.String() != "" {
-		log.Debugf("discovered git status in %s: %s", repoPath, status.String())
+		noNewline := strings.TrimSuffix(status.String(), "\n")
+		log.Debug(gotext.Get("git status: %s: %s", repoPath, noNewline))
 	} else {
-		log.Debugf("discovered clean git status in %s", repoPath)
+		log.Debug(gotext.Get("git status: %s: clean", repoPath))
 	}
 
 	return status.IsClean(), nil
@@ -78,7 +85,7 @@ func parseGitConfig() (*gitConfigPkg.Config, error) {
 	globalGitConfig := filepath.Join(usr.HomeDir, ".gitconfig")
 	if _, err := os.Stat(globalGitConfig); err != nil {
 		if os.IsNotExist(err) {
-			log.Debugf("no %s exists, not reading any global gitignore config", globalGitConfig)
+			log.Debug(gotext.Get("no %s exists, not reading any global gitignore config", globalGitConfig))
 			return cfg, nil
 		}
 		return cfg, err
@@ -120,7 +127,7 @@ func parseExcludesFile(excludesfile string) ([]gitignore.Pattern, error) {
 
 	if _, err := os.Stat(excludesfile); err != nil {
 		if os.IsNotExist(err) {
-			log.Debugf("no %s exists, skipping reading gitignore paths", excludesfile)
+			log.Debug(gotext.Get("no %s exists, skipping reading gitignore paths", excludesfile))
 			return ps, nil
 		}
 		return ps, err
@@ -139,7 +146,7 @@ func parseExcludesFile(excludesfile string) ([]gitignore.Pattern, error) {
 		}
 	}
 
-	log.Debugf("read global ignore paths: %s", strings.Join(pathsRaw, " "))
+	log.Debug(gotext.Get("read global ignore paths: %s", strings.Join(pathsRaw, " ")))
 
 	return ps, nil
 }

pkg/git/read_test.go

@@ -0,0 +1,15 @@
+package git
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/go-git/go-git/v5"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsClean(t *testing.T) {
+	isClean, err := IsClean("/tmp")
+	assert.Equal(t, isClean, false)
+	assert.True(t, errors.Is(err, git.ErrRepositoryNotExists))
+}