fix(recipe): Prevent crash when recipe has no previous tag or release

Easier to hack when customising xgettext-go.

.dockerignore

@@ -4,5 +4,4 @@
 Dockerfile
 abra
 dist
-kadabra
 tags

.drone.yml

@@ -3,17 +3,48 @@ 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
-    environment:
-      ABRA_DIR: "/root/.abra"
+  - name: xgettext-go
+    image: git.coopcloud.tech/toolshed/drone-xgettext-go:latest
+    settings:
+      keyword: i18n.G
+      keyword_ctx: i18n.GC
+      out: pkg/i18n/locales/abra.pot
+      comments_tag: translators
+    depends_on:
+      - make check
+    when:
+      event:
+        exclude:
+          - tag
+
+  - name: xgettext-go status
+    image: golang:1.24-alpine3.22
     commands:
-      - make build-abra
-      - ./abra help # show version, initialise $ABRA_DIR
+      - apk add patchutils git make
+      - cd /drone/src
+      - sed -i "s/charset=CHARSET/charset=UTF-8/g" pkg/i18n/locales/*.pot
+      - git diff pkg/i18n/locales/abra.pot | grepdiff --output-matching=hunk POT-Creation-Date | git apply --reverse --allow-empty
+      - git diff
+      - git diff-files --exit-code
+    depends_on:
+      - xgettext-go
+    when:
+      event:
+        exclude:
+          - tag
+
+  - name: make test
+    image: golang:1.24
+    environment:
+      ABRA_DIR: $HOME/.abra
+      CATL_URL: https://git.coopcloud.tech/toolshed/recipes-catalogue-json.git
+    commands:
+      - mkdir -p $HOME/.abra
+      - git clone $CATL_URL $HOME/.abra/catalogue
       - make test
     depends_on:
       - make check
@@ -29,7 +60,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,19 +78,72 @@ 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:
-      event:
-        exclude:
-          - pull_request
+      branch:
+        - main
     depends_on:
       - make check
+      - make test
+
+  - name: on-demand 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:
+      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:
+      event:
+        - cron:
+      cron:
+        # @daily https://docs.drone.io/cron/
+        - integration 
 
 volumes:
   - name: deps
     temp: {}
+
+trigger:
+  action:
+    exclude:
+      - synchronized

.envrc.sample

@@ -1,7 +1,7 @@
-go env -w GOPRIVATE=coopcloud.tech
-
-# export PASSWORD_STORE_DIR=$(pwd)/../../autonomic/passwords/passwords/
-
+# integration test suite
 # export ABRA_DIR="$HOME/.abra_test"
-# export ABRA_TEST_DOMAIN=test.example.com
-# export ABRA_SKIP_TEARDOWN=1 # for faster feedback when developing tests
+# export TEST_SERVER=test.example.com
+# export ABRA_CI=1
+
+# release automation
+# export GITEA_TOKEN=

.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

@@ -1,9 +1,9 @@
+*.tar.gz
 *fmtcoverage.html
 .e2e.env
 .envrc
 .vscode/
-/kadabra
-abra
+/abra
+/bin
 dist/
 tests/integration/.bats
-vendor/

.goreleaser.yml

@@ -32,29 +32,6 @@ builds:
       - "-s"
       - "-w"
 
-  - id: kadabra
-    binary: kadabra
-    dir: cmd/kadabra
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-      - darwin
-    goarch:
-      - 386
-      - amd64
-      - arm
-      - arm64
-    goarm:
-      - 5
-      - 6
-      - 7
-    ldflags:
-      - "-X 'main.Commit={{ .Commit }}'"
-      - "-X 'main.Version={{ .Version }}'"
-      - "-s"
-      - "-w"
-
 checksum:
   name_template: "checksums.txt"
 

AUTHORS.md

@@ -4,13 +4,19 @@
 > please do add yourself! This is a community project, let's show some 💞
 
 - 3wordchant
+- ammaratef45
+- apfelwurm
+- basebuilder
 - cassowary
+- chasqui
 - codegod100
 - decentral1se
 - fauno
 - frando
+- iexos
 - kawaiipunk
 - knoflook
+- mayel
 - moritz
 - p4u1
 - rix

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

@@ -1,58 +1,87 @@
 ABRA         := ./cmd/abra
-KADABRA      := ./cmd/kadabra
+XGETTEXT     := ./bin/xgettext-go
 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"
+DOMAIN       := abra
+POFILES      := $(wildcard pkg/i18n/locales/*.po)
+MOFILES      := $(patsubst %.po,%.mo,$(POFILES))
+LINGUAS      := $(basename $(POFILES))
 
 export GOPRIVATE=coopcloud.tech
 
-# NOTE(d1): default `make` optimised for Abra hacking
-all: format check build-abra test
+all: format check build
 
-run-abra:
-	@go run -ldflags=$(LDFLAGS) $(ABRA)
+run:
+	@go run -gcflags=$(GCFLAGS) -ldflags=$(LDFLAGS) $(ABRA)
 
-run-kadabra:
-	@go run -ldflags=$(LDFLAGS) $(KADABRA)
+install:
+	@go install -gcflags=$(GCFLAGS) -ldflags=$(LDFLAGS) $(ABRA)
 
-install-abra:
-	@go install -ldflags=$(LDFLAGS) $(ABRA)
+build:
+	@go build -v -gcflags=$(GCFLAGS) -ldflags=$(DIST_LDFLAGS) $(ABRA)
 
-install-kadabra:
-	@go install -ldflags=$(LDFLAGS) $(KADABRA)
-
-build-abra:
-	@go build -v -ldflags=$(DIST_LDFLAGS) $(ABRA)
-
-build-kadabra:
-	@go build -v -ldflags=$(DIST_LDFLAGS) $(KADABRA)
-
-build: build-abra build-kadabra
-
-build-docker-abra:
+build-docker:
 	@docker run -it -v $(PWD):/abra golang:$(GOVERSION) \
 		bash -c 'cd /abra; ./scripts/docker/build.sh'
 
-build-docker: build-docker-abra
-
 clean:
 	@rm '$(GOPATH)/bin/abra'
-	@rm '$(GOPATH)/bin/kadabra'
 
 format:
-	@gofmt -s -w .
+	@gofmt -s -w $$(find . -type f -name '*.go' | grep -v "/vendor/")
 
 check:
-	@test -z $$(gofmt -l .) || \
+	@test -z $$(gofmt -l $$(find . -type f -name '*.go' | grep -v "/vendor/")) || \
 	(echo "gofmt: formatting issue - run 'make format' to resolve" && exit 1)
 
 test:
 	@go test ./... -cover -v
 
+find-tests:
+	@find . -name "*_test.go"
+
 loc:
 	@find . -name "*.go" | xargs wc -l
 
 deps:
 	@go get -t -u ./...
+
+.PHONY: i18n
+i18n: update-pot update-pot-po-metadata update-po build-mo
+
+.PHONY: update-po
+update-po:
+	@set -eu; \
+	for lang in $(LINGUAS); do \
+		msgmerge --backup=none -U $$lang.po pkg/i18n/locales/$(DOMAIN).pot; \
+	done
+
+.PHONY: update-pot
+update-pot: $(XGETTEXT)
+	@${XGETTEXT} \
+		-o pkg/i18n/locales/$(DOMAIN).pot \
+		--keyword=i18n.G \
+		--keyword-ctx=i18n.GC \
+		--sort-output \
+		--add-comments-tag="translators" \
+		$$(find . -name "*.go" -not -path "*vendor*" | sort)
+
+${XGETTEXT}:
+	@mkdir -p ./bin && \
+	wget -O ./bin/xgettext-go https://git.coopcloud.tech/toolshed/xgettext-go/raw/branch/main/xgettext-go && \
+	chmod +x ./bin/xgettext-go
+
+.PHONY: update-pot-po-metadata
+update-pot-po-metadata:
+	@sed -i "s/charset=CHARSET/charset=UTF-8/g" pkg/i18n/locales/*.po pkg/i18n/locales/*.pot
+
+.PHONY: build-mo
+build-mo:
+	@set -eu; \
+	for lang in $(POFILES); do \
+		msgfmt $$lang -o $$(echo $$lang | sed 's/.po/.mo/g') --statistics; \
+	done

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,37 +1,20 @@
 package app
 
 import (
-	"github.com/urfave/cli"
+	"strings"
+
+	"coopcloud.tech/abra/pkg/i18n"
+	"github.com/spf13/cobra"
 )
 
-var AppCommand = cli.Command{
-	Name:        "app",
-	Aliases:     []string{"a"},
-	Usage:       "Manage apps",
-	ArgsUsage:   "<domain>",
-	Description: "Functionality for managing the life cycle of your apps",
-	Subcommands: []cli.Command{
-		appBackupCommand,
-		appCheckCommand,
-		appCmdCommand,
-		appConfigCommand,
-		appCpCommand,
-		appDeployCommand,
-		appErrorsCommand,
-		appListCommand,
-		appLogsCommand,
-		appNewCommand,
-		appPsCommand,
-		appRemoveCommand,
-		appRestartCommand,
-		appRestoreCommand,
-		appRollbackCommand,
-		appRunCommand,
-		appSecretCommand,
-		appServicesCommand,
-		appUndeployCommand,
-		appUpgradeCommand,
-		appVersionCommand,
-		appVolumeCommand,
-	},
+// translators: `abra app` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appAliases = i18n.GC("a", "abra app")
+
+var AppCommand = &cobra.Command{
+	// translators: `app` command group
+	Use:     i18n.G("app [cmd] [args] [flags]"),
+	Aliases: strings.Split(appAliases, ","),
+	// translators: Short description for `app` command group
+	Short: i18n.G("Manage apps"),
 }

cli/app/backup.go

@@ -2,313 +2,338 @@ package app
 
 import (
 	"fmt"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/spf13/cobra"
 )
 
-var snapshot string
-var snapshotFlag = &cli.StringFlag{
-	Name:        "snapshot, s",
-	Usage:       "Lists specific snapshot",
-	Destination: &snapshot,
-}
+// translators: `abra app backup list` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appBackupListAliases = i18n.G("ls")
 
-var includePath string
-var includePathFlag = &cli.StringFlag{
-	Name:        "path, p",
-	Usage:       "Include path",
-	Destination: &includePath,
-}
-
-var resticRepo string
-var resticRepoFlag = &cli.StringFlag{
-	Name:        "repo, r",
-	Usage:       "Restic repository",
-	Destination: &resticRepo,
-}
-
-var appBackupListCommand = cli.Command{
-	Name:    "list",
-	Aliases: []string{"ls"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
-		snapshotFlag,
-		includePathFlag,
+var AppBackupListCommand = &cobra.Command{
+	// translators: `app backup list` command
+	Use:     i18n.G("list <domain> [flags]"),
+	Aliases: strings.Split(appBackupListAliases, ","),
+	// translators: Short description for `app backup list` command
+	Short: i18n.G("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",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
-		}
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
+		}
+
+		execEnv := []string{
+			fmt.Sprintf("SERVICE=%s", app.Domain),
+			"MACHINE_LOGS=true",
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
 		if snapshot != "" {
-			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			log.Debug(i18n.G("including SNAPSHOT=%s in backupbot exec invocation", snapshot))
 			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
 		}
-		if includePath != "" {
-			logrus.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath)
-			execEnv = append(execEnv, fmt.Sprintf("INCLUDE_PATH=%s", includePath))
+
+		if showAllPaths {
+			log.Debug(i18n.G("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 {
-			logrus.Fatal(err)
+		if timestamps {
+			log.Debug(i18n.G("including TIMESTAMPS=%v in backupbot exec invocation", timestamps))
+			execEnv = append(execEnv, fmt.Sprintf("TIMESTAMPS=%v", timestamps))
 		}
 
-		return nil
+		if _, err = internal.RunBackupCmdRemote(cl, "ls", targetContainer.ID, execEnv); err != nil {
+			log.Fatal(err)
+		}
 	},
 }
 
-var appBackupDownloadCommand = cli.Command{
-	Name:    "download",
-	Aliases: []string{"d"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
-		snapshotFlag,
-		includePathFlag,
+// translators: `abra app backup download` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appBackupDownloadAliases = i18n.G("d")
+
+var AppBackupDownloadCommand = &cobra.Command{
+	// translators: `app backup download` command
+	Use:     i18n.G("download <domain> [flags]"),
+	Aliases: strings.Split(appBackupDownloadAliases, ","),
+	// translators: Short description for `app backup download` command
+	Short: i18n.G("Download a snapshot"),
+	Long: i18n.G(`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",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
+		}
+
+		execEnv := []string{
+			fmt.Sprintf("SERVICE=%s", app.Domain),
+			"MACHINE_LOGS=true",
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
 		if snapshot != "" {
-			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			log.Debug(i18n.G("including SNAPSHOT=%s in backupbot exec invocation", snapshot))
 			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
 		}
+
 		if includePath != "" {
-			logrus.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath)
+			log.Debug(i18n.G("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 {
-			logrus.Fatal(err)
+		if includeSecrets {
+			log.Debug(i18n.G("including SECRETS=%v in backupbot exec invocation", includeSecrets))
+			execEnv = append(execEnv, fmt.Sprintf("SECRETS=%v", includeSecrets))
+		}
+
+		if includeVolumes {
+			log.Debug(i18n.G("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)
 		}
 
 		remoteBackupDir := "/tmp/backup.tar.gz"
 		currentWorkingDir := "."
 		if err = CopyFromContainer(cl, targetContainer.ID, remoteBackupDir, currentWorkingDir); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-
-		fmt.Println("backup successfully downloaded to current working directory")
-
-		return nil
 	},
 }
 
-var appBackupCreateCommand = cli.Command{
-	Name:    "create",
-	Aliases: []string{"c"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
-		resticRepoFlag,
+// translators: `abra app backup create` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appBackupCreateAliases = i18n.G("c")
+
+var AppBackupCreateCommand = &cobra.Command{
+	// translators: `app backup create` command
+	Use:     i18n.G("create <domain> [flags]"),
+	Aliases: strings.Split(appBackupCreateAliases, ","),
+	// translators: Short description for `app backup create` command
+	Short: i18n.G("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",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
-		if resticRepo != "" {
-			logrus.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 {
-			logrus.Fatal(err)
+		if retries != "" {
+			log.Debug(i18n.G("including RETRIES=%s in backupbot exec invocation", retries))
+			execEnv = append(execEnv, fmt.Sprintf("RETRIES=%s", retries))
 		}
 
-		return nil
+		if _, err := internal.RunBackupCmdRemote(cl, "create", targetContainer.ID, execEnv); err != nil {
+			log.Fatal(err)
+		}
 	},
 }
 
-var appBackupSnapshotsCommand = cli.Command{
-	Name:    "snapshots",
-	Aliases: []string{"s"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
-		snapshotFlag,
+// translators: `abra app backup snapshots` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appBackupSnapshotsAliases = i18n.G("s")
+
+var AppBackupSnapshotsCommand = &cobra.Command{
+	// translators: `app backup snapshots` command
+	Use:     i18n.G("snapshots <domain> [flags]"),
+	Aliases: strings.Split(appBackupSnapshotsAliases, ","),
+	// translators: Short description for `app backup snapshots` command
+	Short: i18n.G("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",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
-		}
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
-		if snapshot != "" {
-			logrus.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 {
-			logrus.Fatal(err)
+		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",
-	ArgsUsage: "<domain>",
-	Subcommands: []cli.Command{
-		appBackupListCommand,
-		appBackupSnapshotsCommand,
-		appBackupDownloadCommand,
-		appBackupCreateCommand,
-	},
+// translators: `abra app backup` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appBackupAliases = i18n.G("b")
+
+var AppBackupCommand = &cobra.Command{
+	// translators: `app backup` command group
+	Use:     i18n.G("backup [cmd] [args] [flags]"),
+	Aliases: strings.Split(appBackupAliases, ","),
+	// translators: Short description for `app backup` command group
+	Short: i18n.G("Manage app backups"),
+}
+
+var (
+	snapshot       string
+	retries        string
+	includePath    string
+	showAllPaths   bool
+	timestamps     bool
+	includeSecrets bool
+	includeVolumes bool
+)
+
+func init() {
+	AppBackupListCommand.Flags().StringVarP(
+		&snapshot,
+		i18n.G("snapshot"),
+		i18n.G("s"),
+		"",
+		i18n.G("list specific snapshot"),
+	)
+
+	AppBackupListCommand.Flags().BoolVarP(
+		&showAllPaths,
+		i18n.G("all"),
+		i18n.GC("a", "app backup list"),
+		false,
+		i18n.G("show all paths"),
+	)
+
+	AppBackupListCommand.Flags().BoolVarP(
+		&timestamps,
+		i18n.G("timestamps"),
+		i18n.G("t"),
+		false,
+		i18n.G("include timestamps"),
+	)
+
+	AppBackupDownloadCommand.Flags().StringVarP(
+		&snapshot,
+		i18n.G("snapshot"),
+		i18n.G("s"),
+		"",
+		i18n.G("list specific snapshot"),
+	)
+
+	AppBackupDownloadCommand.Flags().StringVarP(
+		&includePath,
+		i18n.G("path"),
+		i18n.G("p"),
+		"",
+		i18n.G("volumes path"),
+	)
+
+	AppBackupDownloadCommand.Flags().BoolVarP(
+		&includeSecrets,
+		i18n.G("secrets"),
+		i18n.G("S"),
+		false,
+		i18n.G("include secrets"),
+	)
+
+	AppBackupDownloadCommand.Flags().BoolVarP(
+		&includeVolumes,
+		i18n.G("volumes"),
+		i18n.G("v"),
+		false,
+		i18n.G("include volumes"),
+	)
+
+	AppBackupDownloadCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+
+	AppBackupCreateCommand.Flags().StringVarP(
+		&retries,
+		i18n.G("retries"),
+		i18n.G("r"),
+		"1",
+		i18n.G("number of retry attempts"),
+	)
+
+	AppBackupCreateCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
 }

cli/app/check.go

@@ -1,22 +1,30 @@
 package app
 
 import (
+	"fmt"
+	"strings"
+
 	"coopcloud.tech/abra/cli/internal"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/spf13/cobra"
 )
 
-var appCheckCommand = cli.Command{
-	Name:    "check",
-	Aliases: []string{"chk"},
-	Usage:   "Ensure an app is well configured",
-	Description: `
-This command compares env vars in both the app ".env" and recipe ".env.sample"
-file.
+// translators: `abra app check` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appCheckAliases = i18n.G("chk")
+
+var AppCheckCommand = &cobra.Command{
+	// translators: `app check` command
+	Use:     i18n.G("check <domain> [flags]"),
+	Aliases: strings.Split(appCheckAliases, ","),
+	// translators: Short description for `app check` command
+	Short: i18n.G("Ensure an app is well configured"),
+	Long: i18n.G(`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
@@ -25,60 +33,67 @@ 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.`,
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.ChaosFlag,
-		internal.OfflineFlag,
+${FOO:<default>} syntax). "check" does not confirm or deny this for you.`),
+	Args: cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		r, err := recipe.Get(app.Recipe)
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
+		}
+
+		table, err := formatter.CreateTable()
 		if err != nil {
-			logrus.Fatal(err)
-		}
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
+		table.
+			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:
+					return lipgloss.NewStyle().Padding(0, 1, 0, 1).Align(lipgloss.Center)
+				default:
+					return lipgloss.NewStyle().Padding(0, 1, 0, 1)
 				}
-			}
+			})
 
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		tableCol := []string{"recipe env sample", "app env"}
-		table := formatter.CreateTable(tableCol)
-
-		envVars, err := config.CheckEnv(app)
+		envVars, err := appPkg.CheckEnv(app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, envVar := range envVars {
 			if envVar.Present {
-				table.Append([]string{envVar.Name, "✅"})
+				val := []string{envVar.Name, "✅"}
+				table.Row(val...)
 			} else {
-				table.Append([]string{envVar.Name, "❌"})
+				val := []string{envVar.Name, "❌"}
+				table.Row(val...)
 			}
 		}
 
-		table.Render()
-
-		return nil
+		if err := formatter.PrintTable(table); err != nil {
+			log.Fatal(err)
+		}
 	},
 }
+
+func init() {
+	AppCheckCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+}

cli/app/cmd.go

@@ -5,110 +5,124 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"path"
+	"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/config"
-	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/spf13/cobra"
 )
 
-var appCmdCommand = cli.Command{
-	Name:    "command",
-	Aliases: []string{"cmd"},
-	Usage:   "Run app commands",
-	Description: `Run an app specific command.
+// translators: `abra app cmd` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appCmdAliases = i18n.G("cmd")
+
+var AppCmdCommand = &cobra.Command{
+	// translators: `app command` command
+	Use:     i18n.G("command <domain> [service | --local] <cmd> [[args] [flags] | [flags] -- [args]]"),
+	Aliases: strings.Split(appCmdAliases, ","),
+	// translators: Short description for `app cmd` command
+	Short: i18n.G("Run app commands"),
+	Long: i18n.G(`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". Arguments can be passed into these functions
-using the "-- <args>" syntax.
+work station by passing "--local/-l".
 
-Example:
+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: i18n.G(`  # pass <cmd> args/flags without "--"
+  abra app cmd 1312.net app my_cmd_arg foo --user bar
 
-  abra app cmd example.com app create_user -- me@example.com
-`,
-	ArgsUsage: "<domain> [<service>] <command> [-- <args>]",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.LocalCmdFlag,
-		internal.RemoteUserFlag,
-		internal.TtyFlag,
-		internal.OfflineFlag,
-		internal.ChaosFlag,
-	},
-	Before:      internal.SubCommandBefore,
-	Subcommands: []cli.Command{appCmdListCommand},
-	BashComplete: func(ctx *cli.Context) {
-		args := ctx.Args()
-		switch len(args) {
-		case 0:
-			autocomplete.AppNameComplete(ctx)
-		case 1:
-			autocomplete.ServiceNameComplete(args.Get(0))
-		case 2:
-			cmdNameComplete(args.Get(0))
-		}
-	},
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+  # pass <cmd> args/flags with "--"
+  abra app cmd 1312.net app my_cmd_args --user bar -- foo -vvv
 
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
+  # 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(i18n.G("requires at least 2 arguments with --local/-l"))
 			}
 
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
+			if slices.Contains(os.Args, "--") {
+				if cmd.ArgsLenAtDash() > 2 {
+					return errors.New(i18n.G("accepts at most 2 args with --local/-l"))
 				}
 			}
 
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
+			// 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(i18n.G("requires at least 3 arguments"))
+		}
+
+		return nil
+	},
+	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 !local {
+				return autocomplete.ServiceNameComplete(args[0])
 			}
+			return autocomplete.CommandNameComplete(args[0])
+		case 2:
+			if !local {
+				return autocomplete.CommandNameComplete(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)
 		}
 
-		if internal.LocalCmd && internal.RemoteUser != "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("cannot use --local & --user together"))
+		if local && remoteUser != "" {
+			log.Fatal(i18n.G("cannot use --local & --user together"))
 		}
 
-		hasCmdArgs, parsedCmdArgs := parseCmdArgs(c.Args(), internal.LocalCmd)
+		hasCmdArgs, parsedCmdArgs := parseCmdArgs(args, local)
 
-		abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
-		if _, err := os.Stat(abraSh); err != nil {
+		if _, err := os.Stat(app.Recipe.AbraShPath); err != nil {
 			if os.IsNotExist(err) {
-				logrus.Fatalf("%s does not exist for %s?", abraSh, app.Name)
+				log.Fatal(i18n.G("%s does not exist for %s?", app.Recipe.AbraShPath, app.Name))
 			}
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if internal.LocalCmd {
-			if !(len(c.Args()) >= 2) {
-				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
+		if local {
+			cmdName := args[1]
+			if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
+				log.Fatal(err)
 			}
 
-			cmdName := c.Args().Get(1)
-			if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
-				logrus.Fatal(err)
-			}
-
-			logrus.Debugf("--local detected, running %s on local work station", cmdName)
+			log.Debug(i18n.G("--local detected, running %s on local work station", cmdName))
 
 			var exportEnv string
 			for k, v := range app.Env {
@@ -117,70 +131,101 @@ Example:
 
 			var sourceAndExec string
 			if hasCmdArgs {
-				logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
-				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s %s", app.Name, app.StackName(), exportEnv, abraSh, cmdName, parsedCmdArgs)
+				log.Debug(i18n.G("parsed following command arguments: %s", parsedCmdArgs))
+				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s %s", app.Name, app.StackName(), exportEnv, app.Recipe.AbraShPath, cmdName, parsedCmdArgs)
 			} else {
-				logrus.Debug("did not detect any command arguments")
-				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s", app.Name, app.StackName(), exportEnv, abraSh, cmdName)
+				log.Debug(i18n.G("did not detect any command arguments"))
+				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s", app.Name, app.StackName(), exportEnv, app.Recipe.AbraShPath, cmdName)
 			}
 
 			shell := "/bin/bash"
 			if _, err := os.Stat(shell); errors.Is(err, os.ErrNotExist) {
-				logrus.Debugf("%s does not exist locally, use /bin/sh as fallback", shell)
+				log.Debug(i18n.G("%s does not exist locally, use /bin/sh as fallback", shell))
 				shell = "/bin/sh"
 			}
 			cmd := exec.Command(shell, "-c", sourceAndExec)
 
 			if err := internal.RunCmd(cmd); err != nil {
-				logrus.Fatal(err)
-			}
-		} else {
-			if !(len(c.Args()) >= 3) {
-				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
+				log.Fatal(err)
 			}
 
-			targetServiceName := c.Args().Get(1)
+			return
+		}
 
-			cmdName := c.Args().Get(2)
-			if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
-				logrus.Fatal(err)
-			}
+		cmdName := args[2]
+		if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
+			log.Fatal(err)
+		}
 
-			serviceNames, err := config.GetAppServiceNames(app.Name)
-			if err != nil {
-				logrus.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 {
-				logrus.Fatalf("no service %s for %s?", targetServiceName, app.Name)
-			}
-
-			logrus.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName)
-
-			if hasCmdArgs {
-				logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
-			} else {
-				logrus.Debug("did not detect any command arguments")
-			}
-
-			cl, err := client.New(app.Server)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if err := internal.RunCmdRemote(cl, app, abraSh, targetServiceName, cmdName, parsedCmdArgs); err != nil {
-				logrus.Fatal(err)
+		matchingServiceName := false
+		targetServiceName := args[1]
+		for _, serviceName := range serviceNames {
+			if serviceName == targetServiceName {
+				matchingServiceName = true
 			}
 		}
 
-		return nil
+		if !matchingServiceName {
+			log.Fatal(i18n.G("no service %s for %s?", targetServiceName, app.Name))
+		}
+
+		log.Debug(i18n.G("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName))
+
+		if hasCmdArgs {
+			log.Debug(i18n.G("parsed following command arguments: %s", parsedCmdArgs))
+		} else {
+			log.Debug(i18n.G("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)
+		}
+	},
+}
+
+// translators: `abra app command list` aliases. use a comma separated list of
+// aliases with no spaces in between
+var appCmdListAliases = i18n.G("ls")
+
+var AppCmdListCommand = &cobra.Command{
+	// translators: `app cmd list` command
+	Use:     i18n.G("list <domain> [flags]"),
+	Aliases: strings.Split(appCmdListAliases, ","),
+	// translators: Short description for `app cmd list` command
+	Short: i18n.G("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)
+		}
 	},
 }
 
@@ -203,80 +248,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",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
-		internal.ChaosFlag,
-	},
-	BashComplete: autocomplete.AppNameComplete,
-	Before:       internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		cmdNames, err := getShCmdNames(app)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		for _, cmdName := range cmdNames {
-			fmt.Println(cmdName)
-		}
-
-		return nil
-	},
-}
-
-func getShCmdNames(app config.App) ([]string, error) {
-	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
-	cmdNames, err := config.ReadAbraShCmdNames(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,
+		i18n.G("local"),
+		i18n.G("l"),
+		false,
+		i18n.G("run command locally"),
+	)
+
+	AppCmdCommand.Flags().StringVarP(
+		&remoteUser,
+		i18n.G("user"),
+		i18n.G("u"),
+		"",
+		i18n.G("request remote user"),
+	)
+
+	AppCmdCommand.Flags().BoolVarP(
+		&disableTTY,
+		i18n.G("tty"),
+		i18n.G("T"),
+		false,
+		i18n.G("disable remote TTY"),
+	)
+
+	AppCmdCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("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,64 +1,65 @@
 package app
 
 import (
-	"errors"
 	"os"
 	"os/exec"
+	"strings"
 
-	"coopcloud.tech/abra/cli/internal"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var appConfigCommand = cli.Command{
-	Name:      "config",
-	Aliases:   []string{"cfg"},
-	Usage:     "Edit app config",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
+// translators: `abra app config` aliases. use a comma separated list of
+// aliases with no spaces in between
+var appConfigAliases = i18n.G("cfg")
+
+var AppConfigCommand = &cobra.Command{
+	// translators: `app config` command
+	Use:     i18n.G("config <domain> [flags]"),
+	Aliases: strings.Split(appConfigAliases, ","),
+	// translators: Short description for `app config` command
+	Short:   i18n.G("Edit app config"),
+	Example: i18n.G("  abra config 1312.net"),
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		appName := c.Args().First()
-
-		if appName == "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no app provided"))
-		}
-
-		files, err := config.LoadAppFiles("")
+	Run: func(cmd *cobra.Command, args []string) {
+		files, err := appPkg.LoadAppFiles("")
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
+		appName := args[0]
 		appFile, exists := files[appName]
 		if !exists {
-			logrus.Fatalf("cannot find app with name %s", appName)
+			log.Fatal(i18n.G("cannot find app with name %s", appName))
 		}
 
 		ed, ok := os.LookupEnv("EDITOR")
 		if !ok {
 			edPrompt := &survey.Select{
-				Message: "Which editor do you wish to use?",
+				Message: i18n.G("which editor do you wish to use?"),
 				Options: []string{"vi", "vim", "nvim", "nano", "pico", "emacs"},
 			}
 			if err := survey.AskOne(edPrompt, &ed); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
-		cmd := exec.Command(ed, appFile.Path)
-		cmd.Stdin = os.Stdin
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		if err := cmd.Run(); err != nil {
-			logrus.Fatal(err)
+		c := exec.Command(ed, appFile.Path)
+		c.Stdin = os.Stdin
+		c.Stdout = os.Stdout
+		c.Stderr = os.Stderr
+		if err := c.Run(); err != nil {
+			log.Fatal(err)
 		}
-
-		return nil
 	},
 }

cli/app/cp.go

@@ -3,7 +3,6 @@ package app
 import (
 	"context"
 	"errors"
-	"fmt"
 	"io"
 	"os"
 	"path"
@@ -15,65 +14,68 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	containerPkg "coopcloud.tech/abra/pkg/container"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"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/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var appCpCommand = cli.Command{
-	Name:      "cp",
-	Aliases:   []string{"c"},
-	ArgsUsage: "<domain> <src> <dst>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
+// translators: `abra app cp` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appCpAliases = i18n.G("c")
+
+var AppCpCommand = &cobra.Command{
+	// translators: `app cp` command
+	Use:     i18n.G("cp <domain> <src> <dst> [flags]"),
+	Aliases: strings.Split(appCpAliases, ","),
+	// translators: Short description for `app cp` command
+	Short: i18n.G("Copy files to/from a deployed app service"),
+	Example: i18n.G(`  # copy myfile.txt to the root of the app service
+  abra app cp 1312.net myfile.txt app:/
+
+  # 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
+		}
 	},
-	Before: internal.SubCommandBefore,
-	Usage:  "Copy files to/from a deployed app service",
-	Description: `
-Copy files to and from any app service file system.
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-If you want to copy a myfile.txt to the root of the app service:
-
-    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 .
-`,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		src := c.Args().Get(1)
-		dst := c.Args().Get(2)
-		if src == "" {
-			logrus.Fatal("missing <src> argument")
-		}
-		if dst == "" {
-			logrus.Fatal("missing <dest> argument")
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
+		src := args[1]
+		dst := args[2]
 		srcPath, dstPath, service, toContainer, err := parseSrcAndDst(src, dst)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		container, err := containerPkg.GetContainerFromStackAndService(cl, app.StackName(), service)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-		logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(container.ID), app.Server)
+		log.Debug(i18n.G("retrieved %s as target container on %s", formatter.ShortenID(container.ID), app.Server))
 
 		if toContainer {
 			err = CopyToContainer(cl, container.ID, srcPath, dstPath)
@@ -81,14 +83,12 @@ And if you want to copy that file back to your current working directory locally
 			err = CopyFromContainer(cl, container.ID, srcPath, dstPath)
 		}
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-
-		return nil
 	},
 }
 
-var errServiceMissing = errors.New("one of <src>/<dest> arguments must take $SERVICE:$PATH form")
+var errServiceMissing = errors.New(i18n.G("one of <src>/<dest> arguments must take $SERVICE:$PATH form"))
 
 // parseSrcAndDst parses src and dest string. One of src or dst must be of the form $SERVICE:$PATH
 func parseSrcAndDst(src, dst string) (srcPath string, dstPath string, service string, toContainer bool, err error) {
@@ -111,7 +111,7 @@ func parseSrcAndDst(src, dst string) (srcPath string, dstPath string, service st
 func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath string) error {
 	srcStat, err := os.Stat(srcPath)
 	if err != nil {
-		return fmt.Errorf("local %s ", err)
+		return errors.New(i18n.G("local %s ", err))
 	}
 
 	dstStat, err := cl.ContainerStatPath(context.Background(), containerID, dstPath)
@@ -120,7 +120,7 @@ func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 		if errdefs.IsNotFound(err) {
 			dstExists = false
 		} else {
-			return fmt.Errorf("remote path: %s", err)
+			return errors.New(i18n.G("remote path: %s", err))
 		}
 	}
 
@@ -140,7 +140,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,
@@ -148,7 +148,7 @@ func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 			Detach:       false,
 			Tty:          true,
 		}); err != nil {
-			return fmt.Errorf("create remote directory: %s", err)
+			return errors.New(i18n.G("create remote directory: %s", err))
 		}
 	case CopyModeFileToFile:
 		// Remove the file component from the path, since docker can only copy
@@ -167,8 +167,8 @@ func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 		return err
 	}
 
-	logrus.Debugf("copy %s from local to %s on container", srcPath, dstPath)
-	copyOpts := types.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
+	log.Debug(i18n.G("copy %s from local to %s on container", srcPath, dstPath))
+	copyOpts := containertypes.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
 	if err := cl.CopyToContainer(context.Background(), containerID, dstPath, content, copyOpts); err != nil {
 		return err
 	}
@@ -179,7 +179,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,
@@ -187,7 +187,7 @@ func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 			Detach:       false,
 			Tty:          true,
 		}); err != nil {
-			return fmt.Errorf("create remote directory: %s", err)
+			return errors.New(i18n.G("create remote directory: %s", err))
 		}
 	}
 
@@ -200,9 +200,9 @@ func CopyFromContainer(cl *dockerClient.Client, containerID, srcPath, dstPath st
 	srcStat, err := cl.ContainerStatPath(context.Background(), containerID, srcPath)
 	if err != nil {
 		if errdefs.IsNotFound(err) {
-			return fmt.Errorf("remote: %s does not exist", srcPath)
+			return errors.New(i18n.G("remote: %s does not exist", srcPath))
 		} else {
-			return fmt.Errorf("remote path: %s", err)
+			return errors.New(i18n.G("remote path: %s", err))
 		}
 	}
 
@@ -213,7 +213,7 @@ func CopyFromContainer(cl *dockerClient.Client, containerID, srcPath, dstPath st
 		if os.IsNotExist(err) {
 			dstExists = false
 		} else {
-			return fmt.Errorf("remote path: %s", err)
+			return errors.New(i18n.G("remote path: %s", err))
 		}
 	} else {
 		dstMode = dstStat.Mode()
@@ -248,7 +248,7 @@ func CopyFromContainer(cl *dockerClient.Client, containerID, srcPath, dstPath st
 
 	content, _, err := cl.CopyFromContainer(context.Background(), containerID, srcPath)
 	if err != nil {
-		return fmt.Errorf("copy: %s", err)
+		return errors.New(i18n.G("copy: %s", err))
 	}
 	defer content.Close()
 	if err := archive.Untar(content, dstPath, &archive.TarOptions{
@@ -256,7 +256,7 @@ func CopyFromContainer(cl *dockerClient.Client, containerID, srcPath, dstPath st
 		Compression:          archive.Gzip,
 		NoLchown:             true,
 	}); err != nil {
-		return fmt.Errorf("untar: %s", err)
+		return errors.New(i18n.G("untar: %s", err))
 	}
 
 	if moveDstFile != "" {
@@ -275,8 +275,8 @@ func CopyFromContainer(cl *dockerClient.Client, containerID, srcPath, dstPath st
 }
 
 var (
-	ErrCopyDirToFile  = fmt.Errorf("can't copy dir to file")
-	ErrDstDirNotExist = fmt.Errorf("destination directory does not exist")
+	ErrCopyDirToFile  = errors.New(i18n.G("can't copy dir to file"))
+	ErrDstDirNotExist = errors.New(i18n.G("destination directory does not exist"))
 )
 
 type CopyMode int
@@ -377,3 +377,13 @@ func moveFile(sourcePath, destPath string) error {
 	}
 	return nil
 }
+
+func init() {
+	AppCpCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+}

cli/app/deploy.go

@@ -2,261 +2,436 @@ package app
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
+	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/secret"
 
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/deploy"
 	"coopcloud.tech/abra/pkg/dns"
 	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/i18n"
 	"coopcloud.tech/abra/pkg/lint"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	dockerClient "github.com/docker/docker/client"
+	"github.com/spf13/cobra"
 )
 
-var appDeployCommand = cli.Command{
-	Name:      "deploy",
-	Aliases:   []string{"d"},
-	Usage:     "Deploy an app",
-	ArgsUsage: "<domain> [<version>]",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.ForceFlag,
-		internal.ChaosFlag,
-		internal.NoDomainChecksFlag,
-		internal.DontWaitConvergeFlag,
-		internal.OfflineFlag,
+// translators: `abra app deploy` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appDeployAliases = i18n.G("d")
+
+var AppDeployCommand = &cobra.Command{
+	// translators: `app deploy` command
+	Use:     i18n.G("deploy <domain> [version] [flags]"),
+	Aliases: strings.Split(appDeployAliases, ","),
+	// translators: Short description for `app deploy` command
+	Short: i18n.G("Deploy an app"),
+	Long: i18n.G(`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: i18n.G(`  # 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 := i18n.G("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. It does not support incrementing the version of a deployed app,
-for this you need to look at the "abra app upgrade <domain>" command.
+	Run: func(cmd *cobra.Command, args []string) {
+		var (
+			deployWarnMessages []string
+			toDeployVersion    string
+		)
 
-You may pass "--force" to re-deploy the same version again. This can be useful
-if the container runtime has gotten into a weird state.
+		app := internal.ValidateApp(args)
 
-Chaos mode ("--chaos") will deploy your local checkout of a recipe as-is,
-including unstaged changes and can be useful for live hacking and testing new
-recipes.
-`,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-		stackName := app.StackName()
-
-		specificVersion := c.Args().Get(1)
-		if specificVersion != "" && internal.Chaos {
-			logrus.Fatal("cannot use <version> and --chaos together")
+		if err := validateArgsAndFlags(args); err != nil {
+			log.Fatal(err)
 		}
 
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if err := r.LoadConfig(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := lint.LintForErrors(r); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
-
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
+		log.Debug(i18n.G("checking whether %s is already deployed", app.StackName()))
+
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		// 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 := deployedVersion
-		if specificVersion != "" {
-			version = specificVersion
-			logrus.Debugf("choosing %s as version to deploy", version)
-			if err := r.EnsureVersion(version); err != nil {
-				logrus.Fatal(err)
+		if deployMeta.IsDeployed && !(internal.Force || internal.Chaos) {
+			log.Fatal(i18n.G("%s is already deployed", app.Name))
+		}
+
+		toDeployVersion, err = getDeployVersion(args, deployMeta, app)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if !internal.Chaos {
+			isChaosCommit, err := app.Recipe.EnsureVersion(toDeployVersion)
+			if err != nil {
+				log.Fatal(i18n.G("ensure recipe: %s", err))
+			}
+			if isChaosCommit {
+				log.Warnf(i18n.G("version '%s' appears to be a chaos commit, but --chaos/-C was not provided", toDeployVersion))
+				internal.Chaos = true
 			}
 		}
 
-		secStats, err := secret.PollSecretsStatus(cl, app)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		for _, secStat := range secStats {
-			if !secStat.CreatedOnRemote {
-				logrus.Fatalf("unable to deploy, secrets not generated (%s)?", secStat.LocalName)
-			}
-		}
-
-		if isDeployed {
-			if internal.Force || internal.Chaos {
-				logrus.Warnf("%s is already deployed but continuing (--force/--chaos)", app.Name)
+		if err := lint.LintForErrors(app.Recipe); err != nil {
+			if internal.Chaos {
+				log.Warn(err)
 			} else {
-				logrus.Fatalf("%s is already deployed", app.Name)
+				log.Fatal(err)
 			}
 		}
 
-		if !internal.Chaos && specificVersion == "" {
-			catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if len(versions) == 0 && !internal.Chaos {
-				logrus.Warn("no published versions in catalogue, trying local recipe repository")
-				recipeVersions, err := r.GetVersions(internal.Offline)
-				if err != nil {
-					logrus.Warn(err)
-				}
-				for _, recipeVersion := range recipeVersions {
-					for version := range recipeVersion {
-						versions = append(versions, version)
-					}
-				}
-			}
-
-			if len(versions) > 0 && !internal.Chaos {
-				version = versions[len(versions)-1]
-				logrus.Debugf("choosing %s as version to deploy", version)
-				if err := r.EnsureVersion(version); err != nil {
-					logrus.Fatal(err)
-				}
-			} else {
-				head, err := git.GetHead(app.Recipe)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				version = formatter.SmallSHA(head.String())
-				logrus.Warn("no versions detected, using latest commit")
-			}
+		if err := validateSecrets(cl, app); err != nil {
+			log.Fatal(err)
 		}
 
-		if internal.Chaos {
-			logrus.Warnf("chaos mode engaged")
-			var err error
-			version, err = r.ChaosVersion()
-			if err != nil {
-				logrus.Fatal(err)
-			}
+		if err := deploy.MergeAbraShEnv(app.Recipe, app.Env); err != nil {
+			log.Fatal(err)
 		}
 
-		abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
-		abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 		if err != nil {
-			logrus.Fatal(err)
-		}
-		for k, v := range abraShEnv {
-			app.Env[k] = v
-		}
-
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
+		stackName := app.StackName()
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
 			Prune:        false,
 			ResolveImage: stack.ResolveImageAlways,
+			Detach:       false,
 		}
-		compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
+		compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		config.ExposeAllEnv(stackName, compose, app.Env)
-		config.SetRecipeLabel(compose, stackName, app.Recipe)
-		config.SetChaosLabel(compose, stackName, internal.Chaos)
-		config.SetChaosVersionLabel(compose, stackName, version)
-		config.SetUpdateLabel(compose, stackName, app.Env)
+		appPkg.ExposeAllEnv(stackName, compose, app.Env)
+		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
+		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
+		if internal.Chaos {
+			appPkg.SetChaosVersionLabel(compose, stackName, toDeployVersion)
+		}
 
-		envVars, err := config.CheckEnv(app)
+		versionLabel := toDeployVersion
+		if internal.Chaos {
+			for _, service := range compose.Services {
+				if service.Name == "app" {
+					labelKey := fmt.Sprintf("coop-cloud.%s.version", stackName)
+					// NOTE(d1): keep non-chaos version labbeling when doing chaos ops
+					versionLabel = service.Deploy.Labels[labelKey]
+				}
+			}
+		}
+		appPkg.SetVersionLabel(compose, stackName, versionLabel)
+
+		envVars, err := appPkg.CheckEnv(app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, envVar := range envVars {
 			if !envVar.Present {
-				logrus.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain)
+				deployWarnMessages = append(deployWarnMessages,
+					i18n.G("%s missing from %s.env", envVar.Name, app.Domain),
+				)
 			}
 		}
 
-		if err := internal.DeployOverview(app, version, "continue with deployment?"); err != nil {
-			logrus.Fatal(err)
-		}
-
 		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 {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			} else {
-				logrus.Warn("skipping domain checks as no DOMAIN=... configured for app")
+				log.Debug(i18n.G("skipping domain checks, no DOMAIN=... configured"))
 			}
 		} else {
-			logrus.Warn("skipping domain checks as requested")
+			log.Debug(i18n.G("skipping domain checks"))
 		}
 
-		stack.WaitTimeout, err = config.GetTimeoutFromLabel(compose, stackName)
+		deployedVersion := config.MISSING_DEFAULT
+		if deployMeta.IsDeployed {
+			deployedVersion = deployMeta.Version
+			if deployMeta.IsChaos {
+				deployedVersion = deployMeta.ChaosVersion
+			}
+		}
+
+		// Gather secrets
+		secretInfo, err := deploy.GatherSecretsForDeploy(cl, app, internal.ShowUnchanged)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-		logrus.Debugf("set waiting timeout to %d s", stack.WaitTimeout)
 
-		if err := stack.RunDeploy(cl, deployOpts, compose, app.Name, internal.DontWaitConverge); err != nil {
-			logrus.Fatal(err)
+		// Gather configs
+		configInfo, err := deploy.GatherConfigsForDeploy(cl, app, compose, app.Env, internal.ShowUnchanged)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// Gather images
+		imageInfo, err := deploy.GatherImagesForDeploy(cl, app, compose, internal.ShowUnchanged)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// Show deploy overview
+		if err := internal.DeployOverview(
+			app,
+			deployedVersion,
+			toDeployVersion,
+			"",
+			deployWarnMessages,
+			secretInfo,
+			configInfo,
+			imageInfo,
+		); err != nil {
+			log.Fatal(err)
+		}
+
+		stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		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)
 		}
 
 		postDeployCmds, ok := app.Env["POST_DEPLOY_CMDS"]
 		if ok && !internal.DontWaitConverge {
-			logrus.Debugf("run the following post-deploy commands: %s", postDeployCmds)
+			log.Debug(i18n.G("run the following post-deploy commands: %s", postDeployCmds))
 			if err := internal.PostCmds(cl, app, postDeployCmds); err != nil {
-				logrus.Fatalf("attempting to run post deploy commands, saw: %s", err)
+				log.Fatal(i18n.G("attempting to run post deploy commands, saw: %s", err))
 			}
 		}
-		return nil
+
+		if err := app.WriteRecipeVersion(toDeployVersion, false); err != nil {
+			log.Fatal(i18n.G("writing recipe version failed: %s", err))
+		}
 	},
 }
+
+func getLatestVersionOrCommit(app appPkg.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 errors.New(i18n.G("cannot use [version] and --chaos together"))
+	}
+
+	if len(args) == 2 && args[1] != "" && internal.DeployLatest {
+		return errors.New(i18n.G("cannot use [version] and --latest together"))
+	}
+
+	if internal.DeployLatest && internal.Chaos {
+		return errors.New(i18n.G("cannot use --chaos and --latest together"))
+	}
+
+	return nil
+}
+
+func validateSecrets(cl *dockerClient.Client, app appPkg.App) error {
+	composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
+	if err != nil {
+		return err
+	}
+
+	secretsConfig, err := secret.ReadSecretsConfig(app.Path, composeFiles, app.StackName())
+	if err != nil {
+		return err
+	}
+
+	secStats, err := secret.PollSecretsStatus(cl, app)
+	if err != nil {
+		return err
+	}
+
+	for _, secStat := range secStats {
+		if !secStat.CreatedOnRemote {
+			secretConfig := secretsConfig[secStat.LocalName]
+			if secretConfig.SkipGenerate {
+				return errors.New(i18n.G("secret not inserted (#generate=false): %s", secStat.LocalName))
+			}
+			return errors.New(i18n.G("secret not generated: %s", secStat.LocalName))
+		}
+	}
+
+	return nil
+}
+
+func getDeployVersion(cliArgs []string, deployMeta stack.DeployMeta, app appPkg.App) (string, error) {
+	// Chaos mode overrides everything
+	if internal.Chaos {
+		v, err := app.Recipe.ChaosVersion()
+		if err != nil {
+			return "", err
+		}
+		log.Debug(i18n.G("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.Debug(i18n.G("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.DeployLatest {
+		if strings.HasSuffix(app.Recipe.EnvVersionRaw, "+U") {
+			// NOTE(d1): use double-line 5 spaces ("FATA ") trick to make a more
+			// informative error message. it's ugly but that's our logging situation
+			// atm
+			return "", errors.New(i18n.G(`cannot redeploy previous chaos version (%s), did you mean to use "--chaos"?
+     to return to a regular release, specify a release tag, commit SHA or use "--latest"`,
+				formatter.BoldDirtyDefault(app.Recipe.EnvVersionRaw)))
+		}
+		log.Debug(i18n.G("version: taking version from .env file: %s", app.Recipe.EnvVersion))
+		return app.Recipe.EnvVersion, nil
+	}
+
+	// Take deployed version
+	if deployMeta.IsDeployed && !internal.DeployLatest {
+		log.Debug(i18n.G("version: taking deployed version: %s", deployMeta.Version))
+		return deployMeta.Version, nil
+	}
+
+	v, err := getLatestVersionOrCommit(app)
+	log.Debug(i18n.G("version: taking new recipe version: %s", v))
+	if err != nil {
+		return "", err
+	}
+	return v, nil
+}
+
+func init() {
+	AppDeployCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+
+	AppDeployCommand.Flags().BoolVarP(
+		&internal.Force,
+		i18n.G("force"),
+		i18n.G("f"),
+		false,
+		i18n.G("perform action without further prompt"),
+	)
+
+	AppDeployCommand.Flags().BoolVarP(
+		&internal.NoDomainChecks,
+		i18n.G("no-domain-checks"),
+		i18n.G("D"),
+		false,
+		i18n.G("disable public DNS checks"),
+	)
+
+	AppDeployCommand.Flags().BoolVarP(
+		&internal.DontWaitConverge,
+		i18n.G("no-converge-checks"),
+		i18n.G("c"),
+		false,
+		i18n.G("disable converge logic checks"),
+	)
+
+	AppDeployCommand.PersistentFlags().BoolVarP(
+		&internal.DeployLatest,
+		i18n.G("latest"),
+		i18n.G("l"),
+		false,
+		i18n.G("deploy latest recipe version"),
+	)
+
+	AppDeployCommand.Flags().BoolVarP(
+		&internal.ShowUnchanged,
+		i18n.G("show-unchanged"),
+		i18n.G("U"),
+		false,
+		i18n.G("show all configs & images, including unchanged ones"),
+	)
+}

cli/app/env.go

@@ -0,0 +1,51 @@
+package app
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
+	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"github.com/spf13/cobra"
+)
+
+// translators: `abra app env` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appEnvAliases = i18n.G("e")
+
+var AppEnvCommand = &cobra.Command{
+	// translators: `app env` command
+	Use:     i18n.G("env <domain> [flags]"),
+	Aliases: strings.Split(appEnvAliases, ","),
+	// translators: Short description for `app env` command
+	Short:   i18n.G("Show app .env values"),
+	Example: i18n.G("  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(i18n.G("ENV OVERVIEW"), rows)
+		fmt.Println(overview)
+	},
+}

cli/app/errors.go

@@ -1,145 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/recipe"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	containerTypes "github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appErrorsCommand = cli.Command{
-	Name:      "errors",
-	Usage:     "List errors for a deployed app",
-	ArgsUsage: "<domain>",
-	Description: `
-List errors for a deployed app.
-
-This is a best-effort implementation and an attempt to gather a number of tips
-& tricks for finding errors together into one convenient command. When an app
-is failing to deploy or having issues, it could be a lot of things.
-
-This command currently takes into account:
-
-    Is the service deployed?
-    Is the service killed by an OOM error?
-    Is the service reporting an error (like in "ps --no-trunc" output)
-    Is the service healthcheck failing? what are the healthcheck logs?
-
-Got any more ideas? Please let us know:
-
-    https://git.coopcloud.tech/coop-cloud/organising/issues/new/choose
-
-This command is best accompanied by "abra app logs <domain>" which may reveal
-further information which can help you debug the cause of an app failure via
-the logs.
-`,
-	Aliases: []string{"e"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.WatchFlag,
-		internal.OfflineFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		if !internal.Watch {
-			if err := checkErrors(c, cl, app); err != nil {
-				logrus.Fatal(err)
-			}
-			return nil
-		}
-
-		for {
-			if err := checkErrors(c, cl, app); err != nil {
-				logrus.Fatal(err)
-			}
-			time.Sleep(2 * time.Second)
-		}
-	},
-}
-
-func checkErrors(c *cli.Context, cl *dockerClient.Client, app config.App) error {
-	r, err := recipe.Get(app.Recipe)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-	if err := r.LoadConfig(); err != nil {
-		return err
-	}
-
-	for _, service := range r.Config.Services {
-		filters := filters.NewArgs()
-		filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), service.Name))
-
-		containers, err := cl.ContainerList(context.Background(), containerTypes.ListOptions{Filters: filters})
-		if err != nil {
-			return err
-		}
-
-		if len(containers) == 0 {
-			logrus.Warnf("%s is not up, something seems wrong", service.Name)
-			continue
-		}
-
-		container := containers[0]
-		containerState, err := cl.ContainerInspect(context.Background(), container.ID)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if containerState.State.OOMKilled {
-			logrus.Warnf("%s has been killed due to an out of memory error", service.Name)
-		}
-
-		if containerState.State.Error != "" {
-			logrus.Warnf("%s reports this error: %s", service.Name, containerState.State.Error)
-		}
-
-		if containerState.State.Health != nil {
-			if containerState.State.Health.Status != "healthy" {
-				logrus.Warnf("%s healthcheck status is %s", service.Name, containerState.State.Health.Status)
-				logrus.Warnf("%s healthcheck has failed %s times", service.Name, strconv.Itoa(containerState.State.Health.FailingStreak))
-				for _, log := range containerState.State.Health.Log {
-					logrus.Warnf("%s healthcheck logs: %s", service.Name, strings.TrimSpace(log.Output))
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
-func getServiceName(names []string) string {
-	containerName := strings.Join(names, " ")
-	trimmed := strings.TrimPrefix(containerName, "/")
-	return strings.Split(trimmed, ".")[0]
-}

cli/app/labels.go

@@ -0,0 +1,147 @@
+package app
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"strings"
+
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
+	"coopcloud.tech/abra/pkg/client"
+	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"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"
+)
+
+// translators: `abra app labels` aliases. use a comma separated list of
+// aliases with no spaces in between
+var appLabelsAliases = i18n.G("lb")
+
+var AppLabelsCommand = &cobra.Command{
+	// translators: `app labels` command
+	Use:     i18n.G("labels <domain> [flags]"),
+	Aliases: strings.Split(appLabelsAliases, ","),
+	// translators: Short description for `app labels` command
+	Short:   i18n.G("Show deployment labels"),
+	Long:    i18n.G("Both local recipe and live deployment labels are shown."),
+	Example: "  " + i18n.G("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{
+			{i18n.G("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{i18n.G("unknown")})
+		}
+
+		rows = append(rows, []string{i18n.G("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(i18n.G("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,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+}

cli/app/list.go

@@ -8,37 +8,15 @@ import (
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/config"
+	appPkg "coopcloud.tech/abra/pkg/app"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/tagcmp"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var status bool
-var statusFlag = &cli.BoolFlag{
-	Name:        "status, S",
-	Usage:       "Show app deployment status",
-	Destination: &status,
-}
-
-var recipeFilter string
-var recipeFlag = &cli.StringFlag{
-	Name:        "recipe, r",
-	Value:       "",
-	Usage:       "Show apps of a specific recipe",
-	Destination: &recipeFilter,
-}
-
-var listAppServer string
-var listAppServerFlag = &cli.StringFlag{
-	Name:        "server, s",
-	Value:       "",
-	Usage:       "Show apps of a specific server",
-	Destination: &listAppServer,
-}
-
 type appStatus struct {
 	Server       string `json:"server"`
 	Recipe       string `json:"recipe"`
@@ -47,7 +25,6 @@ type appStatus struct {
 	Status       string `json:"status"`
 	Chaos        string `json:"chaos"`
 	ChaosVersion string `json:"chaosVersion"`
-	AutoUpdate   string `json:"autoUpdate"`
 	Version      string `json:"version"`
 	Upgrade      string `json:"upgrade"`
 }
@@ -61,42 +38,42 @@ type serverStatus struct {
 	UpgradeCount     int         `json:"upgradeCount"`
 }
 
-var appListCommand = cli.Command{
-	Name:    "list",
-	Aliases: []string{"ls"},
-	Usage:   "List all managed apps",
-	Description: `
-Read the local file system listing of apps and servers (e.g. ~/.abra/) to
-generate a report of all your apps.
+// translators: `abra app list` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appListAliases = i18n.G("ls")
 
-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.DebugFlag,
-		internal.MachineReadableFlag,
-		statusFlag,
-		listAppServerFlag,
-		recipeFlag,
-		internal.OfflineFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		appFiles, err := config.LoadAppFiles(listAppServer)
+var AppListCommand = &cobra.Command{
+	// translators: `app list` command
+	Use:     i18n.G("list [flags]"),
+	Aliases: strings.Split(appListAliases, ","),
+	// translators: Short description for `app list` command
+	Short: i18n.G("List all managed apps"),
+	Long: i18n.G(`Generate a report of all managed apps.
+
+Use "--status/-S" flag to query all servers for the live deployment status.`),
+	Example: i18n.G(`  # 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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		apps, err := config.GetApps(appFiles, recipeFilter)
+		apps, err := appPkg.GetApps(appFiles, recipeFilter)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		sort.Sort(config.ByServerAndRecipe(apps))
+		sort.Sort(appPkg.ByServerAndRecipe(apps))
 
 		statuses := make(map[string]map[string]string)
-		var catl recipe.RecipeCatalogue
 		if status {
 			alreadySeen := make(map[string]bool)
 			for _, app := range apps {
@@ -105,14 +82,9 @@ can take some time.
 				}
 			}
 
-			statuses, err = config.GetAppStatuses(apps, internal.MachineReadable)
+			statuses, err = appPkg.GetAppStatuses(apps, internal.MachineReadable)
 			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			catl, err = recipe.ReadRecipeCatalogue(internal.Offline)
-			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
@@ -130,7 +102,7 @@ can take some time.
 				}
 			}
 
-			if app.Recipe == recipeFilter || recipeFilter == "" {
+			if app.Recipe.Name == recipeFilter || recipeFilter == "" {
 				if recipeFilter != "" {
 					// only count server if matches filter
 					totalServersCount++
@@ -141,11 +113,10 @@ can take some time.
 				totalAppsCount++
 
 				if status {
-					status := "unknown"
-					version := "unknown"
-					chaos := "unknown"
-					chaosVersion := "unknown"
-					autoUpdate := "unknown"
+					status := i18n.G("unknown")
+					version := i18n.G("unknown")
+					chaos := i18n.G("unknown")
+					chaosVersion := i18n.G("unknown")
 					if statusMeta, ok := statuses[app.StackName()]; ok {
 						if currentVersion, exists := statusMeta["version"]; exists {
 							if currentVersion != "" {
@@ -158,9 +129,6 @@ can take some time.
 						if chaosDeployVersion, exists := statusMeta["chaosVersion"]; exists {
 							chaosVersion = chaosDeployVersion
 						}
-						if autoUpdateState, exists := statusMeta["autoUpdate"]; exists {
-							autoUpdate = autoUpdateState
-						}
 						if statusMeta["status"] != "" {
 							status = statusMeta["status"]
 						}
@@ -173,24 +141,32 @@ can take some time.
 					appStats.Chaos = chaos
 					appStats.ChaosVersion = chaosVersion
 					appStats.Version = version
-					appStats.AutoUpdate = autoUpdate
 
 					var newUpdates []string
-					if version != "unknown" {
-						updates, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
+					if version != "unknown" && chaos == "false" {
+						if err := app.Recipe.EnsureExists(); err != nil {
+							log.Fatal(i18n.G("unable to clone %s: %s", app.Name, err))
+						}
+
+						updates, err := app.Recipe.Tags()
 						if err != nil {
-							logrus.Fatal(err)
+							log.Fatal(i18n.G("unable to retrieve tags for %s: %s", app.Name, err))
 						}
 
 						parsedVersion, err := tagcmp.Parse(version)
 						if err != nil {
-							logrus.Fatal(err)
+							log.Fatal(err)
 						}
 
 						for _, update := range updates {
+							if ok := tagcmp.IsParsable(update); !ok {
+								log.Debug(i18n.G("unable to parse %s, skipping as upgrade option", update))
+								continue
+							}
+
 							parsedUpdate, err := tagcmp.Parse(update)
 							if err != nil {
-								logrus.Fatal(err)
+								log.Fatal(err)
 							}
 
 							if update != version && parsedUpdate.IsGreaterThan(parsedVersion) {
@@ -201,20 +177,20 @@ can take some time.
 
 					if len(newUpdates) == 0 {
 						if version == "unknown" {
-							appStats.Upgrade = "unknown"
+							appStats.Upgrade = i18n.G("unknown")
 						} else {
-							appStats.Upgrade = "latest"
+							appStats.Upgrade = i18n.G("latest")
 							stats.LatestCount++
 						}
 					} else {
-						newUpdates = internal.ReverseStringList(newUpdates)
+						newUpdates = internal.SortVersionsDesc(newUpdates)
 						appStats.Upgrade = strings.Join(newUpdates, "\n")
 						stats.UpgradeCount++
 					}
 				}
 
 				appStats.Server = app.Server
-				appStats.Recipe = app.Recipe
+				appStats.Recipe = app.Recipe.Name
 				appStats.AppName = app.Name
 				appStats.Domain = app.Domain
 
@@ -226,11 +202,12 @@ can take some time.
 		if internal.MachineReadable {
 			jsonstring, err := json.Marshal(allStats)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			} else {
 				fmt.Println(string(jsonstring))
 			}
-			return nil
+
+			return
 		}
 
 		alreadySeen := make(map[string]bool)
@@ -241,60 +218,117 @@ can take some time.
 
 			serverStat := allStats[app.Server]
 
-			tableCol := []string{"recipe", "domain"}
+			headers := []string{i18n.G("RECIPE"), i18n.G("DOMAIN"), i18n.G("SERVER")}
 			if status {
-				tableCol = append(tableCol, []string{"status", "chaos", "version", "upgrade", "autoupdate"}...)
+				headers = append(headers, []string{
+					i18n.G("STATUS"),
+					i18n.G("CHAOS"),
+					i18n.G("VERSION"),
+					i18n.G("UPGRADE"),
+				}...,
+				)
 			}
 
-			table := formatter.CreateTable(tableCol)
+			table, err := formatter.CreateTable()
+			if err != nil {
+				log.Fatal(err)
+			}
 
+			table.Headers(headers...)
+
+			var rows [][]string
 			for _, appStat := range serverStat.Apps {
-				tableRow := []string{appStat.Recipe, appStat.Domain}
+				row := []string{appStat.Recipe, appStat.Domain, appStat.Server}
 				if status {
 					chaosStatus := appStat.Chaos
 					if chaosStatus != "unknown" {
 						chaosEnabled, err := strconv.ParseBool(chaosStatus)
 						if err != nil {
-							logrus.Fatal(err)
+							log.Fatal(err)
 						}
 						if chaosEnabled && appStat.ChaosVersion != "unknown" {
 							chaosStatus = appStat.ChaosVersion
 						}
 					}
-					tableRow = append(tableRow, []string{appStat.Status, chaosStatus, appStat.Version, appStat.Upgrade, appStat.AutoUpdate}...)
+
+					row = append(row, []string{
+						appStat.Status,
+						chaosStatus,
+						appStat.Version,
+						appStat.Upgrade}...,
+					)
 				}
-				table.Append(tableRow)
+
+				rows = append(rows, row)
 			}
 
-			if table.NumLines() > 0 {
-				table.Render()
+			table.Rows(rows...)
 
-				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 {
-					fmt.Println(fmt.Sprintf("server: %s | total apps: %v", app.Server, serverStat.AppCount))
+			if len(rows) > 0 {
+				if err := formatter.PrintTable(table); err != nil {
+					log.Fatal(err)
 				}
-			}
 
-			if len(allStats) > 1 && table.NumLines() > 0 {
-				fmt.Println() // newline separator for multiple servers
+				if len(allStats) > 1 && len(rows) > 0 {
+					fmt.Println() // newline separator for multiple servers
+				}
 			}
 
 			alreadySeen[app.Server] = true
 		}
-
-		if len(allStats) > 1 {
-			fmt.Println(fmt.Sprintf("total servers: %v | total apps: %v ", totalServersCount, totalAppsCount))
-		}
-
-		return nil
 	},
 }
+
+var (
+	status        bool
+	recipeFilter  string
+	listAppServer string
+)
+
+func init() {
+	AppListCommand.Flags().BoolVarP(
+		&status,
+		i18n.G("status"),
+		i18n.G("S"),
+		false,
+		i18n.G("show app deployment status"),
+	)
+
+	AppListCommand.Flags().StringVarP(
+		&recipeFilter,
+		i18n.G("recipe"),
+		i18n.G("r"),
+		"",
+		i18n.G("show apps of a specific recipe"),
+	)
+
+	AppListCommand.RegisterFlagCompletionFunc(
+		i18n.G("recipe"),
+		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			return autocomplete.RecipeNameComplete()
+		},
+	)
+
+	AppListCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		i18n.G("machine"),
+		i18n.G("m"),
+		false,
+		i18n.G("print machine-readable output"),
+	)
+
+	AppListCommand.Flags().StringVarP(
+		&listAppServer,
+		i18n.G("server"),
+		i18n.G("s"),
+		"",
+		i18n.G("show apps of a specific server"),
+	)
+
+	AppListCommand.RegisterFlagCompletionFunc(
+		i18n.G("server"),
+		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			return autocomplete.ServerNameComplete()
+		},
+	)
+}

cli/app/logs.go

@@ -2,144 +2,112 @@ package app
 
 import (
 	"context"
-	"io"
-	"os"
-	"slices"
-	"sync"
-	"time"
+	"strings"
 
 	"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/config"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/i18n"
+	"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/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var appLogsCommand = cli.Command{
-	Name:      "logs",
-	Aliases:   []string{"l"},
-	ArgsUsage: "<domain> [<service>]",
-	Usage:     "Tail app logs",
-	Flags: []cli.Flag{
-		internal.StdErrOnlyFlag,
-		internal.SinceLogsFlag,
-		internal.DebugFlag,
+// translators: `abra app logs` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appLogsAliases = i18n.G("l")
+
+var AppLogsCommand = &cobra.Command{
+	// translators: `app logs` command
+	Use:     i18n.G("logs <domain> [service] [flags]"),
+	Aliases: strings.Split(appLogsAliases, ","),
+	// translators: Short description for `app logs` command
+	Short: i18n.G("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 {
+				return []string{i18n.G("autocomplete failed: %s", err)}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.ServiceNameComplete(app.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 		stackName := app.StackName()
 
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
+		if err := app.Recipe.EnsureExists(); err != nil {
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+		if !deployMeta.IsDeployed {
+			log.Fatal(i18n.G("%s is not deployed?", app.Name))
 		}
 
-		serviceName := c.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 {
-			logrus.Fatal(err)
+			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 config.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,
+		i18n.G("stderr"),
+		i18n.G("s"),
+		false,
+		i18n.G("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 {
-					logrus.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 {
-				logrus.Fatal(err)
-			}
-			defer logs.Close()
-
-			_, err = io.Copy(os.Stdout, logs)
-			if err != nil && err != io.EOF {
-				logrus.Fatal(err)
-			}
-		}(service.ID)
-	}
-
-	// Wait for all log streams to be closed.
-	wg.Wait()
-
-	return nil
+	AppLogsCommand.Flags().StringVarP(
+		&sinceLogs,
+		i18n.G("since"),
+		i18n.G("S"),
+		"",
+		i18n.G("tail logs since YYYY-MM-DDTHH:MM:SSZ"),
+	)
 }

cli/app/move.go

@@ -0,0 +1,350 @@
+package app
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"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"
+	containerPkg "coopcloud.tech/abra/pkg/container"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/secret"
+	"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/mount"
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/docker/docker/api/types/volume"
+	dockerclient "github.com/docker/docker/client"
+	"github.com/spf13/cobra"
+)
+
+// translators: `abra app move` aliases. use a comma separated list of aliases
+// with no spaces in between
+var appMoveAliases = i18n.G("m")
+
+var AppMoveCommand = &cobra.Command{
+	// translators: `app move` command
+	Use:     i18n.G("move <domain> <server> [flags]"),
+	Aliases: strings.Split(appMoveAliases, ","),
+	// translators: Short description for `app move` command
+	Short: i18n.G("Moves an app to a different server"),
+	Long: i18n.G(`Move an app to a differnt server.
+
+This command will migrate an app config and copy secrets and volumes from the
+old server to the new one. The app MUST be deployed on the old server before
+doing the move. The app will be undeployed from the current server but not
+deployed on the new server.
+
+The "tar" command is required on both the old and new server as well as "sudo"
+permissions. The "rsync" command is required on your local machine for
+transferring volumes.
+
+Do not forget to update your DNS records. Don't panic, it might take a while
+for the dust to settle after you move an app. If anything goes wrong, you can
+always move the app config file to the original server and deploy it there
+again. No data is removed from the old server.
+
+Use "--dry-run/-r" to see which secrets and volumes will be moved.`),
+	Example: i18n.G(`  # move an app
+  abra app move nextcloud.1312.net myserver.com`),
+	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:
+			return autocomplete.ServerNameComplete()
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
+
+		if len(args) <= 1 {
+			log.Fatal(i18n.G("no server provided?"))
+		}
+		newServer := internal.ValidateServer([]string{args[1]})
+
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
+		}
+
+		currentServerClient, err := client.New(app.Server)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		deployMeta, err := stack.IsDeployed(context.Background(), currentServerClient, app.StackName())
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if !deployMeta.IsDeployed {
+			log.Fatal(i18n.G("%s must first be deployed on %s before moving", app.Name, app.Server))
+		}
+
+		resources, err := getAppResources(currentServerClient, app)
+		if err != nil {
+			log.Fatal(i18n.G("unable to retrieve %s resources on %s: %s", app.Name, app.Server, err))
+		}
+
+		internal.MoveOverview(app, newServer, resources.SecretNames(), resources.VolumeNames())
+		if err := internal.PromptProcced(); err != nil {
+			log.Fatal(i18n.G("bailing out: %s", err))
+		}
+
+		log.Info(i18n.G("undeploying %s on %s", app.Name, app.Server))
+		rmOpts := stack.Remove{
+			Namespaces: []string{app.StackName()},
+			Detach:     false,
+		}
+		if err := stack.RunRemove(context.Background(), currentServerClient, rmOpts); err != nil {
+			log.Fatal(i18n.G("failed to remove app from %s: %s", err, app.Server))
+		}
+
+		newServerClient, err := client.New(newServer)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, s := range resources.SecretList {
+			sname := strings.Split(strings.TrimPrefix(s.Spec.Name, app.StackName()+"_"), "_")
+			secretName := strings.Join(sname[:len(sname)-1], "_")
+			data := resources.Secrets[secretName]
+			if err := client.StoreSecret(newServerClient, s.Spec.Name, data); err != nil {
+				log.Fatal(i18n.G("failed to store secret on %s: %s", err, newServer))
+			}
+			log.Info(i18n.G("created secret on %s: %s", s.Spec.Name, newServer))
+		}
+
+		for _, v := range resources.Volumes {
+			log.Info(i18n.G("moving volume %s from %s to %s", v.Name, app.Server, newServer))
+
+			// NOTE(p4u1): Need to create the volume before copying the data, because
+			// when docker creates a new volume it set the folder permissions to
+			// root, which might be wrong. This ensures we always have the correct
+			// folder permissions inside the volume.
+			log.Debug(i18n.G("creating volume %s on %s", v.Name, newServer))
+			_, err := newServerClient.VolumeCreate(context.Background(), volume.CreateOptions{
+				Name:   v.Name,
+				Driver: v.Driver,
+			})
+			if err != nil {
+				log.Fatal(i18n.G("failed to create volume %s on %s: %s", v.Name, newServer, err))
+			}
+
+			filename := fmt.Sprintf("%s_outgoing.tar.gz", v.Name)
+			log.Debug(i18n.G("creating %s on %s", filename, app.Server))
+			tarCmd := fmt.Sprintf("sudo tar --same-owner -czhpf %s -C /var/lib/docker/volumes %s", filename, v.Name)
+			cmd := exec.Command("ssh", app.Server, "-tt", tarCmd)
+			if out, err := cmd.CombinedOutput(); err != nil {
+				log.Fatal(i18n.G("%s failed on %s: output:%s err:%s", tarCmd, app.Server, string(out), err))
+			}
+
+			log.Debug(i18n.G("rsyncing %s from %s to local machine", filename, app.Server))
+			cmd = exec.Command("rsync", "-a", "-v", fmt.Sprintf("%s:%s", app.Server, filename), filename)
+			if out, err := cmd.CombinedOutput(); err != nil {
+				log.Fatal(i18n.G("failed to copy %s from %s to local machine: output:%s err:%s", filename, app.Server, string(out), err))
+			}
+
+			log.Debug(i18n.G("rsyncing %s to %s from local machine", filename, filename, newServer))
+			cmd = exec.Command("rsync", "-a", "-v", filename, fmt.Sprintf("%s:%s", newServer, filename))
+			if out, err := cmd.CombinedOutput(); err != nil {
+				log.Fatal(i18n.G("failed to copy %s from local machine to %s: output:%s err:%s", filename, newServer, string(out), err))
+			}
+
+			log.Debug(i18n.G("extracting %s on %s", filename, newServer))
+			tarExtractCmd := fmt.Sprintf("sudo tar --same-owner -xzpf %s -C /var/lib/docker/volumes", filename)
+			cmd = exec.Command("ssh", newServer, "-tt", tarExtractCmd)
+			if out, err := cmd.CombinedOutput(); err != nil {
+				log.Fatal(i18n.G("%s failed to extract %s on %s: output:%s err:%s", tarExtractCmd, filename, newServer, string(out), err))
+			}
+
+			// Remove tar files
+			log.Debug(i18n.G("removing %s from %s", filename, newServer))
+			cmd = exec.Command("ssh", newServer, "-tt", fmt.Sprintf("sudo rm -rf %s", filename))
+			if out, err := cmd.CombinedOutput(); err != nil {
+				log.Fatal(i18n.G("failed to remove %s from %s: output:%s err:%s", filename, newServer, string(out), err))
+			}
+
+			log.Debug(i18n.G("removing %s from %s", filename, app.Server))
+			cmd = exec.Command("ssh", app.Server, "-tt", fmt.Sprintf("sudo rm -rf %s", filename))
+			if out, err := cmd.CombinedOutput(); err != nil {
+				log.Fatal(i18n.G("failed to remove %s from %s: output:%s err:%s", filename, app.Server, string(out), err))
+			}
+
+			log.Debug(i18n.G("removing %s from local machine", filename))
+			cmd = exec.Command("rm", "-r", "-f", filename)
+			if out, err := cmd.CombinedOutput(); err != nil {
+				log.Fatal(i18n.G("failed to remove %s on local machine: output:%s err:%s", filename, string(out), err))
+			}
+		}
+
+		newServerPath := fmt.Sprintf("%s/servers/%s/%s.env", config.ABRA_DIR, newServer, app.Name)
+		log.Info(i18n.G("migrating app config from %s to %s", app.Server, newServerPath))
+		if err := copyFile(app.Path, newServerPath); err != nil {
+			log.Fatal(i18n.G("failed to migrate app config: %s", err))
+		}
+
+		if err := os.Remove(app.Path); err != nil {
+			log.Fatal(i18n.G("unable to remove %s: %s", app.Path, err))
+		}
+
+		log.Info(i18n.G("%s was successfully moved from %s to %s 🎉", app.Name, app.Server, newServer))
+	},
+}
+
+type AppResources struct {
+	Secrets    map[string]string
+	SecretList []swarm.Secret
+	Volumes    map[string]containertypes.MountPoint
+}
+
+func (a *AppResources) SecretNames() []string {
+	secrets := []string{}
+	for name := range a.Secrets {
+		secrets = append(secrets, name)
+	}
+	return secrets
+}
+
+func (a *AppResources) VolumeNames() []string {
+	volumes := []string{}
+	for name := range a.Volumes {
+		volumes = append(volumes, name)
+	}
+	return volumes
+}
+
+func getAppResources(cl *dockerclient.Client, app app.App) (*AppResources, error) {
+	filter, err := app.Filters(false, false)
+	if err != nil {
+		return nil, err
+	}
+
+	services, err := cl.ServiceList(context.Background(), types.ServiceListOptions{Filters: filter})
+	if err != nil {
+		return nil, err
+	}
+
+	composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
+	if err != nil {
+		return nil, err
+	}
+
+	secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: filter})
+	if err != nil {
+		return nil, err
+	}
+
+	secretConfigs, err := secret.ReadSecretsConfig(app.Path, composeFiles, app.StackName())
+	if err != nil {
+		return nil, err
+	}
+
+	opts := stack.Deploy{Composefiles: composeFiles, Namespace: app.StackName()}
+	compose, err := appPkg.GetAppComposeConfig(app.Name, opts, app.Env)
+	if err != nil {
+		return nil, err
+	}
+
+	resources := &AppResources{
+		Secrets:    make(map[string]string),
+		SecretList: secretList,
+		Volumes:    make(map[string]containertypes.MountPoint),
+	}
+
+	for _, s := range services {
+		secretNames := map[string]string{}
+		for _, serviceCompose := range compose.Services {
+			stackService := fmt.Sprintf("%s_%s", app.StackName(), serviceCompose.Name)
+			if stackService != s.Spec.Name {
+				log.Debug(i18n.G("skipping %s as it does not match %s", stackService, s.Spec.Name))
+				continue
+			}
+
+			for _, secret := range serviceCompose.Secrets {
+				for _, s := range secretList {
+					stackSecret := fmt.Sprintf("%s_%s_%s", app.StackName(), secret.Source, secretConfigs[secret.Source].Version)
+					if s.Spec.Name == stackSecret {
+						secretNames[secret.Source] = s.ID
+						break
+					}
+				}
+			}
+		}
+
+		f := filters.NewArgs()
+		f.Add("name", s.Spec.Name)
+		targetContainer, err := containerPkg.GetContainer(context.Background(), cl, f, true)
+		if err != nil {
+			return nil, errors.New(i18n.G("unable to get container matching %s: %s", s.Spec.Name, err))
+		}
+
+		for _, m := range targetContainer.Mounts {
+			if m.Type == mount.TypeVolume {
+				resources.Volumes[m.Name] = m
+			}
+		}
+
+		for secretName, secretID := range secretNames {
+			if _, ok := resources.Secrets[secretName]; ok {
+				continue
+			}
+
+			log.Debug(i18n.G("extracting secret %s on %s", secretName, app.Server))
+
+			cmd := fmt.Sprintf("sudo cat /var/lib/docker/containers/%s/mounts/secrets/%s", targetContainer.ID, secretID)
+			out, err := exec.Command("ssh", app.Server, "-tt", cmd).Output()
+			if err != nil {
+				return nil, errors.New(i18n.G("%s failed on %s: output:%s err:%s", cmd, app.Server, string(out), err))
+			}
+
+			resources.Secrets[secretName] = string(out)
+		}
+	}
+
+	return resources, nil
+}
+
+func copyFile(src string, dst string) error {
+	// Read all content of src to data, may cause OOM for a large file.
+	data, err := os.ReadFile(src)
+	if err != nil {
+		return err
+	}
+
+	// Write data to dst
+	err = os.WriteFile(dst, data, 0o644)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func init() {
+	AppMoveCommand.Flags().BoolVarP(
+		&internal.Dry,
+		i18n.G("dry-run"),
+		i18n.G("r"),
+		false,
+		i18n.G("report changes that would be made"),
+	)
+}

cli/app/new.go

@@ -1,32 +1,39 @@
 package app
 
 import (
+	"errors"
 	"fmt"
-	"path"
+	"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/formatter"
-	"coopcloud.tech/abra/pkg/jsontable"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/abra/pkg/secret"
 	"github.com/AlecAivazis/survey/v2"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var appNewDescription = `
-Take a recipe and uses it to create a new app. This new app configuration is
-stored in your ~/.abra directory under the appropriate server.
+var appNewDescription = i18n.G(`Creates a new app from a default recipe.
+
+This new app configuration is stored in your $ABRA_DIR directory under the
+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]".
+
 Passing the "--secrets/-S" flag will automatically generate secrets for your
 app and store them encrypted at rest on the chosen target server. These
 generated secrets are only visible at generation time, so please take care to
@@ -34,165 +41,205 @@ store them somewhere safe.
 
 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.
-`
+on your $PATH.`)
 
-var appNewCommand = cli.Command{
-	Name:        "new",
-	Aliases:     []string{"n"},
-	Usage:       "Create a new app",
-	Description: appNewDescription,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.NewAppServerFlag,
-		internal.DomainFlag,
-		internal.PassFlag,
-		internal.SecretsFlag,
-		internal.OfflineFlag,
-		internal.ChaosFlag,
-	},
-	Before:    internal.SubCommandBefore,
-	ArgsUsage: "[<recipe>] [<version>]",
-	BashComplete: func(ctx *cli.Context) {
-		args := ctx.Args()
-		switch len(args) {
+// translators: `abra app new` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appNewAliases = i18n.G("n")
+
+var AppNewCommand = &cobra.Command{
+	// translators: `app new` command
+	Use:     i18n.G("new [recipe] [version] [flags]"),
+	Aliases: strings.Split(appNewAliases, ","),
+	// translators: Short description for `app new` command
+	Short: i18n.G("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)
+			return autocomplete.RecipeNameComplete()
 		case 1:
-			autocomplete.RecipeVersionComplete(ctx.Args().Get(0))
+			recipe := internal.ValidateRecipe(args, cmd.Name())
+			return autocomplete.RecipeVersionComplete(recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
 		}
 	},
-	Action: func(c *cli.Context) error {
-		r := internal.ValidateRecipe(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
 
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-			if c.Args().Get(1) == "" {
-				var version string
+		if len(args) == 2 && internal.Chaos {
+			log.Fatal(i18n.G("cannot use [version] and --chaos together"))
+		}
 
-				recipeVersions, err := r.GetVersions(internal.Offline)
+		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)
+			}
+
+			var recipeVersions recipePkg.RecipeVersions
+			if recipeVersion == "" {
+				var err error
+				recipeVersions, _, err = recipe.GetRecipeVersions()
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
+				}
+			}
+
+			if len(recipeVersions) > 0 {
+				latest := recipeVersions[len(recipeVersions)-1]
+				for tag := range latest {
+					recipeVersion = tag
 				}
 
-				// NOTE(d1): determine whether recipe versions exist or not and check
-				// out the latest version or current HEAD
-				if len(recipeVersions) > 0 {
-					latest := recipeVersions[len(recipeVersions)-1]
-					for tag := range latest {
-						version = tag
-					}
-
-					if err := r.EnsureVersion(version); err != nil {
-						logrus.Fatal(err)
-					}
-				} else {
-					if err := r.EnsureLatest(); err != nil {
-						logrus.Fatal(err)
-					}
+				if _, err := recipe.EnsureVersion(recipeVersion); err != nil {
+					log.Fatal(err)
 				}
 			} else {
-				if err := r.EnsureVersion(c.Args().Get(1)); err != nil {
-					logrus.Fatal(err)
+				if err := recipe.EnsureLatest(); err != nil {
+					log.Fatal(err)
+				}
+
+				if recipeVersion == "" {
+					head, err := recipe.Head()
+					if err != nil {
+						log.Fatal(i18n.G("failed to retrieve latest commit for %s: %s", recipe.Name, err))
+					}
+
+					recipeVersion = formatter.SmallSHA(head.String())
 				}
 			}
 		}
 
 		if err := ensureServerFlag(); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if err := ensureDomainFlag(r.Name, internal.NewAppServer); err != nil {
-			logrus.Fatal(err)
+		if err := ensureDomainFlag(recipe, newAppServer); err != nil {
+			log.Fatal(err)
 		}
 
-		sanitisedAppName := config.SanitiseAppName(internal.Domain)
-		logrus.Debugf("%s sanitised as %s for new app", internal.Domain, sanitisedAppName)
+		sanitisedAppName := appPkg.SanitiseAppName(appDomain)
+		log.Debug(i18n.G("%s sanitised as %s for new app", appDomain, sanitisedAppName))
 
-		if err := config.TemplateAppEnvSample(
-			r.Name,
-			internal.Domain,
-			internal.NewAppServer,
-			internal.Domain,
+		if err := appPkg.TemplateAppEnvSample(
+			recipe,
+			appDomain,
+			newAppServer,
+			appDomain,
 		); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		var secrets AppSecrets
-		var secretTable *jsontable.JSONTable
-		if internal.Secrets {
-			sampleEnv, err := r.SampleEnv()
+		sampleEnv, err := recipe.SampleEnv()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		composeFiles, err := recipe.GetComposeFiles(sampleEnv)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		secretsConfig, err := secret.ReadSecretsConfig(
+			recipe.SampleEnvPath,
+			composeFiles,
+			appPkg.StackName(appDomain),
+		)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		var appSecrets AppSecrets
+		if generateSecrets {
+			if err := promptForSecrets(recipe.Name, secretsConfig); err != nil {
+				log.Fatal(err)
+			}
+
+			cl, err := client.New(newAppServer)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
-			composeFiles, err := config.GetComposeFiles(r.NameEscaped, sampleEnv)
+			appSecrets, err = createSecrets(cl, secretsConfig, sanitisedAppName)
 			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			envSamplePath := path.Join(r.Dir, ".env.sample")
-			secretsConfig, err := secret.ReadSecretsConfig(envSamplePath, composeFiles, config.StackName(internal.Domain))
-			if err != nil {
-				return err
-			}
-
-			if err := promptForSecrets(r.Name, secretsConfig); err != nil {
-				logrus.Fatal(err)
-			}
-
-			cl, err := client.New(internal.NewAppServer)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			secrets, err = createSecrets(cl, secretsConfig, sanitisedAppName)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			secretCols := []string{"Name", "Value"}
-			secretTable = formatter.CreateTable(secretCols)
-			for name, val := range secrets {
-				secretTable.Append([]string{name, val})
+				log.Fatal(err)
 			}
 		}
 
-		if internal.NewAppServer == "default" {
-			internal.NewAppServer = "local"
+		if newAppServer == "default" {
+			newAppServer = "local"
 		}
 
-		tableCol := []string{"server", "recipe", "domain"}
-		table := formatter.CreateTable(tableCol)
-		table.Append([]string{internal.NewAppServer, r.Name, internal.Domain})
+		log.Info(i18n.G("%s created (version: %s)", appDomain, recipeVersion))
 
-		fmt.Println(fmt.Sprintf("A new %s app has been created! Here is an overview:", r.Name))
-		fmt.Println("")
-		table.Render()
-		fmt.Println("")
-		fmt.Println("You can configure this app by running the following:")
-		fmt.Println(fmt.Sprintf("\n    abra app config %s", internal.Domain))
-		fmt.Println("")
-		fmt.Println("You can deploy this app by running the following:")
-		fmt.Println(fmt.Sprintf("\n    abra app deploy %s", internal.Domain))
+		if len(secretsConfig) > 0 {
+			var (
+				hasSecretToGenerate bool
+				hasSecretToSkip     bool
+			)
 
-		if len(secrets) > 0 {
-			fmt.Println("")
-			fmt.Println("Here are your generated secrets:")
-			fmt.Println("")
-			secretTable.Render()
-			logrus.Warn("generated secrets are not shown again, please take note of them NOW")
+			for _, secretConfig := range secretsConfig {
+				if secretConfig.SkipGenerate {
+					hasSecretToSkip = true
+					continue
+				}
+
+				hasSecretToGenerate = true
+			}
+
+			if hasSecretToGenerate && !generateSecrets {
+				log.Warn(i18n.G("%s requires secret generation before deploy, run \"abra app secret generate %s --all\"", recipe.Name, appDomain))
+			}
+
+			if hasSecretToSkip {
+				log.Warn(i18n.G("%s requires secret insertion before deploy (#generate=false)", recipe.Name))
+			}
 		}
 
-		return nil
+		if len(appSecrets) > 0 {
+			rows := [][]string{}
+			for k, v := range appSecrets {
+				rows = append(rows, []string{k, v})
+			}
+
+			overview := formatter.CreateOverview(i18n.G("SECRETS OVERVIEW"), rows)
+
+			fmt.Println(overview)
+
+			log.Warn(i18n.G(
+				"secrets are %s shown again, please save them %s",
+				formatter.BoldUnderlineStyle.Render("NOT"),
+				formatter.BoldUnderlineStyle.Render("NOW"),
+			))
+		}
+
+		app, err := app.Get(appDomain)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if err := app.WriteRecipeVersion(recipeVersion, false); err != nil {
+			log.Fatal(i18n.G("writing recipe version failed: %s", err))
+		}
 	},
 }
 
@@ -203,23 +250,23 @@ type AppSecrets map[string]string
 func createSecrets(cl *dockerClient.Client, secretsConfig map[string]secret.Secret, sanitisedAppName string) (AppSecrets, error) {
 	// NOTE(d1): trim to match app.StackName() implementation
 	if len(sanitisedAppName) > config.MAX_SANITISED_APP_NAME_LENGTH {
-		logrus.Debugf("trimming %s to %s to avoid runtime limits", sanitisedAppName, sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH])
+		log.Debug(i18n.G("trimming %s to %s to avoid runtime limits", sanitisedAppName, sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH]))
 		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
 			}
@@ -230,19 +277,19 @@ 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(recipeName string, server string) error {
-	if internal.Domain == "" && !internal.NoInput {
+func ensureDomainFlag(recipe recipePkg.Recipe, server string) error {
+	if appDomain == "" && !internal.NoInput {
 		prompt := &survey.Input{
-			Message: "Specify app domain",
-			Default: fmt.Sprintf("%s.%s", recipeName, server),
+			Message: i18n.G("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 == "" {
-		return fmt.Errorf("no domain provided")
+	if appDomain == "" {
+		return errors.New(i18n.G("no domain provided"))
 	}
 
 	return nil
@@ -251,15 +298,15 @@ func ensureDomainFlag(recipeName string, server string) error {
 // promptForSecrets asks if we should generate secrets for a new app.
 func promptForSecrets(recipeName string, secretsConfig map[string]secret.Secret) error {
 	if len(secretsConfig) == 0 {
-		logrus.Debugf("%s has no secrets to generate, skipping...", recipeName)
+		log.Debug(i18n.G("%s has no secrets to generate, skipping...", recipeName))
 		return nil
 	}
 
-	if !internal.Secrets && !internal.NoInput {
+	if !generateSecrets && !internal.NoInput {
 		prompt := &survey.Confirm{
-			Message: "Generate app secrets?",
+			Message: i18n.G("Generate app secrets?"),
 		}
-		if err := survey.AskOne(prompt, &internal.Secrets); err != nil {
+		if err := survey.AskOne(prompt, &generateSecrets); err != nil {
 			return err
 		}
 	}
@@ -274,19 +321,82 @@ func ensureServerFlag() error {
 		return err
 	}
 
-	if internal.NewAppServer == "" && !internal.NoInput {
+	if len(servers) == 1 {
+		newAppServer = servers[0]
+		log.Info(i18n.G("single server detected, choosing %s automatically", newAppServer))
+		return nil
+	}
+
+	if newAppServer == "" && !internal.NoInput {
 		prompt := &survey.Select{
-			Message: "Select app server:",
+			Message: i18n.G("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 == "" {
-		return fmt.Errorf("no server provided")
+	if newAppServer == "" {
+		return errors.New(i18n.G("no server provided"))
 	}
 
 	return nil
 }
+
+var (
+	newAppServer    string
+	appDomain       string
+	saveInPass      bool
+	generateSecrets bool
+)
+
+func init() {
+	AppNewCommand.Flags().StringVarP(
+		&newAppServer,
+		i18n.G("server"),
+		i18n.G("s"),
+		"",
+		i18n.G("specify server for new app"),
+	)
+
+	AppNewCommand.RegisterFlagCompletionFunc(
+		i18n.G("server"),
+		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			return autocomplete.ServerNameComplete()
+		},
+	)
+
+	AppNewCommand.Flags().StringVarP(
+		&appDomain,
+		i18n.G("domain"),
+		i18n.G("D"),
+		"",
+		i18n.G("domain name for app"),
+	)
+
+	AppNewCommand.Flags().BoolVarP(
+		&saveInPass,
+		i18n.G("pass"),
+		i18n.G("p"),
+		false,
+		i18n.G("store secrets in a local pass store"),
+	)
+
+	AppNewCommand.Flags().BoolVarP(
+		&generateSecrets,
+		i18n.G("secrets"),
+		i18n.G("S"),
+		false,
+		i18n.G("automatically generate secrets"),
+	)
+
+	AppNewCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+
+}

cli/app/ps.go

@@ -4,89 +4,86 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"time"
+	"sort"
+	"strings"
 
 	"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/config"
 	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	abraService "coopcloud.tech/abra/pkg/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/buger/goterm"
 	dockerFormatter "github.com/docker/cli/cli/command/formatter"
 	containerTypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var appPsCommand = cli.Command{
-	Name:        "ps",
-	Aliases:     []string{"p"},
-	Usage:       "Check app status",
-	ArgsUsage:   "<domain>",
-	Description: "Show a more detailed status output of a specific deployed app",
-	Flags: []cli.Flag{
-		internal.MachineReadableFlag,
-		internal.WatchFlag,
-		internal.DebugFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+// translators: `abra app ps` aliases. use a comma separated list of aliases
+// with no spaces in between
+var appPsAliases = i18n.G("p")
 
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
+var AppPsCommand = &cobra.Command{
+	// translators: `app ps` command
+	Use:     i18n.G("ps <domain> [flags]"),
+	Aliases: strings.Split(appPsAliases, ","),
+	// translators: Short description for `app ps` command
+	Short: i18n.G("Check app deployment status"),
+	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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+		if !deployMeta.IsDeployed {
+			log.Fatal(i18n.G("%s is not deployed?", app.Name))
 		}
 
-		statuses, err := config.GetAppStatuses([]config.App{app}, true)
+		chaosVersion := config.CHAOS_DEFAULT
+		statuses, err := appPkg.GetAppStatuses([]appPkg.App{app}, true)
 		if statusMeta, ok := statuses[app.StackName()]; ok {
-			if _, exists := statusMeta["chaos"]; !exists {
-				if err := r.EnsureVersion(deployedVersion); err != nil {
-					logrus.Fatal(err)
+			if isChaos, exists := statusMeta["chaos"]; exists && isChaos == "true" {
+				if cVersion, exists := statusMeta["chaosVersion"]; exists {
+					chaosVersion = cVersion
+					if strings.HasSuffix(chaosVersion, config.DIRTY_DEFAULT) {
+						chaosVersion = formatter.BoldDirtyDefault(chaosVersion)
+					}
 				}
 			}
 		}
 
-		if !internal.Watch {
-			showPSOutput(c, app, cl)
-			return nil
-		}
-
-		goterm.Clear()
-		for {
-			goterm.MoveCursor(1, 1)
-			showPSOutput(c, app, cl)
-			goterm.Flush()
-			time.Sleep(2 * time.Second)
-		}
+		showPSOutput(app, cl, deployMeta.Version, chaosVersion)
 	},
 }
 
 // showPSOutput renders ps output.
-func showPSOutput(c *cli.Context, app config.App, cl *dockerClient.Client) {
-	composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
+func showPSOutput(app appPkg.App, cl *dockerClient.Client, deployedVersion, chaosVersion string) {
+	composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 		return
 	}
 
@@ -96,65 +93,125 @@ func showPSOutput(c *cli.Context, app config.App, cl *dockerClient.Client) {
 		Prune:        false,
 		ResolveImage: stack.ResolveImageAlways,
 	}
-	compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
+	compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 		return
 	}
 
-	var tablerows [][]string
+	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))
 
 		containers, err := cl.ContainerList(context.Background(), containerTypes.ListOptions{Filters: filters})
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 			return
 		}
 
 		var containerStats map[string]string
-
 		if len(containers) == 0 {
 			containerStats = map[string]string{
-				"service name": service.Name,
-				"image":        "unknown",
-				"created":      "unknown",
-				"status":       "unknown",
-				"state":        "unknown",
-				"ports":        "unknown",
+				"version": deployedVersion,
+				"chaos":   chaosVersion,
+				"service": service.Name,
+				"image":   i18n.G("unknown"),
+				"created": i18n.G("unknown"),
+				"status":  i18n.G("unknown"),
+				"state":   i18n.G("unknown"),
+				"ports":   i18n.G("unknown"),
 			}
 		} else {
 			container := containers[0]
 			containerStats = map[string]string{
-				"service name": abraService.ContainerToServiceName(container.Names, app.StackName()),
-				"image":        formatter.RemoveSha(container.Image),
-				"created":      formatter.HumanDuration(container.Created),
-				"status":       container.Status,
-				"state":        container.State,
-				"ports":        dockerFormatter.DisplayablePorts(container.Ports),
+				"version": deployedVersion,
+				"chaos":   chaosVersion,
+				"service": abraService.ContainerToServiceName(container.Names, app.StackName()),
+				"image":   formatter.RemoveSha(container.Image),
+				"created": formatter.HumanDuration(container.Created),
+				"status":  container.Status,
+				"state":   container.State,
+				"ports":   dockerFormatter.DisplayablePorts(container.Ports),
 			}
 		}
-		allContainerStats[containerStats["service name"]] = containerStats
 
-		var tablerow []string = []string{containerStats["service name"], containerStats["image"], containerStats["created"], containerStats["status"], containerStats["state"], containerStats["ports"]}
-		tablerows = append(tablerows, tablerow)
+		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["status"],
+			containerStats["image"],
+			dVersion,
+			cVersion,
+		}
+
+		rows = append(rows, row)
 	}
+
 	if internal.MachineReadable {
-		jsonstring, err := json.Marshal(allContainerStats)
+		rendered, err := json.Marshal(allContainerStats)
 		if err != nil {
-			logrus.Fatal(err)
-		} else {
-			fmt.Println(string(jsonstring))
+			log.Fatal(i18n.G("unable to convert to JSON: %s", err))
 		}
+
+		fmt.Println(string(rendered))
+
 		return
-	} else {
-		tableCol := []string{"service name", "image", "created", "status", "state", "ports"}
-		table := formatter.CreateTable(tableCol)
-		for _, row := range tablerows {
-			table.Append(row)
-		}
-		table.Render()
+	}
+
+	table, err := formatter.CreateTable()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	headers := []string{
+		i18n.G("SERVICE"),
+		i18n.G("STATUS"),
+		i18n.G("IMAGE"),
+		i18n.G("VERSION"),
+		i18n.G("CHAOS"),
+	}
+
+	table.
+		Headers(headers...).
+		Rows(rows...)
+
+	if err := formatter.PrintTable(table); err != nil {
+		log.Fatal(err)
 	}
 }
+
+func init() {
+	AppPsCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		i18n.G("machine"),
+		i18n.G("m"),
+		false,
+		i18n.G("print machine-readable output"),
+	)
+
+	AppPsCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+}

cli/app/remove.go

@@ -2,27 +2,31 @@ package app
 
 import (
 	"context"
-	"fmt"
-	"log"
 	"os"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/docker/api/types"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var appRemoveCommand = cli.Command{
-	Name:      "remove",
-	Aliases:   []string{"rm"},
-	ArgsUsage: "<domain>",
-	Usage:     "Remove all app data, locally and remotely",
-	Description: `
-This command removes everything related to an app which is already undeployed.
+// translators: `abra app remove` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appRemoveAliases = i18n.G("rm")
+
+var AppRemoveCommand = &cobra.Command{
+	// translators: `app remove` command
+	Use:     i18n.G("remove <domain> [flags]"),
+	Aliases: strings.Split(appRemoveAliases, ","),
+	// translators: Short description for `app remove` command
+	Short: i18n.G("Remove all app data, locally and remotely"),
+	Long: i18n.G(`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.
@@ -37,52 +41,69 @@ Please note, if you delete the local app env file without removing volumes and
 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,
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.OfflineFlag,
+flag.`),
+	Example: i18n.G("  abra app remove 1312.net"),
+	Args:    cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	BashComplete: autocomplete.AppNameComplete,
-	Before:       internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
 		if !internal.Force && !internal.NoInput {
+			log.Warn(i18n.G("ALERTA ALERTA: deleting %s data and config (local/remote)", app.Name))
+
 			response := false
-			msg := "ALERTA ALERTA: this will completely remove %s data and configurations locally and remotely, are you sure?"
-			prompt := &survey.Confirm{Message: fmt.Sprintf(msg, app.Name)}
+			prompt := &survey.Confirm{Message: i18n.G("are you sure?")}
 			if err := survey.AskOne(prompt, &response); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
+
 			if !response {
-				logrus.Fatal("aborting as requested")
+				log.Fatal(i18n.G("aborting as requested"))
 			}
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-		if isDeployed {
-			logrus.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name)
+		if deployMeta.IsDeployed {
+			log.Fatal(i18n.G("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name))
 		}
 
 		fs, err := app.Filters(false, false)
 		if err != nil {
-			logrus.Fatal(err)
+			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.Fatal(i18n.G("removing configs failed: %s", err))
+			}
+
+			log.Info(i18n.G("%d config(s) removed successfully", len(configNames)))
+		} else {
+			log.Info(i18n.G("no configs to remove"))
 		}
 
 		secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: fs})
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secrets := make(map[string]string)
@@ -97,42 +118,50 @@ flag.
 			for _, name := range secretNames {
 				err := cl.SecretRemove(context.Background(), secrets[name])
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
-				logrus.Info(fmt.Sprintf("secret: %s removed", name))
+				log.Info(i18n.G("secret: %s removed", name))
 			}
 		} else {
-			logrus.Info("no secrets to remove")
+			log.Info(i18n.G("no secrets to remove"))
 		}
 
 		fs, err = app.Filters(false, true)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, fs)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		volumeNames := client.GetVolumeNames(volumeList)
 
 		if len(volumeNames) > 0 {
 			err := client.RemoveVolumes(cl, context.Background(), volumeNames, internal.Force, 5)
 			if err != nil {
-				log.Fatalf("removing volumes failed: %s", err)
+				log.Fatal(i18n.G("removing volumes failed: %s", err))
 			}
 
-			logrus.Infof("%d volumes removed successfully", len(volumeNames))
+			log.Info(i18n.G("%d volume(s) removed successfully", len(volumeNames)))
 		} else {
-			logrus.Info("no volumes to remove")
+			log.Info(i18n.G("no volumes to remove"))
 		}
 
 		if err = os.Remove(app.Path); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Info(fmt.Sprintf("file: %s removed", app.Path))
-
-		return nil
+		log.Info(i18n.G("file: %s removed", app.Path))
 	},
 }
+
+func init() {
+	AppRemoveCommand.Flags().BoolVarP(
+		&internal.Force,
+		i18n.G("force"),
+		i18n.G("f"),
+		false,
+		i18n.G("perform action without further prompt"),
+	)
+}

cli/app/restart.go

@@ -2,79 +2,172 @@ package app
 
 import (
 	"context"
-	"errors"
 	"fmt"
+	"strings"
 
 	"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/i18n"
+	"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/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/docker/docker/api/types"
+	"github.com/spf13/cobra"
 )
 
-var appRestartCommand = cli.Command{
-	Name:      "restart",
-	Aliases:   []string{"re"},
-	Usage:     "Restart an app",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	Description:  `This command restarts a service within a deployed app.`,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+// translators: `abra app restart` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appRestartAliases = i18n.G("re")
 
-		serviceNameShort := c.Args().Get(1)
-		if serviceNameShort == "" {
-			err := errors.New("missing service?")
-			internal.ShowSubcommandHelpAndError(c, err)
+var AppRestartCommand = &cobra.Command{
+	// translators: `app restart` command
+	Use:     i18n.G("restart <domain> [[service] | --all-services] [flags]"),
+	Aliases: strings.Split(appRestartAliases, ","),
+	// translators: Short description for `app restart` command
+	Short: i18n.G("Restart an app"),
+	Long: i18n.G(`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.`),
+	Example: i18n.G(`  # 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)
+		}
+
+		var serviceName string
+		if len(args) == 2 {
+			serviceName = args[1]
+		}
+
+		if serviceName == "" && !allServices {
+			log.Fatal(i18n.G("missing [service]"))
+		}
+
+		if serviceName != "" && allServices {
+			log.Fatal(i18n.G("cannot use [service] and --all-services/-a together"))
+		}
+
+		var serviceNames []string
+		if allServices {
+			var err error
+			serviceNames, err = appPkg.GetAppServiceNames(app.Name)
+			if err != nil {
+				log.Fatal(err)
+			}
+		} else {
+			serviceNames = append(serviceNames, serviceName)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+		if !deployMeta.IsDeployed {
+			log.Fatal(i18n.G("%s is not deployed?", app.Name))
 		}
 
-		serviceName := fmt.Sprintf("%s_%s", app.StackName(), serviceNameShort)
+		for _, serviceName := range serviceNames {
+			stackServiceName := fmt.Sprintf("%s_%s", app.StackName(), serviceName)
 
-		logrus.Debugf("attempting to scale %s to 0 (restart logic)", serviceName)
-		if err := upstream.RunServiceScale(context.Background(), cl, serviceName, 0); err != nil {
-			logrus.Fatal(err)
+			service, _, err := cl.ServiceInspectWithRaw(
+				context.Background(),
+				stackServiceName,
+				types.ServiceInspectOptions{},
+			)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			log.Debug(i18n.G("attempting to scale %s to 0", stackServiceName))
+
+			if err := upstream.RunServiceScale(context.Background(), cl, stackServiceName, 0); err != nil {
+				log.Fatal(err)
+			}
+
+			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)
+			}
+
+			log.Debug(i18n.G("%s has been scaled to 0", stackServiceName))
+			log.Debug(i18n.G("attempting to scale %s to 1", stackServiceName))
+
+			if err := upstream.RunServiceScale(context.Background(), cl, stackServiceName, 1); err != nil {
+				log.Fatal(err)
+			}
+
+			if err := stack.WaitOnServices(cmd.Context(), cl, waitOpts); err != nil {
+				log.Fatal(err)
+			}
+
+			log.Debug(i18n.G("%s has been scaled to 1", stackServiceName))
+			log.Info(i18n.G("%s service successfully restarted", serviceName))
 		}
-
-		if err := stack.WaitOnService(context.Background(), cl, serviceName, app.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("%s has been scaled to 0 (restart logic)", serviceName)
-
-		logrus.Debugf("attempting to scale %s to 1 (restart logic)", serviceName)
-		if err := upstream.RunServiceScale(context.Background(), cl, serviceName, 1); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := stack.WaitOnService(context.Background(), cl, serviceName, app.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("%s has been scaled to 1 (restart logic)", serviceName)
-
-		logrus.Infof("%s service successfully restarted", serviceNameShort)
-
-		return nil
 	},
 }
+
+var allServices bool
+
+func init() {
+	AppRestartCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+	AppRestartCommand.Flags().BoolVarP(
+		&allServices,
+		i18n.G("all-services"),
+		i18n.GC("a", "app restart"),
+		false,
+		i18n.G("restart all services"),
+	)
+}

cli/app/restore.go

@@ -2,86 +2,141 @@ package app
 
 import (
 	"fmt"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/spf13/cobra"
 )
 
-var targetPath string
-var targetPathFlag = &cli.StringFlag{
-	Name:        "target, t",
-	Usage:       "Target path",
-	Destination: &targetPath,
-}
+// translators: `abra app restore` aliases. use a comma separated list of
+// aliases with no spaces in between
+var appRestoreAliases = i18n.G("rs")
 
-var appRestoreCommand = cli.Command{
-	Name:      "restore",
-	Aliases:   []string{"rs"},
-	Usage:     "Restore an app backup",
-	ArgsUsage: "<domain> <service>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
-		targetPathFlag,
+var AppRestoreCommand = &cobra.Command{
+	// translators: `app restore` command
+	Use:     i18n.G("restore <domain> [flags]"),
+	Aliases: strings.Split(appRestoreAliases, ","),
+	// translators: Short description for `app restore` command
+	Short: i18n.G("Restore a snapshot"),
+	Long: i18n.G(`Snapshots are restored while apps are deployed.
+
+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,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
+		}
+
+		execEnv := []string{
+			fmt.Sprintf("SERVICE=%s", app.Domain),
+			"MACHINE_LOGS=true",
 		}
 
-		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
 		if snapshot != "" {
-			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			log.Debug(i18n.G("including SNAPSHOT=%s in backupbot exec invocation", snapshot))
 			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
 		}
+
 		if targetPath != "" {
-			logrus.Debugf("including TARGET=%s in backupbot exec invocation", targetPath)
+			log.Debug(i18n.G("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 {
-			logrus.Fatal(err)
+		if internal.NoInput {
+			log.Debug(i18n.G("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.Debug(i18n.G("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.Debug(i18n.G("including CONTAINER=%s in backupbot exec invocation", allServices))
+			execEnv = append(execEnv, fmt.Sprintf("CONTAINER=%s", allServices))
+		}
+
+		if hooks {
+			log.Debug(i18n.G("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,
+		i18n.G("target"),
+		i18n.G("t"),
+		"/",
+		i18n.G("target path"),
+	)
+
+	AppRestoreCommand.Flags().StringArrayVarP(
+		&services,
+		i18n.G("services"),
+		i18n.G("s"),
+		[]string{},
+		i18n.G("restore specific services"),
+	)
+
+	AppRestoreCommand.Flags().StringArrayVarP(
+		&volumes,
+		i18n.G("volumes"),
+		i18n.G("v"),
+		[]string{},
+		i18n.G("restore specific volumes"),
+	)
+
+	AppRestoreCommand.Flags().BoolVarP(
+		&hooks,
+		i18n.G("hooks"),
+		i18n.G("H"),
+		false,
+		i18n.G("enable pre/post-hook command execution"),
+	)
+
+	AppRestoreCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+}

cli/app/rollback.go

@@ -1,244 +1,377 @@
 package app
 
 import (
-	"context"
-	"fmt"
+	"errors"
+	"strings"
 
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/deploy"
+	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
 	"coopcloud.tech/abra/pkg/lint"
-	"coopcloud.tech/abra/pkg/recipe"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/client"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var appRollbackCommand = cli.Command{
-	Name:      "rollback",
-	Aliases:   []string{"rl"},
-	Usage:     "Roll an app back to a previous version",
-	ArgsUsage: "<domain> [<version>]",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.ForceFlag,
-		internal.ChaosFlag,
-		internal.NoDomainChecksFlag,
-		internal.DontWaitConvergeFlag,
-		internal.OfflineFlag,
+// translators: `abra app rollback` aliases. use a comma separated list of
+// aliases with no spaces in between
+var appRollbackAliases = i18n.G("rl")
+
+var AppRollbackCommand = &cobra.Command{
+	// translators: `app rollback` command
+	Use:     i18n.G("rollback <domain> [version] [flags]"),
+	Aliases: strings.Split(appRollbackAliases, ","),
+	// translators: Short description for `app rollback` command
+	Short: i18n.G("Roll an app back to a previous version"),
+	Long: i18n.G(`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: i18n.G(` # 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 {
+				return []string{i18n.G("autocomplete failed: %s", err)}, 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 if one exists.
+	Run: func(cmd *cobra.Command, args []string) {
+		var (
+			downgradeWarnMessages []string
+			chosenDowngrade       string
+			availableDowngrades   []string
+		)
 
-You may pass "--force/-f" to downgrade to the same version again. This can be
-useful if the container runtime has gotten into a weird state.
+		app := internal.ValidateApp(args)
 
-This action could be destructive, please ensure you have a copy of your app
-data beforehand.
-
-Chaos mode ("--chaos") will deploy your local checkout of a recipe as-is,
-including unstaged changes and can be useful for live hacking and testing new
-recipes.
-`,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-		stackName := app.StackName()
-
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		specificVersion := c.Args().Get(1)
-		if specificVersion != "" && internal.Chaos {
-			logrus.Fatal("cannot use <version> and --chaos together")
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if err := r.LoadConfig(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := lint.LintForErrors(r); err != nil {
-			logrus.Fatal(err)
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Debugf("checking whether %s is already deployed", stackName)
-
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := ensureDeployed(cl, app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+		if err := lint.LintForErrors(app.Recipe); err != nil {
+			log.Fatal(err)
 		}
 
-		catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
+		versions, err := app.Recipe.Tags()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if len(versions) == 0 && !internal.Chaos {
-			logrus.Warn("no published versions in catalogue, trying local recipe repository")
-			recipeVersions, err := r.GetVersions(internal.Offline)
-			if err != nil {
-				logrus.Warn(err)
-			}
-			for _, recipeVersion := range recipeVersions {
-				for version := range recipeVersion {
-					versions = append(versions, version)
-				}
-			}
-		}
-
-		var availableDowngrades []string
-		if deployedVersion == "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
-			logrus.Warnf("failed to determine deployed version of %s", app.Name)
 		}
 
-		if specificVersion != "" {
-			parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
+		if len(args) == 2 && args[1] != "" {
+			chosenDowngrade = args[1]
+
+			if err := validateDowngradeVersionArg(chosenDowngrade, app, deployMeta); err != nil {
+				log.Fatal(err)
+			}
+
+			availableDowngrades = append(availableDowngrades, chosenDowngrade)
+		}
+
+		if deployMeta.Version != config.UNKNOWN_DEFAULT && chosenDowngrade == "" {
+			downgradeAvailable, err := ensureDowngradesAvailable(versions, &availableDowngrades, deployMeta)
 			if err != nil {
-				logrus.Fatal(err)
-			}
-			parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			if parsedSpecificVersion.IsGreaterThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) {
-				logrus.Fatalf("%s is not a downgrade for %s?", deployedVersion, specificVersion)
-			}
-			availableDowngrades = append(availableDowngrades, specificVersion)
-		}
-
-		if deployedVersion != "unknown" && !internal.Chaos && specificVersion == "" {
-			for _, version := range versions {
-				parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				parsedVersion, err := tagcmp.Parse(version)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				if parsedVersion.IsLessThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
-					availableDowngrades = append(availableDowngrades, version)
-				}
+				log.Fatal(err)
 			}
 
-			if len(availableDowngrades) == 0 && !internal.Force {
-				logrus.Info("no available downgrades, you're on oldest ✌️")
-				return nil
+			if !downgradeAvailable {
+				log.Info(i18n.G("no available downgrades"))
+				return
 			}
 		}
 
-		var chosenDowngrade string
-		if len(availableDowngrades) > 0 && !internal.Chaos {
-			if internal.Force || internal.NoInput || specificVersion != "" {
+		if internal.Force || internal.NoInput || chosenDowngrade != "" {
+			if len(availableDowngrades) > 0 {
 				chosenDowngrade = availableDowngrades[len(availableDowngrades)-1]
-				logrus.Debugf("choosing %s as version to downgrade to (--force/--no-input)", chosenDowngrade)
-			} else {
-				prompt := &survey.Select{
-					Message: fmt.Sprintf("Please select a downgrade (current version: %s):", deployedVersion),
-					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.Chaos {
-			if err := r.EnsureVersion(chosenDowngrade); err != nil {
-				logrus.Fatal(err)
-			}
+		if internal.Force &&
+			chosenDowngrade == "" &&
+			deployMeta.Version != config.UNKNOWN_DEFAULT {
+			chosenDowngrade = deployMeta.Version
 		}
 
-		if internal.Chaos {
-			logrus.Warn("chaos mode engaged")
-			var err error
-			chosenDowngrade, err = r.ChaosVersion()
-			if err != nil {
-				logrus.Fatal(err)
-			}
+		if chosenDowngrade == "" {
+			log.Fatal(i18n.G("unknown deployed version, unable to downgrade"))
 		}
 
-		abraShPath := fmt.Sprintf("%s/%s/%s", r.Dir, "abra.sh")
-		abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
+		log.Debug(i18n.G("choosing %s as version to rollback", chosenDowngrade))
+
+		if _, err := app.Recipe.EnsureVersion(chosenDowngrade); err != nil {
+			log.Fatal(err)
+		}
+
+		if err := deploy.MergeAbraShEnv(app.Recipe, app.Env); err != nil {
+			log.Fatal(err)
+		}
+
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 		if err != nil {
-			logrus.Fatal(err)
-		}
-		for k, v := range abraShEnv {
-			app.Env[k] = v
+			log.Fatal(err)
 		}
 
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
-		}
+		stackName := app.StackName()
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
 			Prune:        false,
 			ResolveImage: stack.ResolveImageAlways,
+			Detach:       false,
 		}
-		compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
+
+		compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
+		}
+
+		appPkg.ExposeAllEnv(stackName, compose, app.Env)
+		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
+		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
+		if internal.Chaos {
+			appPkg.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
+		}
+
+		// Gather secrets
+		secretInfo, err := deploy.GatherSecretsForDeploy(cl, app, internal.ShowUnchanged)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// Gather configs
+		configInfo, err := deploy.GatherConfigsForDeploy(cl, app, compose, app.Env, internal.ShowUnchanged)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// Gather images
+		imageInfo, err := deploy.GatherImagesForDeploy(cl, app, compose, internal.ShowUnchanged)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		deployedVersion := deployMeta.Version
+		if deployMeta.IsChaos {
+			deployedVersion = deployMeta.ChaosVersion
 		}
-		config.ExposeAllEnv(stackName, compose, app.Env)
-		config.SetRecipeLabel(compose, stackName, app.Recipe)
-		config.SetChaosLabel(compose, stackName, internal.Chaos)
-		config.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
-		config.SetUpdateLabel(compose, stackName, app.Env)
 
 		// NOTE(d1): no release notes implemeneted for rolling back
-		if err := internal.NewVersionOverview(app, deployedVersion, chosenDowngrade, ""); err != nil {
-			logrus.Fatal(err)
+		if err := internal.DeployOverview(
+			app,
+			deployedVersion,
+			chosenDowngrade,
+			"",
+			downgradeWarnMessages,
+			secretInfo,
+			configInfo,
+			imageInfo,
+		); err != nil {
+			log.Fatal(err)
 		}
 
-		if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
-			logrus.Fatal(err)
+		stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
+		if err != nil {
+			log.Fatal(err)
 		}
 
-		return nil
+		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)
+		}
+
+		if err := app.WriteRecipeVersion(chosenDowngrade, false); err != nil {
+			log.Fatal(i18n.G("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 := i18n.G("please select a downgrade (version: %s):", deployMeta.Version)
+
+	if deployMeta.IsChaos {
+		chaosVersion := formatter.BoldDirtyDefault(deployMeta.ChaosVersion)
+
+		msg = i18n.G(
+			"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 appPkg.App,
+	deployMeta stack.DeployMeta,
+) error {
+	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+	if err != nil {
+		return errors.New(i18n.G("current deployment '%s' is not a known version for %s", deployMeta.Version, app.Recipe.Name))
+	}
+
+	parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
+	if err != nil {
+		return errors.New(i18n.G("'%s' is not a known version for %s", specificVersion, app.Recipe.Name))
+	}
+
+	if parsedSpecificVersion.IsGreaterThan(parsedDeployedVersion) &&
+		!parsedSpecificVersion.Equals(parsedDeployedVersion) {
+		return errors.New(i18n.G("%s is not a downgrade for %s?", deployMeta.Version, specificVersion))
+	}
+
+	if parsedSpecificVersion.Equals(parsedDeployedVersion) && !internal.Force {
+		return errors.New(i18n.G("%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,
+		i18n.G("force"),
+		i18n.G("f"),
+		false,
+		i18n.G("perform action without further prompt"),
+	)
+
+	AppRollbackCommand.Flags().BoolVarP(
+		&internal.NoDomainChecks,
+		i18n.G("no-domain-checks"),
+		i18n.G("D"),
+		false,
+		i18n.G("disable public DNS checks"),
+	)
+
+	AppRollbackCommand.Flags().BoolVarP(
+		&internal.DontWaitConverge,
+		i18n.G("no-converge-checks"),
+		i18n.G("c"),
+		false,
+		i18n.G("disable converge logic checks"),
+	)
+
+	AppRollbackCommand.Flags().BoolVarP(
+		&internal.ShowUnchanged,
+		i18n.G("show-unchanged"),
+		i18n.G("U"),
+		false,
+		i18n.G("show all configs & images, including unchanged ones"),
+	)
+}

cli/app/run.go

@@ -2,99 +2,121 @@ package app
 
 import (
 	"context"
-	"errors"
 	"fmt"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	containerPkg "coopcloud.tech/abra/pkg/container"
+	"coopcloud.tech/abra/pkg/i18n"
+	"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/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var user string
-var userFlag = &cli.StringFlag{
-	Name:        "user, u",
-	Value:       "",
-	Destination: &user,
-}
+// translators: `abra app run` aliases. use a comma separated list of aliases
+// with no spaces in between
+var appRunAliases = i18n.G("r")
 
-var noTTY bool
-var noTTYFlag = &cli.BoolFlag{
-	Name:        "no-tty, t",
-	Destination: &noTTY,
-}
+var AppRunCommand = &cobra.Command{
+	// translators: `app run` command
+	Use:     i18n.G("run <domain> <service> <cmd> [[args] [flags] | [flags] -- [args]]"),
+	Aliases: strings.Split(appRunAliases, ","),
+	// translators: Short description for `app run` command
+	Short: i18n.G("Run a command inside a service container"),
+	Example: i18n.G(`  # run <cmd> with args/flags
+  abra app run 1312.net app -- ls -lha
 
-var appRunCommand = cli.Command{
-	Name:    "run",
-	Aliases: []string{"r"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		noTTYFlag,
-		userFlag,
+  # 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,
-	ArgsUsage:    "<domain> <service> <args>...",
-	Usage:        "Run a command in a service container",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		if len(c.Args()) < 2 {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no <service> provided?"))
-		}
-
-		if len(c.Args()) < 3 {
-			internal.ShowSubcommandHelpAndError(c, 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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		serviceName := c.Args().Get(1)
+		serviceName := args[1]
 		stackAndServiceName := fmt.Sprintf("^%s_%s", app.StackName(), serviceName)
+
 		filters := filters.NewArgs()
 		filters.Add("name", stackAndServiceName)
 
 		targetContainer, err := containerPkg.GetContainer(context.Background(), cl, filters, false)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		cmd := c.Args()[2:]
-		execCreateOpts := types.ExecConfig{
+		userCmd := args[2:]
+		execCreateOpts := containertypes.ExecOptions{
 			AttachStderr: true,
 			AttachStdin:  true,
 			AttachStdout: true,
-			Cmd:          cmd,
+			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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-
-		return nil
 	},
 }
+
+var (
+	noTTY     bool
+	runAsUser string
+)
+
+func init() {
+	AppRunCommand.Flags().BoolVarP(&noTTY,
+		i18n.G("no-tty"),
+		i18n.G("t"),
+		false,
+		i18n.G("do not request a TTY"),
+	)
+
+	AppRunCommand.Flags().StringVarP(
+		&runAsUser,
+		i18n.G("user"),
+		i18n.G("u"),
+		"",
+		i18n.G("run command as user"),
+	)
+}

cli/app/secret.go

@@ -4,110 +4,86 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"os"
+	"sort"
 	"strconv"
 	"strings"
 
 	"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/config"
 	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/secret"
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/docker/api/types"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var (
-	allSecrets     bool
-	allSecretsFlag = &cli.BoolFlag{
-		Name:        "all, a",
-		Destination: &allSecrets,
-		Usage:       "Generate all secrets",
-	}
-)
+// translators: `abra app secret generate` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appSecretGenerateAliases = i18n.G("g")
 
-var (
-	rmAllSecrets     bool
-	rmAllSecretsFlag = &cli.BoolFlag{
-		Name:        "all, a",
-		Destination: &rmAllSecrets,
-		Usage:       "Remove all secrets",
-	}
-)
-
-var appSecretGenerateCommand = cli.Command{
-	Name:      "generate",
-	Aliases:   []string{"g"},
-	Usage:     "Generate secrets",
-	ArgsUsage: "<domain> <secret> <version>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		allSecretsFlag,
-		internal.PassFlag,
-		internal.MachineReadableFlag,
-		internal.OfflineFlag,
-		internal.ChaosFlag,
+var AppSecretGenerateCommand = &cobra.Command{
+	// translators: `app secret generate` command
+	Use:     i18n.G("generate <domain> [[secret] [version] | --all] [flags]"),
+	Aliases: strings.Split(appSecretGenerateAliases, ","),
+	// translators: Short description for `app secret generate` command
+	Short: i18n.G("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 {
+				return []string{i18n.G("autocomplete failed: %s", err)}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.SecretComplete(app.Recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		r, err := recipe.Get(app.Recipe)
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
+		}
+
+		if len(args) <= 2 && !generateAllSecrets {
+			log.Fatal(i18n.G("missing arguments [secret]/[version] or '--all'"))
+		}
+
+		if len(args) > 2 && generateAllSecrets {
+			log.Fatal(i18n.G("cannot use '[secret] [version]' and '--all' together"))
+		}
+
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if len(c.Args()) == 1 && !allSecrets {
-			err := errors.New("missing arguments <secret>/<version> or '--all'")
-			internal.ShowSubcommandHelpAndError(c, err)
-		}
-
-		if c.Args().Get(1) != "" && allSecrets {
-			err := errors.New("cannot use '<secret> <version>' and '--all' together")
-			internal.ShowSubcommandHelpAndError(c, err)
-		}
-
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secrets, err := secret.ReadSecretsConfig(app.Path, composeFiles, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !allSecrets {
-			secretName := c.Args().Get(1)
-			secretVersion := c.Args().Get(2)
+		if !generateAllSecrets {
+			secretName := args[1]
+			secretVersion := args[2]
 			s, ok := secrets[secretName]
 			if !ok {
-				logrus.Fatalf("%s doesn't exist in the env config?", secretName)
+				log.Fatal(i18n.G("%s doesn't exist in the env config?", secretName))
 			}
 			s.Version = secretVersion
 			secrets = map[string]secret.Secret{
@@ -117,214 +93,317 @@ var appSecretGenerateCommand = cli.Command{
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secretVals, err := secret.GenerateSecrets(cl, secrets, app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			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 {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			}
 		}
 
 		if len(secretVals) == 0 {
-			logrus.Warn("no secrets generated")
+			log.Warn(i18n.G("no secrets generated"))
 			os.Exit(1)
 		}
 
-		tableCol := []string{"name", "value"}
-		table := formatter.CreateTable(tableCol)
+		headers := []string{i18n.G("NAME"), i18n.G("VALUE")}
+		table, err := formatter.CreateTable()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		table.Headers(headers...)
+
+		var rows [][]string
 		for name, val := range secretVals {
-			table.Append([]string{name, val})
+			row := []string{name, val}
+			rows = append(rows, row)
+			table.Row(row...)
 		}
 
 		if internal.MachineReadable {
-			table.JSONRender()
-		} else {
-			table.Render()
+			out, err := formatter.ToJSON(headers, rows)
+			if err != nil {
+				log.Fatal(i18n.G("unable to render to JSON: %s", err))
+			}
+			fmt.Println(out)
+			return
 		}
-		logrus.Warn("generated secrets are not shown again, please take note of them NOW")
 
-		return nil
+		if err := formatter.PrintTable(table); err != nil {
+			log.Fatal(err)
+		}
+
+		log.Warn(i18n.G(
+			"generated secrets %s shown again, please take note of them %s",
+			formatter.BoldStyle.Render(i18n.G("NOT")),
+			formatter.BoldStyle.Render(i18n.G("NOW")),
+		))
 	},
 }
 
-var appSecretInsertCommand = cli.Command{
-	Name:    "insert",
-	Aliases: []string{"i"},
-	Usage:   "Insert secret",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.PassFlag,
-		internal.FileFlag,
-		internal.TrimFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	ArgsUsage:    "<domain> <secret-name> <version> <data>",
-	BashComplete: autocomplete.AppNameComplete,
-	Description: `
-This command inserts a secret into an app environment.
+// translators: `abra app secret insert` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appSecretInsertAliases = i18n.G("i")
 
-This can be useful when you want to manually generate secrets for an app
+var AppSecretInsertCommand = &cobra.Command{
+	// translators: `app secret insert` command
+	Use:     i18n.G("insert <domain> <secret> <version> [<data>] [flags]"),
+	Aliases: strings.Split(appSecretInsertAliases, ","),
+	// translators: Short description for `app secret insert` command
+	Short: i18n.G("Insert secret"),
+	Long: i18n.G(`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 command 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).
+(see "abra app new --secrets/-S" for more).`),
+	Example: i18n.G(`  # insert regular secret
+  abra app secret insert 1312.net my_secret v1 mySuperSecret
 
-Example:
+  # insert secret as file
+  abra app secret insert 1312.net my_secret v1 secret.txt -f
 
-    abra app secret insert myapp db_pass v1 mySecretPassword
+  # insert secret from stdin
+  echo "mmySuperSecret" | abra app secret insert 1312.net my_secret v1`),
+	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:
+			app, err := appPkg.Get(args[0])
+			if err != nil {
+				return []string{i18n.G("autocomplete failed: %s", err)}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.SecretComplete(app.Recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveDefault
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-`,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		if len(c.Args()) != 4 {
-			internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments?"))
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		name := c.Args().Get(1)
-		version := c.Args().Get(2)
-		data := c.Args().Get(3)
+		name := args[1]
+		version := args[2]
+		data, err := readSecretData(args)
+		if err != nil {
+			log.Fatal(err)
+		}
 
-		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.Fatal(i18n.G("no secret %s available for recipe %s?", name, app.Recipe.Name))
+		}
+
+		if insertFromFile {
 			raw, err := os.ReadFile(data)
 			if err != nil {
-				logrus.Fatalf("reading secret from file: %s", err)
+				log.Fatal(i18n.G("reading secret from file: %s", err))
 			}
 			data = string(raw)
 		}
 
-		if internal.Trim {
+		if trimInput {
 			data = strings.TrimSpace(data)
 		}
 
 		secretName := fmt.Sprintf("%s_%s_%s", app.StackName(), name, version)
-		if err := client.StoreSecret(cl, secretName, data, app.Server); err != nil {
-			logrus.Fatal(err)
+		if err := client.StoreSecret(cl, secretName, data); err != nil {
+			log.Fatal(err)
 		}
 
-		logrus.Infof("%s successfully stored on server", secretName)
+		log.Info(i18n.G("%s successfully stored on server", secretName))
 
-		if internal.Pass {
+		if storeInPass {
 			if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
-
-		return nil
 	},
 }
 
+func readSecretData(args []string) (string, error) {
+	if len(args) == 4 {
+		return args[3], nil
+	}
+
+	if len(args) != 3 {
+		return "", errors.New(i18n.G("need 3 or 4 arguments"))
+	}
+	// First check if data is provided by stdin
+	fi, err := os.Stdin.Stat()
+	if err != nil {
+		return "", err
+	}
+	if fi.Mode()&os.ModeNamedPipe != 0 {
+		// Can't insert from stdin and read from file
+		if insertFromFile {
+			return "", errors.New(i18n.G("can not insert from file and read from stdin"))
+		}
+
+		log.Debug(i18n.G("reading secret data from stdin"))
+		bytes, err := io.ReadAll(os.Stdin)
+		if err != nil {
+			return "", errors.New(i18n.G("reading data from stdin: %s", err))
+		}
+
+		return string(bytes), nil
+	}
+	if internal.NoInput {
+		return "", errors.New(i18n.G("must provide <data> argument if --no-input is passed"))
+	}
+
+	log.Debug(i18n.G("secret data not provided on command-line or stdin, prompting"))
+	var prompt survey.Prompt
+	if !insertFromFile {
+		prompt = &survey.Password{
+			Message: i18n.G("specify secret value"),
+		}
+	} else {
+		prompt = &survey.Input{
+			Message: i18n.G("specify secret file"),
+		}
+	}
+	var data string
+	if err := survey.AskOne(prompt, &data); err != nil {
+		return "", err
+	}
+	return data, nil
+}
+
 // secretRm removes a secret.
-func secretRm(cl *dockerClient.Client, app config.App, secretName, parsed string) error {
+func secretRm(cl *dockerClient.Client, app appPkg.App, secretName, parsed string) error {
 	if err := cl.SecretRemove(context.Background(), secretName); err != nil {
 		return err
 	}
 
-	logrus.Infof("deleted %s successfully from server", secretName)
+	log.Info(i18n.G("deleted %s successfully from server", secretName))
 
-	if internal.PassRemove {
+	if removeFromPass {
 		if err := secret.PassRmSecret(parsed, app.StackName(), app.Server); err != nil {
 			return err
 		}
 
-		logrus.Infof("deleted %s successfully from local pass store", secretName)
+		log.Info(i18n.G("deleted %s successfully from local pass store", secretName))
 	}
 
 	return nil
 }
 
-var appSecretRmCommand = cli.Command{
-	Name:    "remove",
-	Aliases: []string{"rm"},
-	Usage:   "Remove a secret",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		rmAllSecretsFlag,
-		internal.PassRemoveFlag,
-		internal.OfflineFlag,
-		internal.ChaosFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	ArgsUsage:    "<domain> [<secret-name>]",
-	BashComplete: autocomplete.AppNameComplete,
-	Description: `
-This command removes app secrets.
+// translators: `abra app secret remove` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appSecretRemoveAliases = i18n.G("rm")
 
-Example:
+var AppSecretRmCommand = &cobra.Command{
+	// translators: `app secret remove` command
+	Use:     i18n.G("remove <domain> [[secret] | --all] [flags]"),
+	Aliases: strings.Split(appSecretRemoveAliases, ","),
+	// translators: Short description for `app secret remove` command
+	Short: i18n.G("Remove a secret"),
+	Long: i18n.G(`This command removes a secret from an app environment.
 
-    abra app secret remove myapp db_pass
-`,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
+Arbitrary secret removal is not supported. Secrets that are removed must
+match those configured in the recipe beforehand.`),
+	Example: i18n.G("  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 {
+					return []string{i18n.G("autocomplete failed: %s", err)}, cobra.ShellCompDirectiveError
 				}
+				return autocomplete.SecretComplete(app.Recipe.Name)
 			}
+			return nil, cobra.ShellCompDirectiveDefault
+		default:
+			return nil, cobra.ShellCompDirectiveError
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secrets, err := secret.ReadSecretsConfig(app.Path, composeFiles, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if c.Args().Get(1) != "" && rmAllSecrets {
-			internal.ShowSubcommandHelpAndError(c, errors.New("cannot use '<secret-name>' and '--all' together"))
+		if len(args) == 2 && rmAllSecrets {
+			log.Fatal(i18n.G("cannot use [secret] and --all/-a together"))
 		}
 
-		if c.Args().Get(1) == "" && !rmAllSecrets {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no secret(s) specified?"))
+		if len(args) != 2 && !rmAllSecrets {
+			log.Fatal(i18n.G("no secret(s) specified?"))
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		filters, err := app.Filters(false, false)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: filters})
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		remoteSecretNames := make(map[string]bool)
@@ -332,127 +411,243 @@ Example:
 			remoteSecretNames[cont.Spec.Annotations.Name] = true
 		}
 
+		var secretToRm string
+		if len(args) == 2 {
+			secretToRm = args[1]
+		}
+
 		match := false
-		secretToRm := c.Args().Get(1)
 		for secretName, val := range secrets {
 			secretRemoteName := fmt.Sprintf("%s_%s_%s", app.StackName(), secretName, val.Version)
 			if _, ok := remoteSecretNames[secretRemoteName]; ok {
 				if secretToRm != "" {
 					if secretName == secretToRm {
 						if err := secretRm(cl, app, secretRemoteName, secretName); err != nil {
-							logrus.Fatal(err)
+							log.Fatal(err)
 						}
 
-						return nil
+						return
 					}
 				} else {
 					match = true
 
 					if err := secretRm(cl, app, secretRemoteName, secretName); err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 				}
 			}
 		}
 
 		if !match && secretToRm != "" {
-			logrus.Fatalf("%s doesn't exist on server?", secretToRm)
+			log.Fatal(i18n.G("%s doesn't exist on server?", secretToRm))
 		}
 
 		if !match {
-			logrus.Fatal("no secrets to remove?")
+			log.Fatal(i18n.G("no secrets to remove?"))
 		}
-
-		return nil
 	},
 }
 
-var appSecretLsCommand = cli.Command{
-	Name:    "list",
-	Aliases: []string{"ls"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
-		internal.ChaosFlag,
-		internal.MachineReadableFlag,
+// translators: `abra app secret ls` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appSecretLsAliases = i18n.G("ls")
+
+var AppSecretLsCommand = &cobra.Command{
+	// translators: `app secret list` command
+	Use:     i18n.G("list <domain>"),
+	Aliases: strings.Split(appSecretLsAliases, ","),
+	// translators: Short description for `app secret list` command
+	Short: i18n.G("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",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
+		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		tableCol := []string{"Name", "Version", "Generated Name", "Created On Server"}
-		table := formatter.CreateTable(tableCol)
+		headers := []string{i18n.G("NAME"), i18n.G("VERSION"), i18n.G("GENERATED NAME"), i18n.G("CREATED ON SERVER")}
+		table, err := formatter.CreateTable()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		table.Headers(headers...)
 
 		secStats, err := secret.PollSecretsStatus(cl, app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
+		// Sort secrets to ensure reproducible output
+		sort.Slice(secStats, func(i, j int) bool {
+			return secStats[i].LocalName < secStats[j].LocalName
+		})
+		var rows [][]string
 		for _, secStat := range secStats {
-			tableRow := []string{
+			row := []string{
 				secStat.LocalName,
 				secStat.Version,
 				secStat.RemoteName,
 				strconv.FormatBool(secStat.CreatedOnRemote),
 			}
-			table.Append(tableRow)
+
+			rows = append(rows, row)
+			table.Row(row...)
 		}
 
-		if table.NumLines() > 0 {
+		if len(rows) > 0 {
 			if internal.MachineReadable {
-				table.JSONRender()
-			} else {
-				table.Render()
+				out, err := formatter.ToJSON(headers, rows)
+				if err != nil {
+					log.Fatal(i18n.G("unable to render to JSON: %s", err))
+				}
+				fmt.Println(out)
+				return
 			}
-		} else {
-			logrus.Warnf("no secrets stored for %s", app.Name)
+
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
+			}
+
+			return
 		}
 
-		return nil
+		log.Warn(i18n.G("no secrets stored for %s", app.Name))
 	},
 }
 
-var appSecretCommand = cli.Command{
-	Name:      "secret",
-	Aliases:   []string{"s"},
-	Usage:     "Manage app secrets",
-	ArgsUsage: "<domain>",
-	Subcommands: []cli.Command{
-		appSecretGenerateCommand,
-		appSecretInsertCommand,
-		appSecretRmCommand,
-		appSecretLsCommand,
-	},
+var AppSecretCommand = &cobra.Command{
+	// translators: `app secret` command group
+	Use:     i18n.G("secret [cmd] [args] [flags]"),
+	Aliases: []string{i18n.G("s")},
+	// translators: Short description for `app secret` command group
+	Short: i18n.G("Manage app secrets"),
+}
+
+var (
+	storeInPass        bool
+	insertFromFile     bool
+	trimInput          bool
+	rmAllSecrets       bool
+	generateAllSecrets bool
+	removeFromPass     bool
+)
+
+func init() {
+	AppSecretGenerateCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		i18n.G("machine"),
+		i18n.G("m"),
+		false,
+		i18n.G("print machine-readable output"),
+	)
+
+	AppSecretGenerateCommand.Flags().BoolVarP(
+		&storeInPass,
+		i18n.G("pass"),
+		i18n.G("p"),
+		false,
+		i18n.G("store generated secrets in a local pass store"),
+	)
+
+	AppSecretGenerateCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+
+	AppSecretGenerateCommand.Flags().BoolVarP(
+		&generateAllSecrets,
+		i18n.G("all"),
+		i18n.GC("a", "app secret generate"),
+		false,
+		i18n.G("generate all secrets"),
+	)
+
+	AppSecretInsertCommand.Flags().BoolVarP(
+		&storeInPass,
+		i18n.G("pass"),
+		i18n.G("p"),
+		false,
+		i18n.G("store generated secrets in a local pass store"),
+	)
+
+	AppSecretInsertCommand.Flags().BoolVarP(
+		&insertFromFile,
+		i18n.G("file"),
+		i18n.G("f"),
+		false,
+		i18n.G("treat input as a file"),
+	)
+
+	AppSecretInsertCommand.Flags().BoolVarP(
+		&trimInput,
+		i18n.G("trim"),
+		i18n.G("t"),
+		false,
+		i18n.G("trim input"),
+	)
+
+	AppSecretInsertCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+
+	AppSecretRmCommand.Flags().BoolVarP(
+		&rmAllSecrets,
+		i18n.G("all"),
+		i18n.GC("a", "app secret rm"),
+		false,
+		i18n.G("remove all secrets"),
+	)
+
+	AppSecretRmCommand.Flags().BoolVarP(
+		&removeFromPass,
+		i18n.G("pass"),
+		i18n.G("p"),
+		false,
+		i18n.G("remove generated secrets from a local pass store"),
+	)
+
+	AppSecretRmCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+
+	AppSecretLsCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+
+	AppSecretLsCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		i18n.G("machine"),
+		i18n.G("m"),
+		false,
+		i18n.G("print machine-readable output"),
+	)
 }

cli/app/services.go

@@ -9,53 +9,71 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	containerTypes "github.com/docker/docker/api/types/container"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var appServicesCommand = cli.Command{
-	Name:      "services",
-	Aliases:   []string{"sr"},
-	Usage:     "Display all services of an app",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
+// translators: `abra app services` aliases. use a comma separated list of
+// aliases with no spaces in between
+var appServicesAliases = i18n.G("sr")
+
+var AppServicesCommand = &cobra.Command{
+	// translators: `app services` command
+	Use:     i18n.G("services <domain> [flags]"),
+	Aliases: strings.Split(appServicesAliases, ","),
+	// translators: Short description for `app services` command
+	Short: i18n.G("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()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+		if !deployMeta.IsDeployed {
+			log.Fatal(i18n.G("%s is not deployed?", app.Name))
 		}
 
 		filters, err := app.Filters(true, true)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		containers, err := cl.ContainerList(context.Background(), containerTypes.ListOptions{Filters: filters})
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		tableCol := []string{"service name", "image"}
-		table := formatter.CreateTable(tableCol)
+		table, err := formatter.CreateTable()
+		if err != nil {
+			log.Fatal(err)
+		}
 
+		headers := []string{i18n.G("SERVICE (SHORT)"), i18n.G("SERVICE (LONG)")}
+		table.Headers(headers...)
+
+		var rows [][]string
 		for _, container := range containers {
 			var containerNames []string
 			for _, containerName := range container.Names {
@@ -66,15 +84,20 @@ var appServicesCommand = cli.Command{
 			serviceShortName := service.ContainerToServiceName(container.Names, app.StackName())
 			serviceLongName := fmt.Sprintf("%s_%s", app.StackName(), serviceShortName)
 
-			tableRow := []string{
+			row := []string{
+				serviceShortName,
 				serviceLongName,
-				formatter.RemoveSha(container.Image),
 			}
-			table.Append(tableRow)
+
+			rows = append(rows, row)
 		}
 
-		table.Render()
+		table.Rows(rows...)
 
-		return nil
+		if len(rows) > 0 {
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
+			}
+		}
 	},
 }

cli/app/undeploy.go

@@ -3,52 +3,131 @@ package app
 import (
 	"context"
 	"fmt"
-	"time"
+	"strings"
 
 	"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/config"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var prune bool
+// translators: `abra app undeploy` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appUndeployAliases = i18n.G("un")
 
-var pruneFlag = &cli.BoolFlag{
-	Name:        "prune, p",
-	Destination: &prune,
-	Usage:       "Prunes unused containers, networks, and dangling images for an app",
+var AppUndeployCommand = &cobra.Command{
+	// translators: `app undeploy` command
+	Use: i18n.G("undeploy <domain> [flags]"),
+	// translators: Short description for `app undeploy` command
+	Aliases: strings.Split(appUndeployAliases, ","),
+	Long: i18n.G(`This does not destroy any application data.
+
+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.Debug(i18n.G("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.Fatal(i18n.G("%s is not deployed?", app.Name))
+		}
+
+		version := deployMeta.Version
+		if deployMeta.IsChaos {
+			version = deployMeta.ChaosVersion
+		}
+
+		if err := internal.DeployOverview(
+			app,
+			version,
+			config.MISSING_DEFAULT,
+			"",
+			nil,
+			nil,
+			nil,
+			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)
+		}
+
+		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(i18n.G("undeploy succeeded 🟢"))
+
+		if err := app.WriteRecipeVersion(version, false); err != nil {
+			log.Fatal(i18n.G("writing recipe version failed: %s", err))
+		}
+	},
 }
 
 // pruneApp runs the equivalent of a "docker system prune" but only filtering
 // against resources connected with the app deployment. It is not a system wide
 // prune. Volumes are not pruned to avoid unwated data loss.
-func pruneApp(c *cli.Context, cl *dockerClient.Client, app config.App) error {
+func pruneApp(cl *dockerClient.Client, app appPkg.App) error {
 	stackName := app.StackName()
 	ctx := context.Background()
 
-	for {
-		logrus.Debugf("polling for %s stack, waiting to be undeployed...", stackName)
-
-		services, err := stack.GetStackServices(ctx, cl, stackName)
-		if err != nil {
-			return err
-		}
-
-		if len(services) == 0 {
-			logrus.Debugf("%s undeployed, moving on with pruning logic", stackName)
-			time.Sleep(time.Second) // give runtime more time to tear down related state
-			break
-		}
-
-		time.Sleep(time.Second)
-	}
-
 	pruneFilters := filters.NewArgs()
 	stackSearch := fmt.Sprintf("%s*", stackName)
 	pruneFilters.Add("label", stackSearch)
@@ -58,14 +137,14 @@ func pruneApp(c *cli.Context, cl *dockerClient.Client, app config.App) error {
 	}
 
 	cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
-	logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
+	log.Info(i18n.G("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed))
 
 	nr, err := cl.NetworksPrune(ctx, pruneFilters)
 	if err != nil {
 		return err
 	}
 
-	logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted))
+	log.Info(i18n.G("networks pruned: %d", len(nr.NetworksDeleted)))
 
 	ir, err := cl.ImagesPrune(ctx, pruneFilters)
 	if err != nil {
@@ -73,66 +152,21 @@ func pruneApp(c *cli.Context, cl *dockerClient.Client, app config.App) error {
 	}
 
 	imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed)
-	logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
+	log.Info(i18n.G("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed))
 
 	return nil
 }
 
-var appUndeployCommand = cli.Command{
-	Name:      "undeploy",
-	Aliases:   []string{"un"},
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		pruneFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	Usage:        "Undeploy an app",
-	BashComplete: autocomplete.AppNameComplete,
-	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(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-		stackName := app.StackName()
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
-
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		if err := internal.DeployOverview(app, deployedVersion, "continue with undeploy?"); err != nil {
-			logrus.Fatal(err)
-		}
-
-		rmOpts := stack.Remove{Namespaces: []string{app.StackName()}}
-		if err := stack.RunRemove(context.Background(), cl, rmOpts); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if prune {
-			if err := pruneApp(c, cl, app); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		return nil
-	},
+func init() {
+	AppUndeployCommand.Flags().BoolVarP(
+		&prune,
+		i18n.G("prune"),
+		i18n.G("p"),
+		false,
+		i18n.G("prune unused containers, networks, and dangling images"),
+	)
 }

cli/app/upgrade.go

@@ -2,307 +2,494 @@ package app
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"strings"
 
 	"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/config"
+	"coopcloud.tech/abra/pkg/deploy"
+	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
 	"coopcloud.tech/abra/pkg/lint"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	dockerClient "github.com/docker/docker/client"
+	"github.com/spf13/cobra"
 )
 
-var appUpgradeCommand = cli.Command{
-	Name:      "upgrade",
-	Aliases:   []string{"up"},
-	Usage:     "Upgrade an app",
-	ArgsUsage: "<domain> [<version>]",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.ForceFlag,
-		internal.ChaosFlag,
-		internal.NoDomainChecksFlag,
-		internal.DontWaitConvergeFlag,
-		internal.OfflineFlag,
-		internal.ReleaseNotesFlag,
+// translators: `abra app upgrade` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appUpgradeAliases = i18n.G("up")
+
+var AppUpgradeCommand = &cobra.Command{
+	// translators: `app upgrade` command
+	Use:     i18n.G("upgrade <domain> [version] [flags]"),
+	Aliases: strings.Split(appUpgradeAliases, ","),
+	// translators: Short description for `app upgrade` command
+	Short: i18n.G("Upgrade an app"),
+	Long: i18n.G(`Upgrade an app.
+
+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. 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 {
+				return []string{i18n.G("autocomplete failed: %s", err)}, cobra.ShellCompDirectiveError
+			}
+			return autocomplete.RecipeVersionComplete(app.Recipe.Name)
+		default:
+			return nil, cobra.ShellCompDirectiveError
+		}
 	},
-	Before: internal.SubCommandBefore,
-	Description: `
-Upgrade an app. You can use it to choose and roll out a new upgrade to an
-existing app.
+	Run: func(cmd *cobra.Command, args []string) {
+		var (
+			upgradeWarnMessages []string
+			chosenUpgrade       string
+			availableUpgrades   []string
+			upgradeReleaseNotes string
+		)
 
-This command specifically supports incrementing the version of running apps, as
-opposed to "abra app deploy <domain>" which will not change the version of a
-deployed app.
+		app := internal.ValidateApp(args)
 
-You may pass "--force/-f" to upgrade to the same version again. This can be
-useful if the container runtime has gotten into a weird state.
-
-This action could be destructive, please ensure you have a copy of your app
-data beforehand.
-
-Chaos mode ("--chaos") will deploy your local checkout of a recipe as-is,
-including unstaged changes and can be useful for live hacking and testing new
-recipes.
-`,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-		stackName := app.StackName()
-
-		specificVersion := c.Args().Get(1)
-		if specificVersion != "" && internal.Chaos {
-			logrus.Fatal("cannot use <version> and --chaos together")
+		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)
 		}
 
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if err := r.LoadConfig(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := lint.LintForErrors(r); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
-
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := ensureDeployed(cl, app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+		if err := lint.LintForErrors(app.Recipe); err != nil {
+			log.Fatal(err)
 		}
 
-		catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline)
+		versions, err := app.Recipe.Tags()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		versions, err := recipePkg.GetRecipeCatalogueVersions(app.Recipe, catl)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if len(versions) == 0 && !internal.Chaos {
-			logrus.Warn("no published versions in catalogue, trying local recipe repository")
-			recipeVersions, err := r.GetVersions(internal.Offline)
-			if err != nil {
-				logrus.Warn(err)
-			}
-			for _, recipeVersion := range recipeVersions {
-				for version := range recipeVersion {
-					versions = append(versions, version)
-				}
-			}
-		}
-
-		var availableUpgrades []string
-		if deployedVersion == "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
-			logrus.Warnf("failed to determine deployed version of %s", app.Name)
 		}
 
-		if specificVersion != "" {
-			parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
+		if len(args) == 2 && args[1] != "" {
+			chosenUpgrade = args[1]
+
+			if err := validateUpgradeVersionArg(chosenUpgrade, app, deployMeta); err != nil {
+				log.Fatal(err)
+			}
+
+			availableUpgrades = append(availableUpgrades, chosenUpgrade)
+		}
+
+		if deployMeta.Version != config.UNKNOWN_DEFAULT && chosenUpgrade == "" {
+			upgradeAvailable, err := ensureUpgradesAvailable(app, versions, &availableUpgrades, deployMeta)
 			if err != nil {
-				logrus.Fatal(err)
-			}
-			parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) {
-				logrus.Fatalf("%s is not an upgrade for %s?", deployedVersion, specificVersion)
-			}
-			availableUpgrades = append(availableUpgrades, specificVersion)
-		}
-
-		parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if deployedVersion != "unknown" && !internal.Chaos && specificVersion == "" {
-			for _, version := range versions {
-				parsedVersion, err := tagcmp.Parse(version)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				if parsedVersion.IsGreaterThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
-					availableUpgrades = append(availableUpgrades, version)
-				}
+				log.Fatal(err)
 			}
 
-			if len(availableUpgrades) == 0 && !internal.Force {
-				logrus.Infof("no available upgrades, you're on latest (%s) ✌️", deployedVersion)
-				return nil
+			if !upgradeAvailable {
+				log.Info(i18n.G("no available upgrades"))
+				return
 			}
 		}
 
-		var chosenUpgrade string
-		if len(availableUpgrades) > 0 && !internal.Chaos {
-			if internal.Force || internal.NoInput || specificVersion != "" {
+		if internal.Force || internal.NoInput || chosenUpgrade != "" {
+			if len(availableUpgrades) > 0 {
 				chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
-				logrus.Debugf("choosing %s as version to upgrade to", chosenUpgrade)
-			} else {
-				prompt := &survey.Select{
-					Message: fmt.Sprintf("Please select an upgrade (current version: %s):", deployedVersion),
-					Options: internal.ReverseStringList(availableUpgrades),
-				}
-				if err := survey.AskOne(prompt, &chosenUpgrade); err != nil {
-					return err
-				}
+			}
+		} else {
+			if err := chooseUpgrade(availableUpgrades, deployMeta, &chosenUpgrade); err != nil {
+				log.Fatal(err)
 			}
 		}
 
-		if internal.Force && chosenUpgrade == "" {
-			logrus.Warnf("%s is already upgraded to latest but continuing (--force/--chaos)", app.Name)
-			chosenUpgrade = deployedVersion
+		if internal.Force &&
+			chosenUpgrade == "" &&
+			deployMeta.Version != config.UNKNOWN_DEFAULT {
+			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 err != nil {
-				logrus.Fatal(err)
-			}
-			for _, version := range versions {
-				parsedVersion, err := tagcmp.Parse(version)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				if parsedVersion.IsGreaterThan(parsedDeployedVersion) && parsedVersion.IsLessThan(parsedChosenUpgrade) {
-					note, err := internal.GetReleaseNotes(app.Recipe, version)
-					if err != nil {
-						return err
-					}
-					if note != "" {
-						releaseNotes += fmt.Sprintf("%s\n", note)
-					}
-				}
-			}
+		if chosenUpgrade == "" {
+			log.Fatal(i18n.G("unknown deployed version, unable to upgrade"))
 		}
 
-		if !internal.Chaos {
-			if err := r.EnsureVersion(chosenUpgrade); err != nil {
-				logrus.Fatal(err)
-			}
+		log.Debug(i18n.G("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 internal.Chaos {
-			logrus.Warn("chaos mode engaged")
-			var err error
-			chosenUpgrade, err = r.ChaosVersion()
-			if err != nil {
-				logrus.Fatal(err)
-			}
+		if _, err := app.Recipe.EnsureVersion(chosenUpgrade); err != nil {
+			log.Fatal(err)
 		}
 
-		abraShPath := fmt.Sprintf("%s/%s/%s", r.Dir, "abra.sh")
-		abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
+		if err := deploy.MergeAbraShEnv(app.Recipe, app.Env); err != nil {
+			log.Fatal(err)
+		}
+
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 		if err != nil {
-			logrus.Fatal(err)
-		}
-		for k, v := range abraShEnv {
-			app.Env[k] = v
+			log.Fatal(err)
 		}
 
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
-		}
+		stackName := app.StackName()
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
 			Prune:        false,
 			ResolveImage: stack.ResolveImageAlways,
+			Detach:       false,
 		}
-		compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		config.ExposeAllEnv(stackName, compose, app.Env)
-		config.SetRecipeLabel(compose, stackName, app.Recipe)
-		config.SetChaosLabel(compose, stackName, internal.Chaos)
-		config.SetChaosVersionLabel(compose, stackName, chosenUpgrade)
-		config.SetUpdateLabel(compose, stackName, app.Env)
 
-		envVars, err := config.CheckEnv(app)
+		compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
+		}
+
+		appPkg.ExposeAllEnv(stackName, compose, app.Env)
+		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
+		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
+		if internal.Chaos {
+			appPkg.SetChaosVersionLabel(compose, stackName, chosenUpgrade)
+		}
+
+		envVars, err := appPkg.CheckEnv(app)
+		if err != nil {
+			log.Fatal(err)
 		}
 
 		for _, envVar := range envVars {
 			if !envVar.Present {
-				logrus.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain)
+				upgradeWarnMessages = append(upgradeWarnMessages,
+					i18n.G("%s missing from %s.env", envVar.Name, app.Domain),
+				)
 			}
 		}
 
-		if internal.ReleaseNotes {
-			fmt.Println()
-			fmt.Print(releaseNotes)
-			return nil
-		}
-
-		if err := internal.NewVersionOverview(app, deployedVersion, chosenUpgrade, releaseNotes); err != nil {
-			logrus.Fatal(err)
-		}
-
-		stack.WaitTimeout, err = config.GetTimeoutFromLabel(compose, stackName)
+		// Gather secrets
+		secretInfo, err := deploy.GatherSecretsForDeploy(cl, app, internal.ShowUnchanged)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-		logrus.Debugf("set waiting timeout to %d s", stack.WaitTimeout)
 
-		if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
-			logrus.Fatal(err)
+		// Gather configs
+		configInfo, err := deploy.GatherConfigsForDeploy(cl, app, compose, app.Env, internal.ShowUnchanged)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// Gather images
+		imageInfo, err := deploy.GatherImagesForDeploy(cl, app, compose, internal.ShowUnchanged)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if showReleaseNotes {
+			fmt.Print(upgradeReleaseNotes)
+			return
+		}
+
+		if upgradeReleaseNotes == "" {
+			upgradeWarnMessages = append(
+				upgradeWarnMessages,
+				fmt.Sprintf("no release notes available for %s", chosenUpgrade),
+			)
+		}
+
+		deployedVersion := deployMeta.Version
+		if deployMeta.IsChaos {
+			deployedVersion = deployMeta.ChaosVersion
+		}
+
+		if err := internal.DeployOverview(
+			app,
+			deployedVersion,
+			chosenUpgrade,
+			upgradeReleaseNotes,
+			upgradeWarnMessages,
+			secretInfo,
+			configInfo,
+			imageInfo,
+		); err != nil {
+			log.Fatal(err)
+		}
+
+		stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		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 {
-			logrus.Debugf("run the following post-deploy commands: %s", postDeployCmds)
+			log.Debug(i18n.G("run the following post-deploy commands: %s", postDeployCmds))
+
 			if err := internal.PostCmds(cl, app, postDeployCmds); err != nil {
-				logrus.Fatalf("attempting to run post deploy commands, saw: %s", err)
+				log.Fatal(i18n.G("attempting to run post deploy commands, saw: %s", err))
 			}
 		}
 
-		return nil
+		if err := app.WriteRecipeVersion(chosenUpgrade, false); err != nil {
+			log.Fatal(i18n.G("writing recipe version failed: %s", err))
+		}
 	},
 }
+
+// chooseUpgrade prompts the user to choose an upgrade interactively.
+func chooseUpgrade(
+	availableUpgrades []string,
+	deployMeta stack.DeployMeta,
+	chosenUpgrade *string,
+) error {
+	msg := i18n.G("please select an upgrade (version: %s):", deployMeta.Version)
+
+	if deployMeta.IsChaos {
+		chaosVersion := formatter.BoldDirtyDefault(deployMeta.ChaosVersion)
+
+		msg = i18n.G(
+			"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 appPkg.App,
+	versions []string,
+	chosenUpgrade string,
+	deployMeta stack.DeployMeta,
+	upgradeReleaseNotes *string,
+) error {
+	parsedChosenUpgrade, err := tagcmp.Parse(chosenUpgrade)
+	if err != nil {
+		return errors.New(i18n.G("parsing chosen upgrade version failed: %s", err))
+	}
+
+	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+	if err != nil {
+		return errors.New(i18n.G("parsing deployment version failed: %s", err))
+	}
+
+	for _, version := range internal.SortVersionsDesc(versions) {
+		parsedVersion, err := tagcmp.Parse(version)
+		if err != nil {
+			return errors.New(i18n.G("parsing recipe version failed: %s", err))
+		}
+
+		if parsedVersion.IsGreaterThan(parsedDeployedVersion) &&
+			parsedVersion.IsLessThan(parsedChosenUpgrade) {
+			note, err := app.Recipe.GetReleaseNotes(version, app.Domain)
+			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 appPkg.App,
+	versions []string,
+	availableUpgrades *[]string,
+	deployMeta stack.DeployMeta,
+) (bool, error) {
+	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+	if err != nil {
+		return false, errors.New(i18n.G("parsing deployed version failed: %s", err))
+	}
+
+	for _, version := range versions {
+		parsedVersion, err := tagcmp.Parse(version)
+		if err != nil {
+			return false, errors.New(i18n.G("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 appPkg.App,
+	deployMeta stack.DeployMeta,
+) error {
+	parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
+	if err != nil {
+		return errors.New(i18n.G("'%s' is not a known version for %s", specificVersion, app.Recipe.Name))
+	}
+
+	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+	if err != nil {
+		return errors.New(i18n.G("'%s' is not a known version", deployMeta.Version))
+	}
+
+	if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) &&
+		!parsedSpecificVersion.Equals(parsedDeployedVersion) {
+		return errors.New(i18n.G("%s is not an upgrade for %s?", deployMeta.Version, specificVersion))
+	}
+
+	if parsedSpecificVersion.Equals(parsedDeployedVersion) && !internal.Force {
+		return errors.New(i18n.G("%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 appPkg.App) (stack.DeployMeta, error) {
+	log.Debug(i18n.G("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{}, errors.New(i18n.G("%s is not deployed?", app.Name))
+	}
+
+	return deployMeta, nil
+}
+
+var showReleaseNotes bool
+
+func init() {
+	AppUpgradeCommand.Flags().BoolVarP(
+		&internal.Force,
+		i18n.G("force"),
+		i18n.G("f"),
+		false,
+		i18n.G("perform action without further prompt"),
+	)
+
+	AppUpgradeCommand.Flags().BoolVarP(
+		&internal.NoDomainChecks,
+		i18n.G("no-domain-checks"),
+		i18n.G("D"),
+		false,
+		i18n.G("disable public DNS checks"),
+	)
+
+	AppUpgradeCommand.Flags().BoolVarP(
+		&internal.DontWaitConverge,
+		i18n.G("no-converge-checks"),
+		i18n.G("c"),
+		false,
+		i18n.G("disable converge logic checks"),
+	)
+
+	AppUpgradeCommand.Flags().BoolVarP(
+		&showReleaseNotes,
+		i18n.G("releasenotes"),
+		i18n.G("r"),
+		false,
+		i18n.G("only show release notes"),
+	)
+
+	AppUpgradeCommand.Flags().BoolVarP(
+		&internal.ShowUnchanged,
+		i18n.G("show-unchanged"),
+		i18n.G("U"),
+		false,
+		i18n.G("show all configs & images, including unchanged ones"),
+	)
+}

cli/app/version.go

@@ -1,122 +0,0 @@
-package app
-
-import (
-	"context"
-	"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/recipe"
-	"coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/distribution/reference"
-	"github.com/olekukonko/tablewriter"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-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]
-	}
-}
-
-// getImagePath returns the image name
-func getImagePath(image string) (string, error) {
-	img, err := reference.ParseNormalizedNamed(image)
-	if err != nil {
-		return "", err
-	}
-
-	path := reference.Path(img)
-
-	path = formatter.StripTagMeta(path)
-
-	logrus.Debugf("parsed %s from %s", path, image)
-
-	return path, nil
-}
-
-var appVersionCommand = cli.Command{
-	Name:      "version",
-	Aliases:   []string{"v"},
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.OfflineFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	Usage:        "Show version info of a deployed app",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-		stackName := app.StackName()
-
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
-
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		if deployedVersion == "unknown" {
-			logrus.Fatalf("failed to determine version of deployed %s", app.Name)
-		}
-
-		recipeMeta, err := r.GetRecipeMeta(internal.Offline)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		versionsMeta := make(map[string]recipe.ServiceMeta)
-		for _, recipeVersion := range recipeMeta.Versions {
-			if currentVersion, exists := recipeVersion[deployedVersion]; exists {
-				versionsMeta = currentVersion
-			}
-		}
-
-		if len(versionsMeta) == 0 {
-			logrus.Fatalf("could not retrieve deployed version (%s) from recipe catalogue?", deployedVersion)
-		}
-
-		tableCol := []string{"version", "service", "image", "tag"}
-		table := formatter.CreateTable(tableCol)
-
-		var versions [][]string
-		for serviceName, versionMeta := range versionsMeta {
-			versions = append(versions, []string{deployedVersion, serviceName, versionMeta.Image, versionMeta.Tag})
-		}
-
-		sort.Slice(versions, sortServiceByName(versions))
-
-		for _, version := range versions {
-			table.Append(version)
-		}
-
-		table.SetAutoMergeCellsByColumnIndex([]int{0})
-		table.SetAlignment(tablewriter.ALIGN_LEFT)
-		table.Render()
-
-		return nil
-	},
-}

cli/app/volume.go

@@ -2,128 +2,183 @@ package app
 
 import (
 	"context"
-	"log"
+	"fmt"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var appVolumeListCommand = cli.Command{
-	Name:      "list",
-	Aliases:   []string{"ls"},
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
+// translators: `abra app volume list` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appVolumeListAliases = i18n.G("ls")
+
+var AppVolumeListCommand = &cobra.Command{
+	// translators: `app volume list` command
+	Use:     i18n.G("list <domain> [flags]"),
+	Aliases: strings.Split(appVolumeListAliases, ","),
+	// translators: Short description for `app list` command
+	Short: i18n.G("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()
 	},
-	Before:       internal.SubCommandBefore,
-	Usage:        "List volumes associated with an app",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		app := internal.ValidateApp(args)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		filters, err := app.Filters(false, true)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, filters)
+		volumes, err := client.GetVolumes(cl, context.Background(), app.Server, filters)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		table := formatter.CreateTable([]string{"name", "created", "mounted"})
-		var volTable [][]string
-		for _, volume := range volumeList {
-			volRow := []string{volume.Name, volume.CreatedAt, volume.Mountpoint}
-			volTable = append(volTable, volRow)
+		headers := []string{i18n.G("NAME"), i18n.G("ON SERVER")}
+
+		table, err := formatter.CreateTable()
+		if err != nil {
+			log.Fatal(err)
 		}
 
-		table.AppendBulk(volTable)
+		table.Headers(headers...)
 
-		if table.NumLines() > 0 {
-			table.Render()
-		} else {
-			logrus.Warnf("no volumes created for %s", app.Name)
+		var rows [][]string
+		for _, volume := range volumes {
+			row := []string{volume.Name, volume.Mountpoint}
+			rows = append(rows, row)
 		}
 
-		return nil
+		table.Rows(rows...)
+
+		if len(rows) > 0 {
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
+			}
+			return
+		}
+
+		log.Warn(i18n.G("no volumes created for %s", app.Name))
 	},
 }
 
-var appVolumeRemoveCommand = cli.Command{
-	Name:  "remove",
-	Usage: "Remove volume(s) associated with an app",
-	Description: `
-This command supports removing 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.
+// translators: `abra app volume remove` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appVolumeRemoveAliases = i18n.G("rm")
+
+var AppVolumeRemoveCommand = &cobra.Command{
+	// translators: `app volume remove` command
+	Use: i18n.G("remove <domain> [volume] [flags]"),
+	// translators: Short description for `app volume remove` command
+	Short: i18n.G("Remove volume(s) associated with an app"),
+	Long: i18n.G(`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.
 
 The command is interactive and will show a multiple select input which allows
 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.
-`,
-	ArgsUsage: "<domain>",
-	Aliases:   []string{"rm"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.ForceFlag,
+Passing "--force/-f" will select all volumes for removal. Be careful.`),
+	Example: i18n.G(`  # delete volumes interactively
+  abra app volume rm 1312.net
+
+  # delete specific volume
+  abra app volume rm 1312.net my_volume`),
+	Aliases: strings.Split(appVolumeRemoveAliases, ","),
+	Args:    cobra.MinimumNArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.AppNameComplete()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if isDeployed {
-			logrus.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name)
+		if deployMeta.IsDeployed {
+			log.Fatal(i18n.G("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name))
 		}
 
 		filters, err := app.Filters(false, true)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, filters)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		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.Fatal(i18n.G("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.Fatal(i18n.G("removing volume %s failed: %s", volumeToDelete, err))
+			}
+
+			log.Info(i18n.G("volume %s removed successfully", volumeToDelete))
+
+			return
+		}
+
 		var volumesToRemove []string
 		if !internal.Force && !internal.NoInput {
 			volumesPrompt := &survey.MultiSelect{
-				Message: "which volumes do you want to remove?",
-				Help:    "'x' indicates selected, enter / return to confirm, ctrl-c to exit, vim mode is enabled",
+				Message: i18n.G("which volumes do you want to remove?"),
+				Help:    i18n.G("'x' indicates selected, enter / return to confirm, ctrl-c to exit, vim mode is enabled"),
 				VimMode: true,
 				Options: volumeNames,
 				Default: volumeNames,
 			}
 			if err := survey.AskOne(volumesPrompt, &volumesToRemove); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
@@ -134,25 +189,33 @@ Passing "--force/-f" will select all volumes for removal. Be careful.
 		if len(volumesToRemove) > 0 {
 			err := client.RemoveVolumes(cl, context.Background(), volumesToRemove, internal.Force, 5)
 			if err != nil {
-				log.Fatalf("removing volumes failed: %s", err)
+				log.Fatal(i18n.G("removing volumes failed: %s", err))
 			}
 
-			logrus.Infof("%d volumes removed successfully", len(volumesToRemove))
+			log.Info(i18n.G("%d volumes removed successfully", len(volumesToRemove)))
 		} else {
-			logrus.Info("no volumes removed")
+			log.Info(i18n.G("no volumes removed"))
 		}
-
-		return nil
 	},
 }
 
-var appVolumeCommand = cli.Command{
-	Name:      "volume",
-	Aliases:   []string{"vl"},
-	Usage:     "Manage app volumes",
-	ArgsUsage: "<domain>",
-	Subcommands: []cli.Command{
-		appVolumeListCommand,
-		appVolumeRemoveCommand,
-	},
+// translators: `abra app volume` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appVolumeAliases = i18n.G("vl")
+
+var AppVolumeCommand = &cobra.Command{
+	// translators: `app volume` command group
+	Use:     i18n.G("volume [cmd] [args] [flags]"),
+	Aliases: strings.Split(appVolumeAliases, ","),
+	Short:   i18n.G("Manage app volumes"),
+}
+
+func init() {
+	AppVolumeRemoveCommand.Flags().BoolVarP(
+		&internal.Force,
+		i18n.G("force"),
+		i18n.G("f"),
+		false,
+		i18n.G("perform action without further prompt"),
+	)
 }

cli/catalogue/catalogue.go

@@ -6,6 +6,8 @@ import (
 	"io/ioutil"
 	"os"
 	"path"
+	"slices"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
@@ -13,101 +15,145 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var catalogueGenerateCommand = cli.Command{
-	Name:    "generate",
-	Aliases: []string{"g"},
-	Usage:   "Generate the recipe catalogue",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.PublishFlag,
-		internal.DryFlag,
-		internal.SkipUpdatesFlag,
-		internal.ChaosFlag,
-		internal.OfflineFlag,
+// translators: `abra catalogue sync` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appCatalogueSyncAliases = i18n.G("s")
+
+var CatalogueSyncCommand = &cobra.Command{
+	// translators: `catalogue sync` command
+	Use:     i18n.G("sync [flags]"),
+	Aliases: strings.Split(appCatalogueSyncAliases, ","),
+	// translators: Short description for `catalogue sync` command
+	Short: i18n.G("Sync recipe catalogue for latest changes"),
+	Args:  cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := catalogue.EnsureCatalogue(); err != nil {
+			log.Fatal(err)
+		}
+
+		if err := catalogue.EnsureUpToDate(); err != nil {
+			log.Fatal(err)
+		}
+
+		log.Info(i18n.G("catalogue successfully synced"))
 	},
-	Before: internal.SubCommandBefore,
-	Description: `
-Generate a new copy of the recipe catalogue which can be found on:
+}
 
-    https://recipes.coopcloud.tech (website that humans read)
-    https://recipes.coopcloud.tech/recipes.json (JSON that Abra reads)
+// translators: `abra catalogue` aliases. use a comma separated list of aliases with
+// no spaces in between
+var appCatalogueAliases = i18n.G("g")
 
-It polls the entire git.coopcloud.tech/coop-cloud/... recipe repository
-listing, parses README.md and git tags to produce recipe metadata which is
-loaded into the catalogue JSON file.
+var CatalogueGenerateCommand = &cobra.Command{
+	// translators: `catalogue generate` command
+	Use:     i18n.G("generate [recipe] [flags]"),
+	Aliases: strings.Split(appCatalogueAliases, ","),
+	// translators: Short description for `catalogue generate` command
+	Short: i18n.G("Generate the recipe catalogue"),
+	Long: i18n.G(`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
-that you have permission to git push to these repositories and have your SSH
-keys configured on your account.
-`,
-	ArgsUsage:    "[<recipe>]",
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipeName := c.Args().First()
-		r := recipe.Recipe{}
+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. Enable ssh-agent and make sure to add
+your private key and enter your passphrase beforehand.
+
+    eval ` + "`ssh-agent`" + `
+    ssh-add ~/.ssh/<my-ssh-private-key-for-git-coopcloud-tech>`),
+	Example: `  # publish catalogue
+  eval ` + "`ssh-agent`" + `
+  ssh-add ~/.ssh/id_ed25519
+  abra catalogue generate -p`,
+	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 os.Getenv("SSH_AUTH_SOCK") == "" {
+			log.Warn(i18n.G("ssh: SSH_AUTH_SOCK missing, --publish/-p will fail. see \"abra catalogue generate --help\""))
+		}
 
 		if recipeName != "" {
-			r = internal.ValidateRecipe(c)
+			internal.ValidateRecipe(args, cmd.Name())
+		}
+
+		if err := catalogue.EnsureCatalogue(); err != nil {
+			log.Fatal(err)
 		}
 
 		if !internal.Chaos {
 			if err := catalogue.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
-		repos, err := recipe.ReadReposMetadata()
+		repos, err := recipe.ReadReposMetadata(internal.Debug)
 		if err != nil {
-			logrus.Fatal(err)
+			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 {
-			logrus.Warn(logMsg)
-			if err := recipe.UpdateRepositories(repos, recipeName); err != nil {
-				logrus.Fatal(err)
+		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, i18n.G("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.GetVersions(internal.Offline)
+			r := recipe.Get(recipeMeta.Name)
+			versions, warnMsgs, err := r.GetRecipeVersions()
 			if err != nil {
-				logrus.Warn(err)
+				warnings = append(warnings, err.Error())
+			}
+			if len(warnMsgs) > 0 {
+				warnings = append(warnings, warnMsgs...)
 			}
 
-			features, category, err := r.GetRecipeFeaturesAndCategory()
+			features, category, warnMsgs, err := recipe.GetRecipeFeaturesAndCategory(r)
 			if err != nil {
-				logrus.Warn(err)
+				warnings = append(warnings, err.Error())
+			}
+			if len(warnMsgs) > 0 {
+				warnings = append(warnings, warnMsgs...)
 			}
 
 			catl[recipeMeta.Name] = recipe.RecipeMeta{
@@ -123,103 +169,154 @@ 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, "", "    ")
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if recipeName == "" {
-			if err := os.WriteFile(config.RECIPES_JSON, recipesJSON, 0764); err != nil {
-				logrus.Fatal(err)
+			if err := ioutil.WriteFile(config.RECIPES_JSON, recipesJSON, 0764); err != nil {
+				log.Fatal(err)
 			}
 		} else {
 			catlFS, err := recipe.ReadRecipeCatalogue(internal.Offline)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			catlFS[recipeName] = catl[recipeName]
 
 			updatedRecipesJSON, err := json.MarshalIndent(catlFS, "", "    ")
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if err := ioutil.WriteFile(config.RECIPES_JSON, updatedRecipesJSON, 0764); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
-		logrus.Infof("generated new recipe catalogue in %s", config.RECIPES_JSON)
+		log.Info(i18n.G("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 {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if isClean {
 				if !internal.Dry {
-					logrus.Fatalf("no changes discovered in %s, nothing to publish?", cataloguePath)
+					log.Fatal(i18n.G("no changes discovered in %s, nothing to publish?", cataloguePath))
 				}
 			}
 
-			msg := "chore: publish new catalogue release changes"
+			msg := i18n.G("chore: publish new catalogue release changes")
 			if err := gitPkg.Commit(cataloguePath, msg, internal.Dry); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			repo, err := git.PlainOpen(cataloguePath)
 			if err != nil {
-				logrus.Fatal(err)
+				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 {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if err := gitPkg.Push(cataloguePath, "origin-ssh", false, internal.Dry); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		repo, err := git.PlainOpen(cataloguePath)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		head, err := repo.Head()
 		if err != nil {
-			logrus.Fatal(err)
+			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())
-			logrus.Infof("new changes published: %s", url)
+			log.Info(i18n.G("new changes published: %s", url))
 		}
 
 		if internal.Dry {
-			logrus.Info("dry run: no changes published")
+			log.Info(i18n.G("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"},
-	ArgsUsage:   "<recipe>",
-	Description: "This command helps recipe packagers interact with the recipe catalogue",
-	Subcommands: []cli.Command{
-		catalogueGenerateCommand,
-	},
+var CatalogueCommand = &cobra.Command{
+	// translators: `catalogue` command group
+	Use: i18n.G("catalogue [cmd] [args] [flags]"),
+	// translators: Short description for `catalogue` command group
+	Short:   i18n.G("Manage the recipe catalogue"),
+	Aliases: []string{"c"},
+}
+
+var (
+	publishChanges bool
+	skipUpdates    bool
+)
+
+func init() {
+	CatalogueGenerateCommand.Flags().BoolVarP(
+		&publishChanges,
+		i18n.G("publish"),
+		i18n.G("p"),
+		false,
+		i18n.G("publish changes to git.coopcloud.tech"),
+	)
+
+	CatalogueGenerateCommand.Flags().BoolVarP(
+		&internal.Dry,
+		i18n.G("dry-run"),
+		i18n.G("r"),
+		false,
+		i18n.G("report changes that would be made"),
+	)
+
+	CatalogueGenerateCommand.Flags().BoolVarP(
+		&skipUpdates,
+		i18n.G("skip-updates"),
+		i18n.G("s"),
+		false,
+		i18n.G("skip updating recipe repositories"),
+	)
+
+	CatalogueGenerateCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
 }

cli/cli.go

@@ -1,206 +0,0 @@
-// Package cli provides the interface for the command-line.
-package cli
-
-import (
-	"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"
-	cataloguePkg "coopcloud.tech/abra/pkg/catalogue"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/web"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// AutoCompleteCommand helps people set up auto-complete in their shells
-var AutoCompleteCommand = cli.Command{
-	Name:    "autocomplete",
-	Aliases: []string{"ac"},
-	Usage:   "Configure shell autocompletion (recommended)",
-	Description: `
-Set up auto-completion in your shell by downloading the relevant files and
-laying out what additional information must be loaded. Supported shells are as
-follows: bash, fish, fizsh & zsh.
-
-Example:
-
-    abra autocomplete bash
-`,
-	ArgsUsage: "<shell>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-	},
-	Action: func(c *cli.Context) error {
-		shellType := c.Args().First()
-
-		if shellType == "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no shell provided"))
-		}
-
-		supportedShells := map[string]bool{
-			"bash":  true,
-			"zsh":   true,
-			"fizsh": true,
-			"fish":  true,
-		}
-
-		if _, ok := supportedShells[shellType]; !ok {
-			logrus.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) {
-				logrus.Fatal(err)
-			}
-			logrus.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)
-			logrus.Infof("fetching %s", url)
-			if err := web.GetFile(autocompletionFile, url); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		switch shellType {
-		case "bash":
-			fmt.Println(fmt.Sprintf(`
-# Run the following commands to install auto-completion
-sudo mkdir /etc/bash_completion.d/
-sudo cp %s /etc/bash_completion.d/abra
-echo "source /etc/bash_completion.d/abra" >> ~/.bashrc
-# 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 install auto-completion
-sudo mkdir /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
-# 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 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
-# 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 itself",
-	Description: `
-Upgrade Abra in-place with the latest stable or release candidate.
-
-Pass "-r/--rc" to install the latest release candidate. Please bear in mind
-that it may contain catastrophic bugs. Thank you very much for the testing
-efforts!
-`,
-	Flags: []cli.Flag{internal.RCFlag},
-	Action: func(c *cli.Context) error {
-		mainURL := "https://install.abra.coopcloud.tech"
-		cmd := 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"
-			cmd = exec.Command("bash", "-c", fmt.Sprintf("wget -q -O- %s | bash -s -- --rc", releaseCandidateURL))
-		}
-
-		logrus.Debugf("attempting to run %s", cmd)
-
-		if err := internal.RunCmd(cmd); err != nil {
-			logrus.Fatal(err)
-		}
-
-		return nil
-	},
-}
-
-func newAbraApp(version, commit string) *cli.App {
-	app := &cli.App{
-		Name: "abra",
-		Usage: `The Co-op Cloud command-line utility belt 🎩🐇
-    ____                           ____ _                 _
-   / ___|___         ___  _ __    / ___| | ___  _   _  __| |
-  | |   / _ \ _____ / _ \| '_ \  | |   | |/ _ \| | | |/ _' |
-  | |__| (_) |_____| (_) | |_) | | |___| | (_) | |_| | (_| |
-   \____\___/       \___/| .__/   \____|_|\___/ \__,_|\__,_|
-                         |_|
-`,
-		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
-		Commands: []cli.Command{
-			app.AppCommand,
-			server.ServerCommand,
-			recipe.RecipeCommand,
-			catalogue.CatalogueCommand,
-			UpgradeCommand,
-			AutoCompleteCommand,
-		},
-		BashComplete: autocomplete.SubcommandComplete,
-	}
-
-	app.EnableBashCompletion = true
-
-	app.Before = func(c *cli.Context) 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) {
-					logrus.Fatal(err)
-				}
-				continue
-			}
-		}
-
-		if err := cataloguePkg.EnsureCatalogue(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("abra version %s, commit %s", version, commit)
-
-		return nil
-	}
-
-	return app
-}
-
-// RunApp runs CLI abra app.
-func RunApp(version, commit string) {
-	app := newAbraApp(version, commit)
-
-	if err := app.Run(os.Args); err != nil {
-		logrus.Fatal(err)
-	}
-}

cli/complete.go

@@ -0,0 +1,71 @@
+package cli
+
+import (
+	"os"
+	"strings"
+
+	"coopcloud.tech/abra/pkg/i18n"
+	"github.com/spf13/cobra"
+)
+
+// translators: `abra autocomplete` aliases. use a comma separated list of
+// aliases with no spaces in between
+var autocompleteAliases = i18n.G("ac")
+
+var AutocompleteCommand = &cobra.Command{
+	// translators: `autocomplete` command
+	Use:     i18n.G("autocomplete [bash|zsh|fish|powershell]"),
+	Aliases: strings.Split(autocompleteAliases, ","),
+	// translators: Short description for `autocomplete` command
+	Short: i18n.G("Generate autocompletion script"),
+	Long: i18n.G(`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,16 +2,20 @@ package internal
 
 import (
 	"context"
+	"errors"
+	"io"
 
 	"coopcloud.tech/abra/pkg/config"
 	containerPkg "coopcloud.tech/abra/pkg/container"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/service"
 	"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/sirupsen/logrus"
 )
 
 // RetrieveBackupBotContainer gets the deployed backupbot container.
@@ -19,10 +23,10 @@ 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{}, errors.New(i18n.G("no backupbot discovered, is it deployed?"))
 	}
 
-	logrus.Debugf("retrieved %s as backup enabled service", chosenService.Spec.Name)
+	log.Debug(i18n.G("retrieved %s as backup enabled service", chosenService.Spec.Name))
 
 	filters := filters.NewArgs()
 	filters.Add("name", chosenService.Spec.Name)
@@ -40,8 +44,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,
@@ -51,17 +59,18 @@ func RunBackupCmdRemote(cl *dockerClient.Client, backupCmd string, containerID s
 		Tty:          true,
 	}
 
-	logrus.Debugf("running backup %s on %s with exec config %v", backupCmd, containerID, execBackupListOpts)
+	log.Debug(i18n.G("running backup %s on %s with exec config %v", backupCmd, containerID, execBackupListOpts))
 
 	// 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,291 +1,23 @@
 package internal
 
-import (
-	"os"
+var (
+	// NOTE(d1): global
+	Debug   bool
+	NoInput bool
+	Offline bool
+	Help    bool
+	Version bool
 
-	logrusStack "github.com/Gurpartap/logrus-stack"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	// NOTE(d1): sub-command specific
+	Chaos            bool
+	DeployLatest     bool
+	DontWaitConverge bool
+	Dry              bool
+	Force            bool
+	MachineReadable  bool
+	Major            bool
+	Minor            bool
+	NoDomainChecks   bool
+	Patch            bool
+	ShowUnchanged    bool
 )
-
-// Secrets stores the variable from SecretsFlag
-var Secrets bool
-
-// SecretsFlag turns on/off automatically generating secrets
-var SecretsFlag = &cli.BoolFlag{
-	Name:        "secrets, 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, 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, p",
-	Usage:       "Remove generated secrets from a local pass store",
-	Destination: &PassRemove,
-}
-
-var File bool
-var FileFlag = &cli.BoolFlag{
-	Name:        "file, f",
-	Usage:       "Treat input as a file",
-	Destination: &File,
-}
-
-var Trim bool
-var TrimFlag = &cli.BoolFlag{
-	Name:        "trim, 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, 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, C",
-	Usage:       "Proceed with 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, T",
-	Usage:       "Disables TTY mode to run this command from a script.",
-	Destination: &Tty,
-}
-
-var NoInput bool
-var NoInputFlag = &cli.BoolFlag{
-	Name:        "no-input, 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, 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, o",
-	Destination: &Offline,
-	Usage:       "Prefer offline & filesystem access when possible",
-}
-
-// 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, 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, m",
-	Destination: &MachineReadable,
-	Usage:       "Output in a machine-readable format (where supported)",
-}
-
-// RC signifies the latest release candidate
-var RC bool
-
-// RCFlag chooses the latest release candidate for install
-var RCFlag = &cli.BoolFlag{
-	Name:        "rc, r",
-	Destination: &RC,
-	Usage:       "Install the latest release candidate",
-}
-
-var Major bool
-var MajorFlag = &cli.BoolFlag{
-	Name:        "major, x",
-	Usage:       "Increase the major part of the version",
-	Destination: &Major,
-}
-
-var Minor bool
-var MinorFlag = &cli.BoolFlag{
-	Name:        "minor, y",
-	Usage:       "Increase the minor part of the version",
-	Destination: &Minor,
-}
-
-var Patch bool
-var PatchFlag = &cli.BoolFlag{
-	Name:        "patch, z",
-	Usage:       "Increase the patch part of the version",
-	Destination: &Patch,
-}
-
-var Dry bool
-var DryFlag = &cli.BoolFlag{
-	Name:        "dry-run, r",
-	Usage:       "Only reports changes that would be made",
-	Destination: &Dry,
-}
-
-var Publish bool
-var PublishFlag = &cli.BoolFlag{
-	Name:        "publish, p",
-	Usage:       "Publish changes to git.coopcloud.tech",
-	Destination: &Publish,
-}
-
-var Domain string
-var DomainFlag = &cli.StringFlag{
-	Name:        "domain, D",
-	Value:       "",
-	Usage:       "Choose a domain name",
-	Destination: &Domain,
-}
-
-var NewAppServer string
-var NewAppServerFlag = &cli.StringFlag{
-	Name:        "server, s",
-	Value:       "",
-	Usage:       "Show apps of a specific server",
-	Destination: &NewAppServer,
-}
-
-var NoDomainChecks bool
-var NoDomainChecksFlag = &cli.BoolFlag{
-	Name:        "no-domain-checks, D",
-	Usage:       "Disable app domain sanity checks",
-	Destination: &NoDomainChecks,
-}
-
-var StdErrOnly bool
-var StdErrOnlyFlag = &cli.BoolFlag{
-	Name:        "stderr, s",
-	Usage:       "Only tail stderr",
-	Destination: &StdErrOnly,
-}
-
-var SinceLogs string
-var SinceLogsFlag = &cli.StringFlag{
-	Name:        "since, S",
-	Value:       "",
-	Usage:       "tail logs since YYYY-MM-DDTHH:MM:SSZ",
-	Destination: &SinceLogs,
-}
-
-var DontWaitConverge bool
-var DontWaitConvergeFlag = &cli.BoolFlag{
-	Name:        "no-converge-checks, c",
-	Usage:       "Don't wait for converge logic checks",
-	Destination: &DontWaitConverge,
-}
-
-var Watch bool
-var WatchFlag = &cli.BoolFlag{
-	Name:        "watch, w",
-	Usage:       "Watch status by polling repeatedly",
-	Destination: &Watch,
-}
-
-var OnlyErrors bool
-var OnlyErrorFlag = &cli.BoolFlag{
-	Name:        "errors, e",
-	Usage:       "Only show errors",
-	Destination: &OnlyErrors,
-}
-
-var SkipUpdates bool
-var SkipUpdatesFlag = &cli.BoolFlag{
-	Name:        "skip-updates, s",
-	Usage:       "Skip updating recipe repositories",
-	Destination: &SkipUpdates,
-}
-
-var AllTags bool
-var AllTagsFlag = &cli.BoolFlag{
-	Name:        "all-tags, a",
-	Usage:       "List all tags, not just upgrades",
-	Destination: &AllTags,
-}
-
-var LocalCmd bool
-var LocalCmdFlag = &cli.BoolFlag{
-	Name:        "local, l",
-	Usage:       "Run command locally",
-	Destination: &LocalCmd,
-}
-
-var RemoteUser string
-var RemoteUserFlag = &cli.StringFlag{
-	Name:        "user, u",
-	Value:       "",
-	Usage:       "User to run command within a service context",
-	Destination: &RemoteUser,
-}
-
-var GitName string
-var GitNameFlag = &cli.StringFlag{
-	Name:        "git-name, gn",
-	Value:       "",
-	Usage:       "Git (user) name to do commits with",
-	Destination: &GitName,
-}
-
-var GitEmail string
-var GitEmailFlag = &cli.StringFlag{
-	Name:        "git-email, ge",
-	Value:       "",
-	Usage:       "Git email name to do commits with",
-	Destination: &GitEmail,
-}
-
-// SubCommandBefore wires up pre-action machinery (e.g. --debug handling).
-func SubCommandBefore(c *cli.Context) error {
-	if Debug {
-		logrus.SetLevel(logrus.DebugLevel)
-		logrus.SetFormatter(&logrus.TextFormatter{})
-		logrus.SetOutput(os.Stderr)
-		logrus.AddHook(logrusStack.StandardHook())
-	}
-
-	return nil
-}

cli/internal/command.go

@@ -3,25 +3,31 @@ package internal
 import (
 	"bufio"
 	"context"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"os/exec"
 	"strings"
 
-	"coopcloud.tech/abra/pkg/config"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	containerPkg "coopcloud.tech/abra/pkg/container"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"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"
-	"github.com/sirupsen/logrus"
 )
 
 // RunCmdRemote executes an abra.sh command in the target service
-func RunCmdRemote(cl *dockerClient.Client, app config.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))
 
@@ -30,7 +36,7 @@ func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName,
 		return err
 	}
 
-	logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(targetContainer.ID), app.Server)
+	log.Debug(i18n.G("retrieved %s as target container on %s", formatter.ShortenID(targetContainer.ID), app.Server))
 
 	toTarOpts := &archive.TarOptions{NoOverwriteDirNonDir: true, Compression: archive.Gzip}
 	content, err := archive.TarWithOptions(abraSh, toTarOpts)
@@ -38,7 +44,7 @@ func RunCmdRemote(cl *dockerClient.Client, app config.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 +57,7 @@ func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName,
 
 	shell := "/bin/bash"
 	findShell := []string{"test", "-e", shell}
-	execCreateOpts := types.ExecConfig{
+	execCreateOpts := containertypes.ExecOptions{
 		AttachStderr: true,
 		AttachStdin:  true,
 		AttachStdout: true,
@@ -61,7 +67,7 @@ func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName,
 	}
 
 	if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
-		logrus.Infof("%s does not exist for %s, use /bin/sh as fallback", shell, app.Name)
+		log.Info(i18n.G("%s does not exist for %s, use /bin/sh as fallback", shell, app.Name))
 		shell = "/bin/sh"
 	}
 
@@ -72,17 +78,19 @@ func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName,
 		cmd = []string{shell, "-c", fmt.Sprintf("TARGET=%s; APP_NAME=%s; STACK_NAME=%s; . /tmp/abra.sh; %s", serviceName, app.Name, app.StackName(), cmdName)}
 	}
 
-	logrus.Debugf("running command: %s", strings.Join(cmd, " "))
+	log.Debug(i18n.G("running command: %s", strings.Join(cmd, " ")))
 
-	if RemoteUser != "" {
-		logrus.Debugf("running command with user %s", RemoteUser)
-		execCreateOpts.User = RemoteUser
+	if remoteUser != "" {
+		log.Debug(i18n.G("running command with user %s", remoteUser))
+		execCreateOpts.User = remoteUser
 	}
 
 	execCreateOpts.Cmd = cmd
+
 	execCreateOpts.Tty = true
-	if Tty {
+	if disableTTY {
 		execCreateOpts.Tty = false
+		log.Debug(i18n.G("not requesting a remote TTY"))
 	}
 
 	if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
@@ -99,7 +107,7 @@ func EnsureCommand(abraSh, recipeName, execCmd string) error {
 	}
 
 	if !strings.Contains(string(bytes), execCmd) {
-		return fmt.Errorf("%s doesn't have a %s function", recipeName, execCmd)
+		return errors.New(i18n.G("%s doesn't have a %s function", recipeName, execCmd))
 	}
 
 	return nil

cli/internal/deploy.go

@@ -1,27 +1,62 @@
 package internal
 
 import (
+	"errors"
 	"fmt"
-	"io/ioutil"
 	"os"
-	"path"
+	"sort"
 	"strings"
 
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
+	"github.com/charmbracelet/lipgloss"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
-// NewVersionOverview shows an upgrade or downgrade overview
-func NewVersionOverview(app config.App, currentVersion, newVersion, releaseNotes string) error {
-	tableCol := []string{"server", "recipe", "config", "domain", "current version", "to be deployed"}
-	table := formatter.CreateTable(tableCol)
+var borderStyle = lipgloss.NewStyle().
+	BorderStyle(lipgloss.ThickBorder()).
+	Padding(0, 1, 0, 1).
+	MaxWidth(79).
+	BorderForeground(lipgloss.Color("63"))
 
+var headerStyle = lipgloss.NewStyle().
+	Underline(true).
+	Bold(true).
+	PaddingBottom(1)
+
+var leftStyle = lipgloss.NewStyle().
+	Bold(true)
+
+var rightStyle = lipgloss.NewStyle()
+
+// horizontal is a JoinHorizontal helper function.
+func horizontal(left, mid, right string) string {
+	return lipgloss.JoinHorizontal(lipgloss.Left, left, mid, right)
+}
+
+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,
+	secrets []string,
+	configs []string,
+	images []string,
+) 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
@@ -29,14 +64,62 @@ func NewVersionOverview(app config.App, currentVersion, newVersion, releaseNotes
 		server = "local"
 	}
 
-	table.Append([]string{server, app.Recipe, deployConfig, app.Domain, currentVersion, newVersion})
-	table.Render()
+	domain := app.Domain
+	if domain == "" {
+		domain = config.MISSING_DEFAULT
+	}
 
-	if releaseNotes != "" && newVersion != "" {
-		fmt.Println()
+	envVersion := app.Recipe.EnvVersionRaw
+	if envVersion == "" {
+		envVersion = config.MISSING_DEFAULT
+	}
+
+	rows := [][]string{
+		{i18n.G("DOMAIN"), domain},
+		{i18n.G("RECIPE"), app.Recipe.Name},
+		{i18n.G("SERVER"), server},
+		{i18n.G("CONFIG"), deployConfig},
+		{"", ""},
+		{i18n.G("CURRENT DEPLOYMENT"), formatter.BoldDirtyDefault(deployedVersion)},
+		{i18n.G("ENV VERSION"), formatter.BoldDirtyDefault(envVersion)},
+		{i18n.G("NEW DEPLOYMENT"), formatter.BoldDirtyDefault(toDeployVersion)},
+	}
+
+	if len(images) > 0 {
+		imageRows := [][]string{
+			{"", ""},
+			{i18n.G("IMAGES"), strings.Join(images, "\n")},
+		}
+		rows = append(rows, imageRows...)
+	}
+
+	if len(secrets) > 0 {
+		secretsRows := [][]string{
+			{"", ""},
+			{i18n.G("SECRETS"), strings.Join(secrets, "\n")},
+		}
+		rows = append(rows, secretsRows...)
+	}
+
+	if len(configs) > 0 {
+		configsRows := [][]string{
+			{"", ""},
+			{i18n.G("CONFIGS"), strings.Join(configs, "\n")},
+		}
+		rows = append(rows, configsRows...)
+	}
+
+	deployType := getDeployType(deployedVersion, toDeployVersion)
+	overview := formatter.CreateOverview(i18n.G("%s OVERVIEW", deployType), rows)
+
+	fmt.Println(overview)
+
+	if releaseNotes != "" {
 		fmt.Print(releaseNotes)
-	} else {
-		logrus.Warnf("no release notes available for %s", newVersion)
+	}
+
+	for _, msg := range warnMessages {
+		log.Warn(msg)
 	}
 
 	if NoInput {
@@ -44,49 +127,126 @@ func NewVersionOverview(app config.App, currentVersion, newVersion, releaseNotes
 	}
 
 	response := false
-	prompt := &survey.Confirm{
-		Message: "continue with deployment?",
-	}
-
+	prompt := &survey.Confirm{Message: "proceed?"}
 	if err := survey.AskOne(prompt, &response); err != nil {
 		return err
 	}
 
 	if !response {
-		logrus.Fatal("exiting as requested")
+		log.Fatal(i18n.G("deployment cancelled"))
 	}
 
 	return nil
 }
 
-// GetReleaseNotes prints release notes for a recipe version
-func GetReleaseNotes(recipeName, version string) (string, error) {
-	if version == "" {
-		return "", nil
+func getDeployType(currentVersion, newVersion string) string {
+	if newVersion == config.MISSING_DEFAULT {
+		return i18n.G("UNDEPLOY")
 	}
 
-	fpath := path.Join(config.RECIPES_DIR, recipeName, "release", version)
-
-	if _, err := os.Stat(fpath); !os.IsNotExist(err) {
-		releaseNotes, err := ioutil.ReadFile(fpath)
-		if err != nil {
-			return "", err
-		}
-		withTitle := fmt.Sprintf("%s release notes:\n%s", version, string(releaseNotes))
-		return withTitle, nil
+	if strings.Contains(newVersion, "+U") {
+		return i18n.G("CHAOS DEPLOY")
 	}
 
-	return "", nil
+	if strings.Contains(currentVersion, "+U") {
+		return i18n.G("UNCHAOS DEPLOY")
+	}
+
+	if currentVersion == newVersion {
+		return ("REDEPLOY")
+	}
+
+	if currentVersion == config.MISSING_DEFAULT {
+		return i18n.G("NEW DEPLOY")
+	}
+
+	currentParsed, err := tagcmp.Parse(currentVersion)
+	if err != nil {
+		return i18n.G("DEPLOY")
+	}
+
+	newParsed, err := tagcmp.Parse(newVersion)
+	if err != nil {
+		return i18n.G("DEPLOY")
+	}
+
+	if currentParsed.IsLessThan(newParsed) {
+		return i18n.G("UPGRADE")
+	}
+
+	return i18n.G("DOWNGRADE")
+}
+
+// MoveOverview shows a overview before moving an app to a different server
+func MoveOverview(
+	app appPkg.App,
+	newServer string,
+	secrets []string,
+	volumes []string,
+) {
+	server := app.Server
+	if app.Server == "default" {
+		server = "local"
+	}
+
+	domain := app.Domain
+	if domain == "" {
+		domain = config.MISSING_DEFAULT
+	}
+
+	secretsOverview := strings.Join(secrets, "\n")
+	if len(secrets) == 0 {
+		secretsOverview = config.MISSING_DEFAULT
+	}
+
+	volumesOverview := strings.Join(volumes, "\n")
+	if len(volumes) == 0 {
+		volumesOverview = config.MISSING_DEFAULT
+	}
+
+	rows := [][]string{
+		{i18n.G("DOMAIN"), domain},
+		{i18n.G("RECIPE"), app.Recipe.Name},
+		{i18n.G("OLD SERVER"), server},
+		{i18n.G("NEW SERVER"), newServer},
+		{i18n.G("SECRETS"), secretsOverview},
+		{i18n.G("VOLUMES"), volumesOverview},
+	}
+
+	overview := formatter.CreateOverview(i18n.G("MOVE OVERVIEW"), rows)
+
+	fmt.Println(overview)
+}
+
+func PromptProcced() error {
+	if NoInput {
+		return nil
+	}
+
+	if Dry {
+		return errors.New(i18n.G("dry run"))
+	}
+
+	response := false
+	prompt := &survey.Confirm{Message: i18n.G("proceed?")}
+	if err := survey.AskOne(prompt, &response); err != nil {
+		return err
+	}
+
+	if !response {
+		return errors.New(i18n.G("cancelled"))
+	}
+
+	return nil
 }
 
 // PostCmds parses a string of commands and executes them inside of the respective services
 // the commands string must have the following format:
 // "<service> <command> <arguments>|<service> <command> <arguments>|... "
-func PostCmds(cl *dockerClient.Client, app config.App, commands string) error {
-	abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
-	if _, err := os.Stat(abraSh); err != nil {
+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?", abraSh, app.Name))
+			return errors.New(i18n.G("%s does not exist for %s?", app.Recipe.AbraShPath, app.Name))
 		}
 		return err
 	}
@@ -94,7 +254,7 @@ func PostCmds(cl *dockerClient.Client, app config.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 errors.New(i18n.G("not enough arguments: %s", command))
 		}
 		targetServiceName := commandParts[0]
 		cmdName := commandParts[1]
@@ -102,13 +262,13 @@ func PostCmds(cl *dockerClient.Client, app config.App, commands string) error {
 		if len(commandParts) > 2 {
 			parsedCmdArgs = fmt.Sprintf("%s ", strings.Join(commandParts[2:], " "))
 		}
-		logrus.Infof("running post-command '%s %s' in container %s", cmdName, parsedCmdArgs, targetServiceName)
+		log.Info(i18n.G("running post-command '%s %s' in container %s", cmdName, parsedCmdArgs, targetServiceName))
 
-		if err := EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
+		if err := EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
 			return err
 		}
 
-		serviceNames, err := config.GetAppServiceNames(app.Name)
+		serviceNames, err := appPkg.GetAppServiceNames(app.Name)
 		if err != nil {
 			return err
 		}
@@ -121,53 +281,38 @@ func PostCmds(cl *dockerClient.Client, app config.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)
 		}
 
-		logrus.Debugf("running command %s %s within the context of %s_%s", cmdName, parsedCmdArgs, app.StackName(), targetServiceName)
+		log.Debug(i18n.G("running command %s %s within the context of %s_%s", cmdName, parsedCmdArgs, app.StackName(), targetServiceName))
 
-		Tty = true
-		if err := RunCmdRemote(cl, app, abraSh, 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
 }
 
-// DeployOverview shows a deployment overview
-func DeployOverview(app config.App, version, message string) error {
-	tableCol := []string{"server", "recipe", "config", "domain", "version"}
-	table := formatter.CreateTable(tableCol)
+// SortVersionsDesc sorts versions in descending order.
+func SortVersionsDesc(versions []string) []string {
+	var tags []tagcmp.Tag
 
-	deployConfig := "compose.yml"
-	if composeFiles, ok := app.Env["COMPOSE_FILE"]; ok {
-		deployConfig = strings.Join(strings.Split(composeFiles, ":"), "\n")
+	for _, v := range versions {
+		parsed, _ := tagcmp.Parse(v) // skips unsupported tags
+		tags = append(tags, parsed)
 	}
 
-	server := app.Server
-	if app.Server == "default" {
-		server = "local"
+	sort.Sort(tagcmp.ByTagDesc(tags))
+
+	var desc []string
+	for _, t := range tags {
+		desc = append(desc, t.String())
 	}
 
-	table.Append([]string{server, app.Recipe, deployConfig, app.Domain, version})
-	table.Render()
-
-	if NoInput {
-		return nil
-	}
-
-	response := false
-	prompt := &survey.Confirm{
-		Message: message,
-	}
-
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
-	}
-
-	if !response {
-		logrus.Fatal("exiting as requested")
-	}
-
-	return nil
+	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,
+		DeployLatest,
+	}
+}

cli/internal/errors.go

@@ -1,18 +0,0 @@
-package internal
-
-import (
-	"os"
-
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// ShowSubcommandHelpAndError exits the program on error, logs the error to the
-// terminal, and shows the help command.
-func ShowSubcommandHelpAndError(c *cli.Context, err interface{}) {
-	if err2 := cli.ShowSubcommandHelp(c); err2 != nil {
-		logrus.Error(err2)
-	}
-	logrus.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/recipe.go

@@ -1,19 +1,21 @@
 package internal
 
 import (
+	"errors"
 	"fmt"
 
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
-	"github.com/sirupsen/logrus"
 )
 
 // PromptBumpType prompts for version bump type
-func PromptBumpType(tagString, latestRelease string) error {
+func PromptBumpType(tagString, latestRelease, changeOverview string) error {
 	if (!Major && !Minor && !Patch) && tagString == "" {
-		fmt.Printf(`
+		fmt.Print(i18n.G(`
 You need to make a decision about what kind of an update this new recipe
 version is. If someone else performs this upgrade, do they have to do some
 migration work or take care of some breaking changes? This can be signaled in
@@ -22,6 +24,8 @@ version.
 
 The latest published version is %s.
 
+%s
+
 Here is a semver cheat sheet (more on https://semver.org):
 
     major: new features/bug fixes, backwards incompatible (e.g 1.0.0 -> 2.0.0).
@@ -36,12 +40,12 @@ Here is a semver cheat sheet (more on https://semver.org):
            should also Just Work and is mostly to do with minor bug fixes
            and/or security patches. "nothing to worry about".
 
-`, latestRelease)
+`, latestRelease, changeOverview))
 
 		var chosenBumpType string
 		prompt := &survey.Select{
 			Message: fmt.Sprintf("select recipe version increment type"),
-			Options: []string{"major", "minor", "patch"},
+			Options: []string{i18n.G("major"), i18n.G("minor"), i18n.G("patch")},
 		}
 
 		if err := survey.AskOne(prompt, &chosenBumpType); err != nil {
@@ -59,13 +63,13 @@ func GetBumpType() string {
 	var bumpType string
 
 	if Major {
-		bumpType = "major"
+		bumpType = i18n.G("major")
 	} else if Minor {
-		bumpType = "minor"
+		bumpType = i18n.G("minor")
 	} else if Patch {
-		bumpType = "patch"
+		bumpType = i18n.G("patch")
 	} else {
-		logrus.Fatal("no version bump type specififed?")
+		log.Fatal(i18n.G("no version bump type specififed?"))
 	}
 
 	return bumpType
@@ -73,14 +77,14 @@ func GetBumpType() string {
 
 // SetBumpType figures out which bump type is specified
 func SetBumpType(bumpType string) {
-	if bumpType == "major" {
+	if bumpType == i18n.G("major") {
 		Major = true
-	} else if bumpType == "minor" {
+	} else if bumpType == i18n.G("minor") {
 		Minor = true
-	} else if bumpType == "patch" {
+	} else if bumpType == i18n.G("patch") {
 		Patch = true
 	} else {
-		logrus.Fatal("no version bump type specififed?")
+		log.Fatal(i18n.G("no version bump type specififed?"))
 	}
 }
 
@@ -88,7 +92,11 @@ func SetBumpType(bumpType string) {
 func GetMainAppImage(recipe recipe.Recipe) (string, error) {
 	var path string
 
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return "", err
+	}
+	for _, service := range config.Services {
 		if service.Name == "app" {
 			img, err := reference.ParseNormalizedNamed(service.Image)
 			if err != nil {
@@ -103,7 +111,7 @@ func GetMainAppImage(recipe recipe.Recipe) (string, error) {
 	}
 
 	if path == "" {
-		return path, fmt.Errorf("%s has no main 'app' service?", recipe.Name)
+		return path, errors.New(i18n.G("%s has no main 'app' service?", recipe.Name))
 	}
 
 	return path, nil

cli/internal/validate.go

@@ -1,156 +1,158 @@
 package internal
 
 import (
-	"errors"
 	"strings"
 
 	"coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
 )
 
 // ValidateRecipe ensures the recipe arg is valid.
-func ValidateRecipe(c *cli.Context) recipe.Recipe {
-	recipeName := c.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 {
-			logrus.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 {
-			logrus.Fatal(err)
-		}
+	knownRecipes := make(map[string]bool)
+	for name := range catl {
+		knownRecipes[name] = true
+	}
 
+	localRecipes, err := recipe.GetRecipesLocal()
+	if err != nil {
+		log.Debug(i18n.G("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",
+			Message: i18n.G("Select recipe"),
 			Options: recipes,
 		}
 		if err := survey.AskOne(prompt, &recipeName); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 	}
 
 	if recipeName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
+		log.Fatal(i18n.G("no recipe name provided"))
 	}
 
-	r, err := recipe.Get(recipeName)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-	if err != nil {
-		if c.Command.Name == "generate" {
-			if strings.Contains(err.Error(), "missing a compose") {
-				logrus.Fatal(err)
-			}
-			logrus.Warn(err)
-		} else {
-			if strings.Contains(err.Error(), "template_driver is not allowed") {
-				logrus.Warnf("ensure %s recipe compose.* files include \"version: '3.8'\"", recipeName)
-			}
-			logrus.Fatalf("unable to validate recipe: %s", err)
+	if _, ok := knownRecipes[recipeName]; !ok {
+		if !strings.Contains(recipeName, "/") {
+			log.Fatal(i18n.G("no recipe '%s' exists?", recipeName))
 		}
 	}
 
-	logrus.Debugf("validated %s as recipe argument", recipeName)
+	chosenRecipe := recipe.Get(recipeName)
+	if err := chosenRecipe.EnsureExists(); err != nil {
+		log.Fatal(err)
+	}
 
-	return r
+	_, err = chosenRecipe.GetComposeConfig(nil)
+	if err != nil {
+		if cmdName == i18n.G("generate") {
+			if strings.Contains(err.Error(), "missing a compose") {
+				log.Fatal(err)
+			}
+			log.Warn(err)
+		} else {
+			if strings.Contains(err.Error(), "template_driver is not allowed") {
+				log.Warn(i18n.G("ensure %s recipe compose.* files include \"version: '3.8'\"", recipeName))
+			}
+			log.Fatal(i18n.G("unable to validate recipe: %s", err))
+		}
+	}
+
+	log.Debug(i18n.G("validated %s as recipe argument", recipeName))
+
+	return chosenRecipe
 }
 
 // ValidateApp ensures the app name arg is valid.
-func ValidateApp(c *cli.Context) config.App {
-	appName := c.Args().First()
-
-	if appName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no app provided"))
+func ValidateApp(args []string) app.App {
+	if len(args) == 0 {
+		log.Fatal(i18n.G("no app provided"))
 	}
 
+	appName := args[0]
+
 	app, err := app.Get(appName)
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
-	logrus.Debugf("validated %s as app argument", appName)
+	log.Debug(i18n.G("validated %s as app argument", appName))
 
 	return app
 }
 
 // ValidateDomain ensures the domain name arg is valid.
-func ValidateDomain(c *cli.Context) string {
-	domainName := c.Args().First()
+func ValidateDomain(args []string) string {
+	var domainName string
+	if len(args) > 0 {
+		domainName = args[0]
+	}
 
 	if domainName == "" && !NoInput {
 		prompt := &survey.Input{
-			Message: "Specify a domain name",
-			Default: "example.com",
+			Message: i18n.G("Specify a domain name"),
+			Default: "1312.net",
 		}
 		if err := survey.AskOne(prompt, &domainName); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 	}
 
 	if domainName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no domain provided"))
+		log.Fatal(i18n.G("no domain provided"))
 	}
 
-	logrus.Debugf("validated %s as domain argument", domainName)
+	log.Debug(i18n.G("validated %s as domain argument", domainName))
 
 	return domainName
 }
 
-// ValidateSubCmdFlags ensures flag order conforms to correct order
-func ValidateSubCmdFlags(c *cli.Context) bool {
-	for argIdx, arg := range c.Args() {
-		if !strings.HasPrefix(arg, "--") {
-			for _, flag := range c.Args()[argIdx:] {
-				if strings.HasPrefix(flag, "--") {
-					return false
-				}
-			}
-		}
-	}
-	return true
-}
-
 // ValidateServer ensures the server name arg is valid.
-func ValidateServer(c *cli.Context) string {
-	serverName := c.Args().First()
+func ValidateServer(args []string) string {
+	var serverName string
+	if len(args) > 0 {
+		serverName = args[0]
+	}
 
 	serverNames, err := config.ReadServerNames()
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	if serverName == "" && !NoInput {
 		prompt := &survey.Select{
-			Message: "Specify a server name",
+			Message: i18n.G("Specify a server name"),
 			Options: serverNames,
 		}
 		if err := survey.AskOne(prompt, &serverName); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 	}
 
@@ -162,14 +164,14 @@ func ValidateServer(c *cli.Context) string {
 	}
 
 	if serverName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no server provided"))
+		log.Fatal(i18n.G("no server provided"))
 	}
 
 	if !matched {
-		ShowSubcommandHelpAndError(c, errors.New("server doesn't exist?"))
+		log.Fatal(i18n.G("server doesn't exist?"))
 	}
 
-	logrus.Debugf("validated %s as server argument", serverName)
+	log.Debug(i18n.G("validated %s as server argument", serverName))
 
 	return serverName
 }

cli/recipe/diff.go

@@ -1,40 +1,38 @@
 package recipe
 
 import (
-	"path"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
 	gitPkg "coopcloud.tech/abra/pkg/git"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/spf13/cobra"
 )
 
-var recipeDiffCommand = cli.Command{
-	Name:        "diff",
-	Usage:       "Show unstaged changes in recipe config",
-	Description: "Due to limitations in our underlying Git dependency, this command requires /usr/bin/git.",
-	Aliases:     []string{"d"},
-	ArgsUsage:   "<recipe>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
+// translators: `abra recipe diff` aliases. use a comma separated list of aliases
+// with no spaces in between
+var recipeDiffAliases = i18n.G("d")
+
+var RecipeDiffCommand = &cobra.Command{
+	// translators: `recipe diff` command
+	Use:     i18n.G("diff <recipe> [flags]"),
+	Aliases: strings.Split(recipeDiffAliases, ","),
+	// translators: Short description for `recipe diff` command
+	Short: i18n.G("Show unstaged changes in recipe config"),
+	Long:  i18n.G("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()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipeName := c.Args().First()
-
-		if recipeName != "" {
-			internal.ValidateRecipe(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		r := internal.ValidateRecipe(args, cmd.Name())
+		if err := gitPkg.DiffUnstaged(r.Dir); err != nil {
+			log.Fatal(err)
 		}
-
-		recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-		if err := gitPkg.DiffUnstaged(recipeDir); err != nil {
-			logrus.Fatal(err)
-		}
-
-		return nil
 	},
 }

cli/recipe/fetch.go

@@ -1,59 +1,142 @@
 package recipe
 
 import (
+	"os"
+	"strings"
+
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"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"},
-	ArgsUsage:   "[<recipe>]",
-	Description: "Retrieves all recipes if no <recipe> argument is passed",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.OfflineFlag,
+// translators: `abra recipe fetch` aliases. use a comma separated list of aliases
+// with no spaces in between
+var recipeFetchAliases = i18n.G("f")
+
+var RecipeFetchCommand = &cobra.Command{
+	// translators: `recipe fetch` command
+	Use:     i18n.G("fetch [recipe | --all] [flags]"),
+	Aliases: strings.Split(recipeFetchAliases, ","),
+	// translators: Short description for `recipe fetch` command
+	Short: i18n.G("Clone recipe(s) locally"),
+	Long:  i18n.G(`Using "--force/-f" Git syncs an existing recipe. It does not erase unstaged changes.`),
+	Args:  cobra.RangeArgs(0, 1),
+	Example: i18n.G(`  # 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()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipeName := c.Args().First()
+	Run: func(cmd *cobra.Command, args []string) {
+		var recipeName string
+		if len(args) > 0 {
+			recipeName = args[0]
+		}
+
+		if recipeName == "" && !fetchAllRecipes {
+			log.Fatal(i18n.G("missing [recipe] or --all/-a"))
+		}
+
+		if recipeName != "" && fetchAllRecipes {
+			log.Fatal(i18n.G("cannot use [recipe] and --all/-a together"))
+		}
 
 		if recipeName != "" {
-			internal.ValidateRecipe(c)
-			r, err := recipe.Get(recipeName)
-			if err != nil {
-				logrus.Fatal(err)
+			r := recipe.Get(recipeName)
+			if _, err := os.Stat(r.Dir); !os.IsNotExist(err) {
+				if !force {
+					log.Warn(i18n.G("%s is already fetched", r.Name))
+					return
+				}
 			}
-			if err := r.Ensure(); err != nil {
-				logrus.Fatal(err)
+
+			r = internal.ValidateRecipe(args, cmd.Name())
+
+			if sshRemote {
+				if r.SSHURL == "" {
+					log.Warn(i18n.G("unable to discover SSH remote for %s", r.Name))
+					return
+				}
+
+				repo, err := git.PlainOpen(r.Dir)
+				if err != nil {
+					log.Fatal(i18n.G("unable to open %s: %s", r.Dir, err))
+				}
+
+				if err = repo.DeleteRemote("origin"); err != nil {
+					log.Fatal(i18n.G("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.Fatal(i18n.G("unable to set SSH remote in %s: %s", r.Dir, err))
+				}
 			}
-			return nil
+
+			return
 		}
 
 		catalogue, err := recipe.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		catlBar := formatter.CreateProgressbar(len(catalogue), "fetching latest recipes...")
+		catlBar := formatter.CreateProgressbar(len(catalogue), i18n.G("fetching latest recipes..."))
+		ensureCtx := internal.GetEnsureContext()
 		for recipeName := range catalogue {
-			r, err := recipe.Get(recipeName)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			if err := r.Ensure(); err != nil {
-				logrus.Error(err)
+			r := recipe.Get(recipeName)
+			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,
+		i18n.G("all"),
+		i18n.GC("a", "recipe fetch"),
+		false,
+		i18n.G("fetch all recipes"),
+	)
+
+	RecipeFetchCommand.Flags().BoolVarP(
+		&sshRemote,
+		i18n.G("ssh"),
+		i18n.G("s"),
+		false,
+		i18n.G("automatically set ssh remote"),
+	)
+
+	RecipeFetchCommand.Flags().BoolVarP(
+		&force,
+		i18n.G("force"),
+		i18n.G("f"),
+		false,
+		i18n.G("force re-fetch"),
+	)
+}

cli/recipe/lint.go

@@ -1,70 +1,69 @@
 package recipe
 
 import (
-	"fmt"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
 	"coopcloud.tech/abra/pkg/lint"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/spf13/cobra"
 )
 
-var recipeLintCommand = cli.Command{
-	Name:      "lint",
-	Usage:     "Lint a recipe",
-	Aliases:   []string{"l"},
-	ArgsUsage: "<recipe>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OnlyErrorFlag,
-		internal.OfflineFlag,
-		internal.NoInputFlag,
-		internal.ChaosFlag,
+// translators: `abra recipe lint` aliases. use a comma separated list of
+// aliases with no spaces in between
+var recipeLintAliases = i18n.G("l")
+
+var RecipeLintCommand = &cobra.Command{
+	// translators: `recipe lint` command
+	Use: i18n.G("lint <recipe> [flags]"),
+	// translators: Short description for `recipe lint` command
+	Short:   i18n.G("Lint a recipe"),
+	Aliases: strings.Split(recipeLintAliases, ","),
+	Args:    cobra.MinimumNArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		r := internal.ValidateRecipe(c)
-		if err := r.LoadConfig(); err != nil {
-			logrus.Fatal(err)
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
+
+		if err := recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
-		if err := r.EnsureExists(); err != nil {
-			logrus.Fatal(err)
+		headers := []string{
+			i18n.G("ref"),
+			i18n.G("rule"),
+			i18n.G("severity"),
+			i18n.G("satisfied"),
+			i18n.G("skipped"),
+			i18n.G("resolve"),
 		}
 
-		if !internal.Chaos {
-			if err := r.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := r.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := r.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
-			}
+		table, err := formatter.CreateTable()
+		if err != nil {
+			log.Fatal(err)
 		}
 
-		tableCol := []string{"ref", "rule", "severity", "satisfied", "skipped", "resolve"}
-		table := formatter.CreateTable(tableCol)
+		table.Headers(headers...)
 
 		hasError := false
-		bar := formatter.CreateProgressbar(-1, "running recipe lint rules...")
+		var rows [][]string
+		var warnMessages []string
 		for level := range lint.LintRules {
 			for _, rule := range lint.LintRules[level] {
-				if internal.OnlyErrors && rule.Level != "error" {
-					logrus.Debugf("skipping %s, does not have level \"error\"", rule.Ref)
+				if onlyError && rule.Level != "error" {
+					log.Debug(i18n.G("skipping %s, does not have level \"error\"", rule.Ref))
 					continue
 				}
 
 				skipped := false
-				if rule.Skip(r) {
+				if rule.Skip(recipe) {
 					skipped = true
 				}
 
@@ -75,12 +74,12 @@ var recipeLintCommand = cli.Command{
 
 				satisfied := false
 				if !skipped {
-					ok, err := rule.Function(r)
+					ok, err := rule.Function(recipe)
 					if err != nil {
-						logrus.Warn(err)
+						warnMessages = append(warnMessages, err.Error())
 					}
 
-					if !ok && rule.Level == "error" {
+					if !ok && rule.Level == i18n.G("error") {
 						hasError = true
 					}
 
@@ -97,28 +96,54 @@ var recipeLintCommand = cli.Command{
 					}
 				}
 
-				table.Append([]string{
+				row := []string{
 					rule.Ref,
 					rule.Description,
 					rule.Level,
 					satisfiedOutput,
 					skippedOutput,
 					rule.HowToResolve,
-				})
+				}
 
-				bar.Add(1)
+				rows = append(rows, row)
+				table.Row(row...)
 			}
 		}
 
-		if table.NumLines() > 0 {
-			fmt.Println()
-			table.Render()
-		}
+		if len(rows) > 0 {
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
+			}
 
-		if hasError {
-			logrus.Warn("watch out, some critical errors are present in your recipe config")
-		}
+			for _, warnMsg := range warnMessages {
+				log.Warn(warnMsg)
+			}
 
-		return nil
+			if hasError {
+				log.Warn(i18n.G("critical errors present in %s config", recipe.Name))
+			}
+		}
 	},
 }
+
+var (
+	onlyError bool
+)
+
+func init() {
+	RecipeLintCommand.Flags().BoolVarP(
+		&internal.Chaos,
+		i18n.G("chaos"),
+		i18n.G("C"),
+		false,
+		i18n.G("ignore uncommitted recipes changes"),
+	)
+
+	RecipeLintCommand.Flags().BoolVarP(
+		&onlyError,
+		i18n.G("error"),
+		i18n.G("e"),
+		false,
+		i18n.G("only show errors"),
+	)
+}

cli/recipe/list.go

@@ -8,45 +8,53 @@ import (
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var pattern string
-var patternFlag = &cli.StringFlag{
-	Name:        "pattern, p",
-	Value:       "",
-	Usage:       "Simple string to filter recipes",
-	Destination: &pattern,
-}
+// translators: `abra recipe list` aliases. use a comma separated list of
+// aliases with no spaces in between
+var recipeListAliases = i18n.G("ls")
 
-var recipeListCommand = cli.Command{
-	Name:    "list",
-	Usage:   "List available recipes",
-	Aliases: []string{"ls"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.MachineReadableFlag,
-		patternFlag,
-		internal.OfflineFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
+var RecipeListCommand = &cobra.Command{
+	// translators: `recipe list` command
+	Use: i18n.G("list"),
+	// translators: Short description for `recipe list` command
+	Short:   i18n.G("List recipes"),
+	Aliases: strings.Split(recipeListAliases, ","),
+	Args:    cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
 		catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
-			logrus.Fatal(err.Error())
+			log.Fatal(err)
 		}
 
 		recipes := catl.Flatten()
 		sort.Sort(recipe.ByRecipeName(recipes))
 
-		tableCol := []string{"name", "category", "status", "healthcheck", "backups", "email", "tests", "SSO"}
-		table := formatter.CreateTable(tableCol)
+		table, err := formatter.CreateTable()
+		if err != nil {
+			log.Fatal(err)
+		}
 
-		len := 0
+		headers := []string{
+			i18n.G("name"),
+			i18n.G("category"),
+			i18n.G("status"),
+			i18n.G("healthcheck"),
+			i18n.G("backups"),
+			i18n.G("email"),
+			i18n.G("tests"),
+			i18n.G("SSO"),
+		}
+
+		table.Headers(headers...)
+
+		var rows [][]string
 		for _, recipe := range recipes {
-			tableRow := []string{
+			row := []string{
 				recipe.Name,
 				recipe.Category,
 				strconv.Itoa(recipe.Features.Status),
@@ -59,25 +67,50 @@ var recipeListCommand = cli.Command{
 
 			if pattern != "" {
 				if strings.Contains(recipe.Name, pattern) {
-					table.Append(tableRow)
-					len++
+					table.Row(row...)
+					rows = append(rows, row)
 				}
 			} else {
-				table.Append(tableRow)
-				len++
+				table.Row(row...)
+				rows = append(rows, row)
 			}
 		}
 
-		if table.NumLines() > 0 {
+		if len(rows) > 0 {
 			if internal.MachineReadable {
-				table.SetCaption(false, "")
-				table.JSONRender()
-			} else {
-				table.SetCaption(true, fmt.Sprintf("total recipes: %v", len))
-				table.Render()
+				out, err := formatter.ToJSON(headers, rows)
+				if err != nil {
+					log.Fatal(i18n.G("unable to render to JSON: %s", err))
+				}
+				fmt.Println(out)
+				return
+			}
+
+			if err := formatter.PrintTable(table); err != nil {
+				log.Fatal(err)
 			}
 		}
-
-		return nil
 	},
 }
+
+var (
+	pattern string
+)
+
+func init() {
+	RecipeListCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		i18n.G("machine"),
+		i18n.G("m"),
+		false,
+		i18n.G("print machine-readable output"),
+	)
+
+	RecipeListCommand.Flags().StringVarP(
+		&pattern,
+		i18n.G("pattern"),
+		i18n.G("p"),
+		"",
+		i18n.G("filter by recipe"),
+	)
+}

cli/recipe/new.go

@@ -2,17 +2,19 @@ package recipe
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"os"
 	"path"
+	"strings"
 	"text/template"
 
-	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/git"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/recipe"
+	"github.com/spf13/cobra"
 )
 
 // recipeMetadata is the recipe metadata for the README.md
@@ -29,99 +31,67 @@ type recipeMetadata struct {
 	SSO         string
 }
 
-var recipeNewCommand = cli.Command{
-	Name:    "new",
-	Aliases: []string{"n"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.OfflineFlag,
-		internal.GitNameFlag,
-		internal.GitEmailFlag,
+// translators: `abra recipe new` aliases. use a comma separated list of
+// aliases with no spaces in between
+var recipeNewAliases = i18n.G("n")
+
+var RecipeNewCommand = &cobra.Command{
+	// translators: `recipe new` command
+	Use:     i18n.G("new <recipe> [flags]"),
+	Aliases: strings.Split(recipeNewAliases, ","),
+	// translators: Short description for `abra recipe new` command
+	Short: i18n.G("Create a new recipe"),
+	Long:  i18n.G(`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",
-	ArgsUsage: "<recipe>",
-	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
-
-Files within the example repository make use of the Golang templating system
-which Abra uses to inject values into the generated recipe folder (e.g. name of
-recipe and domain in the sample environment config).
-`,
-	Action: func(c *cli.Context) error {
-		recipeName := c.Args().First()
-
-		if recipeName == "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
+		r := recipe.Get(recipeName)
+		if _, err := os.Stat(r.Dir); !os.IsNotExist(err) {
+			log.Fatal(i18n.G("%s recipe directory already exists?", r.Dir))
 		}
 
-		directory := path.Join(config.RECIPES_DIR, recipeName)
-		if _, err := os.Stat(directory); !os.IsNotExist(err) {
-			logrus.Fatalf("%s recipe directory already exists?", directory)
+		url := i18n.G("%s/example.git", config.REPOS_BASE_URL)
+		if err := git.Clone(r.Dir, url); err != nil {
+			log.Fatal(err)
 		}
 
-		url := fmt.Sprintf("%s/example.git", config.REPOS_BASE_URL)
-		if err := git.Clone(directory, url); err != nil {
-			logrus.Fatal(err)
-		}
-
-		gitRepo := path.Join(config.RECIPES_DIR, recipeName, ".git")
+		gitRepo := path.Join(r.Dir, ".git")
 		if err := os.RemoveAll(gitRepo); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-		logrus.Debugf("removed example git repo in %s", gitRepo)
+		log.Debug(i18n.G("removed .git repo in %s", gitRepo))
 
 		meta := newRecipeMeta(recipeName)
 
-		toParse := []string{
-			path.Join(config.RECIPES_DIR, recipeName, "README.md"),
-			path.Join(config.RECIPES_DIR, recipeName, ".env.sample"),
-		}
-		for _, path := range toParse {
+		for _, path := range []string{r.ReadmePath, r.SampleEnvPath} {
 			tpl, err := template.ParseFiles(path)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			var templated bytes.Buffer
 			if err := tpl.Execute(&templated, meta); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
-			if err := os.WriteFile(path, templated.Bytes(), 0644); err != nil {
-				logrus.Fatal(err)
+			if err := os.WriteFile(path, templated.Bytes(), 0o644); err != nil {
+				log.Fatal(err)
 			}
-
 		}
 
-		newGitRepo := path.Join(config.RECIPES_DIR, recipeName)
-		if err := git.Init(newGitRepo, true, internal.GitName, internal.GitEmail); err != nil {
-			logrus.Fatal(err)
+		if err := git.Init(r.Dir, true, gitName, gitEmail); err != nil {
+			log.Fatal(err)
 		}
 
-		fmt.Print(fmt.Sprintf(`
-Your new %s recipe has been created in %s.
-
-In order to share your recipe, you can upload it the git repository to:
-
-    https://git.coopcloud.tech/coop-cloud/%s
-
-If you're not sure how to do that, come chat with us:
-
-    https://docs.coopcloud.tech/intro/contact
-
-See "abra recipe -h" for additional recipe maintainer commands.
-
-Happy Hacking!
-
-`, recipeName, path.Join(config.RECIPES_DIR, recipeName), recipeName))
-
-		return nil
+		log.Info(i18n.G("new recipe '%s' created: %s", recipeName, path.Join(r.Dir)))
+		log.Info(i18n.G("happy hacking 🎉"))
 	},
 }
 
@@ -140,3 +110,26 @@ func newRecipeMeta(recipeName string) recipeMetadata {
 		SSO:         "No",
 	}
 }
+
+var (
+	gitName  string
+	gitEmail string
+)
+
+func init() {
+	RecipeNewCommand.Flags().StringVarP(
+		&gitName,
+		i18n.G("git-name"),
+		i18n.G("N"),
+		"",
+		i18n.G("Git (user) name to do commits with"),
+	)
+
+	RecipeNewCommand.Flags().StringVarP(
+		&gitEmail,
+		i18n.G("git-email"),
+		i18n.G("e"),
+		"",
+		i18n.G("Git email name to do commits with"),
+	)
+}

cli/recipe/recipe.go

@@ -1,36 +1,30 @@
 package recipe
 
 import (
-	"github.com/urfave/cli"
+	"strings"
+
+	"coopcloud.tech/abra/pkg/i18n"
+	"github.com/spf13/cobra"
 )
 
+// translators: `abra recipe` aliases. use a comma separated list of aliases
+// with no spaces in between
+var recipeAliases = i18n.G("r")
+
 // RecipeCommand defines all recipe related sub-commands.
-var RecipeCommand = cli.Command{
-	Name:      "recipe",
-	Aliases:   []string{"r"},
-	Usage:     "Manage recipes",
-	ArgsUsage: "<recipe>",
-	Description: `
-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 read them, deploy them and create apps
-for you.
+var RecipeCommand = &cobra.Command{
+	// translators: `recipe` command group
+	Use:     i18n.G("recipe [cmd] [args] [flags]"),
+	Aliases: strings.Split(recipeAliases, ","),
+	// translators: Short description for `recipe` command group
+	Short: i18n.G("Manage recipes"),
+	Long: i18n.G(`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
+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. Abra supports convenient automation for recipe maintainenace, see the
-"abra recipe upgrade", "abra recipe sync" and "abra recipe release" commands.
-`,
-	Subcommands: []cli.Command{
-		recipeFetchCommand,
-		recipeLintCommand,
-		recipeListCommand,
-		recipeNewCommand,
-		recipeReleaseCommand,
-		recipeSyncCommand,
-		recipeUpgradeCommand,
-		recipeVersionCommand,
-		recipeResetCommand,
-		recipeDiffCommand,
-	},
+manner.`),
 }

cli/recipe/release.go

@@ -10,27 +10,33 @@ import (
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
 	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/spf13/cobra"
 )
 
-var recipeReleaseCommand = cli.Command{
-	Name:      "release",
-	Aliases:   []string{"rl"},
-	Usage:     "Release a new recipe version",
-	ArgsUsage: "<recipe> [<version>]",
-	Description: `
-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:
+// translators: `abra recipe release` aliases. use a comma separated list of
+// aliases with no spaces in between
+var recipeReleaseAliases = i18n.G("rl")
+
+var RecipeReleaseCommand = &cobra.Command{
+	// translators: `recipe release` command
+	Use:     i18n.G("release <recipe> [version] [flags]"),
+	Aliases: strings.Split(recipeReleaseAliases, ","),
+	// translators: Short description for `recipe release` command
+	Short: i18n.G("Release a new recipe version"),
+	Long: i18n.G(`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:
 
     a.b.c+x.y.z
 
@@ -44,108 +50,160 @@ 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.DebugFlag,
-		internal.NoInputFlag,
-		internal.DryFlag,
-		internal.MajorFlag,
-		internal.MinorFlag,
-		internal.PatchFlag,
-		internal.PublishFlag,
-		internal.OfflineFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipe(c)
+your SSH keys configured on your account. Enable ssh-agent and make sure to add
+your private key and enter your passphrase beforehand.
 
-		imagesTmp, err := getImageVersions(recipe)
+    eval ` + "`ssh-agent`" + `
+    ssh-add ~/.ssh/<my-ssh-private-key-for-git-coopcloud-tech>`),
+	Example: `  # publish release
+  eval ` + "`ssh-agent`" + `
+  ssh-add ~/.ssh/id_ed25519
+  abra recipe release gitea -p`,
+	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
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
+
+		imagesTmp, err := GetImageVersions(recipe)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		mainApp, err := internal.GetMainAppImage(recipe)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		mainAppVersion := imagesTmp[mainApp]
 		if mainAppVersion == "" {
-			logrus.Fatalf("main app service version for %s is empty?", recipe.Name)
+			log.Fatal(i18n.G("main app service version for %s is empty?", recipe.Name))
+		}
+
+		var tagString string
+		if len(args) == 2 {
+			tagString = args[1]
 		}
 
-		tagString := c.Args().Get(1)
 		if tagString != "" {
 			if _, err := tagcmp.Parse(tagString); err != nil {
-				logrus.Fatalf("cannot parse %s, invalid tag specified?", tagString)
+				log.Fatal(i18n.G("cannot parse %s, invalid tag specified?", tagString))
 			}
 		}
 
 		if (internal.Major || internal.Minor || internal.Patch) && tagString != "" {
-			logrus.Fatal("cannot specify tag and bump type at the same time")
+			log.Fatal(i18n.G("cannot specify tag and bump type at the same time"))
+		}
+
+		repo, err := git.PlainOpen(recipe.Dir)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		preCommitHead, err := repo.Head()
+		if err != nil {
+			log.Fatal(err)
 		}
 
 		if tagString != "" {
 			if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
-				logrus.Fatal(err)
+				if cleanErr := cleanTag(recipe, tagString); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				if cleanErr := cleanCommit(recipe, preCommitHead); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				log.Fatal(err)
 			}
 		}
 
 		tags, err := recipe.Tags()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
+		}
+
+		labelVersion, err := getLabelVersion(recipe, false)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, tag := range tags {
+			previousTagLeftHand := strings.Split(tag, "+")[0]
+			newTagStringLeftHand := strings.Split(labelVersion, "+")[0]
+			if previousTagLeftHand == newTagStringLeftHand {
+				log.Fatal(i18n.G("%s+... conflicts with a previous release: %s", newTagStringLeftHand, tag))
+			}
 		}
 
 		if tagString == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
-			var err error
-			tagString, err = getLabelVersion(recipe, false)
-			if err != nil {
-				logrus.Fatal(err)
-			}
+			tagString = labelVersion
 		}
 
 		isClean, err := gitPkg.IsClean(recipe.Dir)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !isClean {
-			logrus.Infof("%s currently has these unstaged changes 👇", recipe.Name)
+			log.Info(i18n.G("%s currently has these unstaged changes 👇", recipe.Name))
 			if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		if len(tags) > 0 {
-			logrus.Warnf("previous git tags detected, assuming this is a new semver release")
+			log.Warn(i18n.G("previous git tags detected, assuming new semver release"))
+
 			if err := createReleaseFromPreviousTag(tagString, mainAppVersion, recipe, tags); err != nil {
-				logrus.Fatal(err)
+				if cleanErr := cleanTag(recipe, tagString); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				if cleanErr := cleanCommit(recipe, preCommitHead); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				log.Fatal(err)
 			}
 		} else {
-			logrus.Warnf("no tag specified and no previous tag available for %s, assuming this is the initial release", recipe.Name)
+			log.Warn(i18n.G("no tag specified and no previous tag available for %s, assuming initial release", recipe.Name))
 
 			if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
-				if cleanUpErr := cleanUpTag(tagString, recipe.Name); err != nil {
-					logrus.Fatal(cleanUpErr)
+				if cleanErr := cleanTag(recipe, tagString); cleanErr != nil {
+					log.Fatal(cleanErr)
 				}
-				logrus.Fatal(err)
+				if cleanErr := cleanCommit(recipe, preCommitHead); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				log.Fatal(err)
 			}
 		}
 
-		return nil
+		return
 	},
 }
 
-// getImageVersions retrieves image versions for a recipe
-func getImageVersions(recipe recipe.Recipe) (map[string]string, error) {
+// GetImageVersions retrieves image versions for a recipe
+func GetImageVersions(recipe recipe.Recipe) (map[string]string, error) {
 	services := make(map[string]string)
 
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return nil, err
+	}
 	missingTag := false
-	for _, service := range recipe.Config.Services {
+	for _, service := range config.Services {
 		if service.Image == "" {
 			continue
 		}
@@ -174,7 +232,7 @@ func getImageVersions(recipe recipe.Recipe) (map[string]string, error) {
 	}
 
 	if missingTag {
-		return services, fmt.Errorf("app service is missing image tag?")
+		return services, errors.New(i18n.G("app service is missing image tag?"))
 	}
 
 	return services, nil
@@ -184,8 +242,7 @@ func getImageVersions(recipe recipe.Recipe) (map[string]string, error) {
 func createReleaseFromTag(recipe recipe.Recipe, tagString, mainAppVersion string) error {
 	var err error
 
-	directory := path.Join(recipe.Dir)
-	repo, err := git.PlainOpen(directory)
+	repo, err := git.PlainOpen(recipe.Dir)
 	if err != nil {
 		return err
 	}
@@ -210,19 +267,19 @@ func createReleaseFromTag(recipe recipe.Recipe, tagString, mainAppVersion string
 	}
 
 	if err := addReleaseNotes(recipe, tagString); err != nil {
-		logrus.Fatal(err)
+		return errors.New(i18n.G("failed to add release notes: %s", err.Error()))
 	}
 
 	if err := commitRelease(recipe, tagString); err != nil {
-		logrus.Fatal(err)
+		return errors.New(i18n.G("failed to commit changes: %s", err.Error()))
 	}
 
 	if err := tagRelease(tagString, repo); err != nil {
-		logrus.Fatal(err)
+		return errors.New(i18n.G("failed to tag release: %s", err.Error()))
 	}
 
 	if err := pushRelease(recipe, tagString); err != nil {
-		logrus.Fatal(err)
+		return errors.New(i18n.G("failed to publish new release: %s", err.Error()))
 	}
 
 	return nil
@@ -239,14 +296,21 @@ func btoi(b bool) int {
 
 // getTagCreateOptions constructs git tag create options
 func getTagCreateOptions(tag string) (git.CreateTagOptions, error) {
-	msg := fmt.Sprintf("chore: publish %s release", tag)
+	msg := i18n.G("chore: publish %s release", tag)
 	return git.CreateTagOptions{Message: msg}, nil
 }
 
 // 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 +318,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 {
-			logrus.Debugf("dry run: move release note from 'next' to %s", tag)
+			log.Debug(i18n.G("dry run: move release note from 'next' to %s", tag))
 			return nil
 		}
+
 		if !internal.NoInput {
-			prompt := &survey.Input{
-				Message: "Use release note in release/next?",
+			prompt := &survey.Confirm{
+				Message: i18n.G("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)",
+		Message: i18n.G("add release note? (leave empty to skip)"),
 	}
+
 	var releaseNote string
 	if err := survey.AskOne(prompt, &releaseNote); err != nil {
 		return err
@@ -306,12 +376,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
 	}
 
@@ -320,7 +389,7 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 
 func commitRelease(recipe recipe.Recipe, tag string) error {
 	if internal.Dry {
-		logrus.Debugf("dry run: no changes committed")
+		log.Debug(i18n.G("dry run: no changes committed"))
 		return nil
 	}
 
@@ -331,13 +400,12 @@ func commitRelease(recipe recipe.Recipe, tag string) error {
 
 	if isClean {
 		if !internal.Dry {
-			return fmt.Errorf("no changes discovered in %s, nothing to publish?", recipe.Dir)
+			return errors.New(i18n.G("no changes discovered in %s, nothing to publish?", recipe.Dir))
 		}
 	}
 
 	msg := fmt.Sprintf("chore: publish %s release", tag)
-	repoPath := path.Join(config.RECIPES_DIR, recipe.Name)
-	if err := gitPkg.Commit(repoPath, msg, internal.Dry); err != nil {
+	if err := gitPkg.Commit(recipe.Dir, msg, internal.Dry); err != nil {
 		return err
 	}
 
@@ -346,7 +414,7 @@ func commitRelease(recipe recipe.Recipe, tag string) error {
 
 func tagRelease(tagString string, repo *git.Repository) error {
 	if internal.Dry {
-		logrus.Debugf("dry run: no git tag created (%s)", tagString)
+		log.Debug(i18n.G("dry run: no git tag created (%s)", tagString))
 		return nil
 	}
 
@@ -366,35 +434,40 @@ func tagRelease(tagString string, repo *git.Repository) error {
 	}
 
 	hash := formatter.SmallSHA(head.Hash().String())
-	logrus.Debugf(fmt.Sprintf("created tag %s at %s", tagString, hash))
+	log.Debug(i18n.G("created tag %s at %s", tagString, hash))
 
 	return nil
 }
 
 func pushRelease(recipe recipe.Recipe, tagString string) error {
 	if internal.Dry {
-		logrus.Info("dry run: no changes published")
+		log.Info(i18n.G("dry run: no changes published"))
 		return nil
 	}
 
-	if !internal.Publish && !internal.NoInput {
+	if !publish && !internal.NoInput {
 		prompt := &survey.Confirm{
-			Message: "publish new release?",
+			Message: i18n.G("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 os.Getenv("SSH_AUTH_SOCK") == "" {
+			return errors.New(i18n.G("ssh-agent not found. see \"abra recipe release --help\" and try again"))
+		}
+
 		if err := recipe.Push(internal.Dry); err != nil {
 			return err
 		}
-		url := fmt.Sprintf("%s/%s/src/tag/%s", config.REPOS_BASE_URL, recipe.Name, tagString)
-		logrus.Infof("new release published: %s", url)
+
+		url := fmt.Sprintf("%s/src/tag/%s", recipe.GitURL, tagString)
+		log.Info(i18n.G("new release published: %s", url))
 	} else {
-		logrus.Info("no -p/--publish passed, not publishing")
+		log.Info(i18n.G("no -p/--publish passed, not publishing"))
 	}
 
 	return nil
@@ -409,7 +482,7 @@ func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recip
 	bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
 	if bumpType != 0 {
 		if (bumpType & (bumpType - 1)) != 0 {
-			return fmt.Errorf("you can only use one of: --major, --minor, --patch")
+			return errors.New(i18n.G("you can only use one of: --major, --minor, --patch"))
 		}
 	}
 
@@ -454,97 +527,159 @@ func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recip
 		newTag.Major = strconv.Itoa(now + 1)
 	}
 
-	if tagString == "" {
-		if err := internal.PromptBumpType(tagString, lastGitTag.String()); err != nil {
-			return err
-		}
-	}
-
 	if internal.Major || internal.Minor || internal.Patch {
 		newTag.Metadata = mainAppVersion
 		tagString = newTag.String()
 	}
 
 	if lastGitTag.String() == tagString {
-		logrus.Fatalf("latest git tag (%s) and synced label (%s) are the same?", lastGitTag, tagString)
+		return errors.New(i18n.G("latest git tag (%s) and synced label (%s) are the same?", lastGitTag, tagString))
 	}
 
 	if !internal.NoInput {
 		prompt := &survey.Confirm{
-			Message: fmt.Sprintf("current: %s, new: %s, correct?", lastGitTag, tagString),
+			Message: i18n.G("current: %s, new: %s, correct?", lastGitTag, tagString),
 		}
 
 		var ok bool
 		if err := survey.AskOne(prompt, &ok); err != nil {
-			logrus.Fatal(err)
+			return err
 		}
 
 		if !ok {
-			logrus.Fatal("exiting as requested")
+			return errors.New(i18n.G("exiting as requested"))
 		}
 	}
 
 	if err := addReleaseNotes(recipe, tagString); err != nil {
-		logrus.Fatal(err)
+		return errors.New(i18n.G("failed to add release notes: %s", err.Error()))
 	}
 
 	if err := commitRelease(recipe, tagString); err != nil {
-		logrus.Fatalf("failed to commit changes: %s", err.Error())
+		return errors.New(i18n.G("failed to commit changes: %s", err.Error()))
 	}
 
 	if err := tagRelease(tagString, repo); err != nil {
-		logrus.Fatalf("failed to tag release: %s", err.Error())
+		return errors.New(i18n.G("failed to tag release: %s", err.Error()))
 	}
 
 	if err := pushRelease(recipe, tagString); err != nil {
-		logrus.Fatalf("failed to publish new release: %s", err.Error())
+		return errors.New(i18n.G("failed to publish new release: %s", err.Error()))
 	}
 
 	return nil
 }
 
-// cleanUpTag removes a freshly created tag
-func cleanUpTag(tag, recipeName string) error {
-	directory := path.Join(config.RECIPES_DIR, recipeName)
-	repo, err := git.PlainOpen(directory)
+// cleanCommit soft removes the latest release commit. No change are lost the
+// the commit itself is removed. This is the equivalent of `git reset HEAD~1`.
+func cleanCommit(recipe recipe.Recipe, head *plumbing.Reference) error {
+	repo, err := git.PlainOpen(recipe.Dir)
 	if err != nil {
-		return err
+		return errors.New(i18n.G("unable to open repo in %s: %s", recipe.Dir, err))
+	}
+
+	worktree, err := repo.Worktree()
+	if err != nil {
+		return errors.New(i18n.G("unable to open work tree in %s: %s", recipe.Dir, err))
+	}
+
+	opts := &git.ResetOptions{Commit: head.Hash(), Mode: git.MixedReset}
+	if err := worktree.Reset(opts); err != nil {
+		return errors.New(i18n.G("unable to soft reset %s: %s", recipe.Dir, err))
+	}
+
+	log.Debug(i18n.G("removed freshly created commit"))
+
+	return nil
+}
+
+// cleanTag removes a freshly created tag
+func cleanTag(recipe recipe.Recipe, tag string) error {
+	repo, err := git.PlainOpen(recipe.Dir)
+	if err != nil {
+		return errors.New(i18n.G("unable to open repo in %s: %s", recipe.Dir, err))
 	}
 
 	if err := repo.DeleteTag(tag); err != nil {
 		if !strings.Contains(err.Error(), "not found") {
-			return err
+			return errors.New(i18n.G("unable to delete tag %s: %s", tag, err))
 		}
 	}
 
-	logrus.Debugf("removed freshly created tag %s", tag)
+	log.Debug(i18n.G("removed freshly created tag %s", tag))
 
 	return nil
 }
 
 func getLabelVersion(recipe recipe.Recipe, prompt bool) (string, error) {
-	initTag, err := recipePkg.GetVersionLabelLocal(recipe)
+	initTag, err := recipe.GetVersionLabelLocal()
 	if err != nil {
 		return "", err
 	}
 
 	if initTag == "" {
-		logrus.Fatalf("unable to read version for %s from synced label. Did you try running \"abra recipe sync %s\" already?", recipe.Name, recipe.Name)
+		return "", errors.New(i18n.G("unable to read version for %s from synced label. Did you try running \"abra recipe sync %s\" already?", recipe.Name, recipe.Name))
 	}
 
-	logrus.Warnf("discovered %s as currently synced recipe label", initTag)
+	log.Warn(i18n.G("discovered %s as currently synced recipe label", initTag))
 
 	if prompt && !internal.NoInput {
 		var response bool
-		prompt := &survey.Confirm{Message: fmt.Sprintf("use %s as the new version?", initTag)}
+		prompt := &survey.Confirm{Message: i18n.G("use %s as the new version?", initTag)}
 		if err := survey.AskOne(prompt, &response); err != nil {
 			return "", err
 		}
 
 		if !response {
-			return "", fmt.Errorf("please fix your synced label for %s and re-run this command", recipe.Name)
+			return "", errors.New(i18n.G("please fix your synced label for %s and re-run this command", recipe.Name))
 		}
 	}
 
 	return initTag, nil
 }
+
+var (
+	publish bool
+)
+
+func init() {
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&internal.Dry,
+		i18n.G("dry-run"),
+		i18n.G("r"),
+		false,
+		i18n.G("report changes that would be made"),
+	)
+
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&internal.Major,
+		i18n.G("major"),
+		i18n.G("x"),
+		false,
+		i18n.G("increase the major part of the version"),
+	)
+
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&internal.Minor,
+		i18n.G("minor"),
+		i18n.G("y"),
+		false,
+		i18n.G("increase the minor part of the version"),
+	)
+
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&internal.Patch,
+		i18n.G("patch"),
+		i18n.G("z"),
+		false,
+		i18n.G("increase the patch part of the version"),
+	)
+
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&publish,
+		i18n.G("publish"),
+		i18n.G("p"),
+		false,
+		i18n.G("publish changes to git.coopcloud.tech"),
+	)
+}

cli/recipe/reset.go

@@ -1,56 +1,55 @@
 package recipe
 
 import (
-	"path"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"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"},
-	ArgsUsage:   "<recipe>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
+// translators: `abra recipe reset` aliases. use a comma separated list of
+// aliases with no spaces in between
+var recipeResetAliases = i18n.G("rs")
+
+var RecipeResetCommand = &cobra.Command{
+	// translators: `recipe reset` command
+	Use:     i18n.G("reset <recipe> [flags]"),
+	Aliases: strings.Split(recipeResetAliases, ","),
+	// translators: Short description for `recipe reset` command
+	Short: i18n.G("Remove all unstaged changes from recipe config"),
+	Long:  i18n.G("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()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipeName := c.Args().First()
+	Run: func(cmd *cobra.Command, args []string) {
+		r := internal.ValidateRecipe(args, cmd.Name())
 
-		if recipeName != "" {
-			internal.ValidateRecipe(c)
-		}
-
-		repoPath := path.Join(config.RECIPES_DIR, recipeName)
-		repo, err := git.PlainOpen(repoPath)
+		repo, err := git.PlainOpen(r.Dir)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		ref, err := repo.Head()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		worktree, err := repo.Worktree()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		opts := &git.ResetOptions{Commit: ref.Hash(), Mode: git.HardReset}
 		if err := worktree.Reset(opts); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-
-		return nil
 	},
 }

cli/recipe/sync.go

@@ -2,73 +2,88 @@ package recipe
 
 import (
 	"fmt"
-	"path"
 	"strconv"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var recipeSyncCommand = cli.Command{
-	Name:      "sync",
-	Aliases:   []string{"s"},
-	Usage:     "Sync recipe version label",
-	ArgsUsage: "<recipe> [<version>]",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.DryFlag,
-		internal.MajorFlag,
-		internal.MinorFlag,
-		internal.PatchFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-Generate labels for the main recipe service (i.e. by convention, the service
-named "app") which corresponds to the following format:
+// translators: `abra recipe reset` aliases. use a comma separated list of
+// aliases with no spaces in between
+var recipeSyncAliases = i18n.G("s")
+
+var RecipeSyncCommand = &cobra.Command{
+	// translators: `recipe sync` command
+	Use:     i18n.G("sync <recipe> [version] [flags]"),
+	Aliases: strings.Split(recipeSyncAliases, ","),
+	// translators: Short description for `recipe sync` command
+	Short: i18n.G("Sync recipe version label"),
+	Long: i18n.G(`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.
-`,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipe(c)
+local file system.`),
+	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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		imagesTmp, err := getImageVersions(recipe)
+		imagesTmp, err := GetImageVersions(recipe)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		mainAppVersion := imagesTmp[mainApp]
 
 		tags, err := recipe.Tags()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
+		}
+
+		var nextTag string
+		if len(args) == 2 {
+			nextTag = args[1]
 		}
 
-		nextTag := c.Args().Get(1)
 		if len(tags) == 0 && nextTag == "" {
-			logrus.Warnf("no git tags found for %s", recipe.Name)
+			log.Warn(i18n.G("no git tags found for %s", recipe.Name))
 			if internal.NoInput {
-				logrus.Fatalf("unable to continue, input required for initial version")
+				log.Fatal(i18n.G("unable to continue, input required for initial version"))
 			}
-			fmt.Println(fmt.Sprintf(`
+			fmt.Println(i18n.G(`
 The following options are two types of initial semantic version that you can
 pick for %s that will be published in the recipe catalogue. This follows the
 semver convention (more on https://semver.org), here is a short cheatsheet
@@ -88,41 +103,86 @@ likely to change.
 `, recipe.Name, recipe.Name))
 			var chosenVersion string
 			edPrompt := &survey.Select{
-				Message: "which version do you want to begin with?",
+				Message: i18n.G("which version do you want to begin with?"),
 				Options: []string{"0.1.0", "1.0.0"},
 			}
 
 			if err := survey.AskOne(edPrompt, &chosenVersion); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			nextTag = fmt.Sprintf("%s+%s", chosenVersion, mainAppVersion)
 		}
 
 		if nextTag == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
-			latestRelease := tags[len(tags)-1]
-			if err := internal.PromptBumpType("", latestRelease); err != nil {
-				logrus.Fatal(err)
+			var changeOverview string
+
+			catl, err := recipePkg.ReadRecipeCatalogue(false)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			versions, err := recipePkg.GetRecipeCatalogueVersions(recipe.Name, catl)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			changesTable, err := formatter.CreateTable()
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			latestRelease := "0.0.0+0.0.0"
+			if len(tags) > 0 {
+				latestRelease = tags[len(tags)-1]
+			}
+			changesTable.Headers(i18n.G("SERVICE"), latestRelease, i18n.G("PROPOSED CHANGES"))
+
+			latestRecipeVersion := latestRelease
+			if len(versions) > 0 {
+				latestRecipeVersion = versions[len(versions)-1]
+			}
+			allRecipeVersions := catl[recipe.Name].Versions
+			for _, recipeVersion := range allRecipeVersions {
+				if serviceVersions, ok := recipeVersion[latestRecipeVersion]; ok {
+					for serviceName := range serviceVersions {
+						serviceMeta := serviceVersions[serviceName]
+
+						existingImageTag := fmt.Sprintf("%s:%s", serviceMeta.Image, serviceMeta.Tag)
+						newImageTag := fmt.Sprintf("%s:%s", serviceMeta.Image, imagesTmp[serviceMeta.Image])
+
+						if existingImageTag == newImageTag {
+							continue
+						}
+
+						changesTable.Row([]string{serviceName, existingImageTag, newImageTag}...)
+					}
+				}
+			}
+
+			changeOverview = changesTable.Render()
+
+			if err := internal.PromptBumpType("", latestRelease, changeOverview); err != nil {
+				log.Fatal(err)
 			}
 		}
 
 		if nextTag == "" {
-			recipeDir := path.Join(config.RECIPES_DIR, recipe.Name)
-			repo, err := git.PlainOpen(recipeDir)
+			repo, err := git.PlainOpen(recipe.Dir)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			var lastGitTag tagcmp.Tag
 			iter, err := repo.Tags()
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if err := iter.ForEach(func(ref *plumbing.Reference) error {
 				obj, err := repo.TagObject(ref.Hash())
 				if err != nil {
-					logrus.Fatal("Tag at commit ", ref.Hash(), " is unannotated or otherwise broken. Please fix it.")
+					log.Fatal(i18n.G("tag at commit %s is unannotated or otherwise broken", ref.Hash()))
 					return err
 				}
 
@@ -139,7 +199,7 @@ likely to change.
 
 				return nil
 			}); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			// bumpType is used to decide what part of the tag should be incremented
@@ -147,7 +207,7 @@ likely to change.
 			if bumpType != 0 {
 				// a bitwise check if the number is a power of 2
 				if (bumpType & (bumpType - 1)) != 0 {
-					logrus.Fatal("you can only use one version flag: --major, --minor or --patch")
+					log.Fatal(i18n.G("you can only use one version flag: --major, --minor or --patch"))
 				}
 			}
 
@@ -156,14 +216,14 @@ likely to change.
 				if internal.Patch {
 					now, err := strconv.Atoi(newTag.Patch)
 					if err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 
 					newTag.Patch = strconv.Itoa(now + 1)
 				} else if internal.Minor {
 					now, err := strconv.Atoi(newTag.Minor)
 					if err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 
 					newTag.Patch = "0"
@@ -171,7 +231,7 @@ likely to change.
 				} else if internal.Major {
 					now, err := strconv.Atoi(newTag.Major)
 					if err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 
 					newTag.Patch = "0"
@@ -181,35 +241,67 @@ likely to change.
 			}
 
 			newTag.Metadata = mainAppVersion
-			logrus.Debugf("choosing %s as new version for %s", newTag.String(), recipe.Name)
+			log.Debug(i18n.G("choosing %s as new version for %s", newTag.String(), recipe.Name))
 			nextTag = newTag.String()
 		}
 
 		if _, err := tagcmp.Parse(nextTag); err != nil {
-			logrus.Fatalf("invalid version %s specified", nextTag)
+			log.Fatal(i18n.G("invalid version %s specified", nextTag))
 		}
 
 		mainService := "app"
-		label := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", nextTag)
+		label := i18n.G("coop-cloud.${STACK_NAME}.version=%s", nextTag)
 		if !internal.Dry {
 			if err := recipe.UpdateLabel("compose.y*ml", mainService, label); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		} else {
-			logrus.Infof("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name)
+			log.Info(i18n.G("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name))
 		}
 
 		isClean, err := gitPkg.IsClean(recipe.Dir)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		if !isClean {
-			logrus.Infof("%s currently has these unstaged changes 👇", recipe.Name)
+			log.Info(i18n.G("%s currently has these unstaged changes 👇", recipe.Name))
 			if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
-
-		return nil
 	},
 }
+
+func init() {
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Dry,
+		i18n.G("dry-run"),
+		i18n.G("r"),
+		false,
+		i18n.G("report changes that would be made"),
+	)
+
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Major,
+		i18n.G("major"),
+		i18n.G("x"),
+		false,
+		i18n.G("increase the major part of the version"),
+	)
+
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Minor,
+		i18n.G("minor"),
+		i18n.G("y"),
+		false,
+		i18n.G("increase the minor part of the version"),
+	)
+
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Patch,
+		i18n.G("patch"),
+		i18n.G("z"),
+		false,
+		i18n.G("increase the patch part of the version"),
+	)
+}

cli/recipe/upgrade.go

@@ -12,15 +12,15 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
 type imgPin struct {
@@ -28,8 +28,8 @@ type imgPin struct {
 	version tagcmp.Tag
 }
 
-// anUpgrade represents a single service upgrade (as within a recipe), and the list of tags that it can be upgraded to,
-// for serialization purposes.
+// anUpgrade represents a single service upgrade (as within a recipe), and the
+// list of tags that it can be upgraded to, for serialization purposes.
 type anUpgrade struct {
 	Service     string   `json:"service"`
 	Image       string   `json:"image"`
@@ -37,14 +37,19 @@ type anUpgrade struct {
 	UpgradeTags []string `json:"upgrades"`
 }
 
-var recipeUpgradeCommand = cli.Command{
-	Name:    "upgrade",
-	Aliases: []string{"u"},
-	Usage:   "Upgrade recipe image tags",
-	Description: `
-Parse all image tags within the given <recipe> configuration and prompt with
-more recent tags to upgrade to. It will update the relevant compose file tags
-on the local file system.
+// translators: `abra recipe upgrade` aliases. use a comma separated list of
+// aliases with no spaces in between
+var recipeUpgradeAliases = i18n.G("u")
+
+var RecipeUpgradeCommand = &cobra.Command{
+	// translators: `recipe upgrade` command
+	Use:     i18n.G("upgrade <recipe> [flags]"),
+	Aliases: strings.Split(recipeUpgradeAliases, ","),
+	// translators: Short description for `recipe upgrade` command
+	Short: i18n.G("Upgrade recipe image tags"),
+	Long: i18n.G(`Upgrade a given <recipe> configuration.
+
+It will update the relevant compose file tags on the local file system.
 
 Some image tags cannot be parsed because they do not follow some sort of
 semver-like convention. In this case, all possible tags will be listed and it
@@ -54,46 +59,26 @@ The command is interactive and will show a select input which allows you to
 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:
-
-    abra recipe upgrade
-`,
-	ArgsUsage: "<recipe>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.PatchFlag,
-		internal.MinorFlag,
-		internal.MajorFlag,
-		internal.MachineReadableFlag,
-		internal.AllTagsFlag,
+You may invoke this command in "wizard" mode and be prompted for input.`),
+	Args: cobra.RangeArgs(0, 1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.RecipeNameComplete()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipe(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
 
-		if err := recipe.EnsureIsClean(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := recipe.EnsureExists(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := recipe.EnsureUpToDate(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := recipe.EnsureLatest(); err != nil {
-			logrus.Fatal(err)
+		if err := recipe.Ensure(internal.GetEnsureContext()); err != nil {
+			log.Fatal(err)
 		}
 
 		bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
 		if bumpType != 0 {
 			// a bitwise check if the number is a power of 2
 			if (bumpType & (bumpType - 1)) != 0 {
-				logrus.Fatal("you can only use one of: --major, --minor, --patch.")
+				log.Fatal(i18n.G("you can only use one of: --major, --minor, --patch."))
 			}
 		}
 
@@ -106,26 +91,25 @@ You may invoke this command in "wizard" mode and be prompted for input:
 
 		// check for versions file and load pinned versions
 		versionsPresent := false
-		recipeDir := path.Join(config.RECIPES_DIR, recipe.Name)
-		versionsPath := path.Join(recipeDir, "versions")
-		var servicePins = make(map[string]imgPin)
+		versionsPath := path.Join(recipe.Dir, "versions")
+		servicePins := make(map[string]imgPin)
 		if _, err := os.Stat(versionsPath); err == nil {
-			logrus.Debugf("found versions file for %s", recipe.Name)
+			log.Debug(i18n.G("found versions file for %s", recipe.Name))
 			file, err := os.Open(versionsPath)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 			scanner := bufio.NewScanner(file)
 			for scanner.Scan() {
 				line := scanner.Text()
 				splitLine := strings.Split(line, " ")
 				if splitLine[0] != "pin" || len(splitLine) != 3 {
-					logrus.Fatalf("malformed version pin specification: %s", line)
+					log.Fatal(i18n.G("malformed version pin specification: %s", line))
 				}
 				pinSlice := strings.Split(splitLine[2], ":")
 				pinTag, err := tagcmp.Parse(pinSlice[1])
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 				pin := imgPin{
 					image:   pinSlice[0],
@@ -134,45 +118,50 @@ You may invoke this command in "wizard" mode and be prompted for input:
 				servicePins[splitLine[1]] = pin
 			}
 			if err := scanner.Err(); err != nil {
-				logrus.Error(err)
+				log.Error(err)
 			}
 			versionsPresent = true
 		} else {
-			logrus.Debugf("did not find versions file for %s", recipe.Name)
+			log.Debug(i18n.G("did not find versions file for %s", recipe.Name))
 		}
 
-		for _, service := range recipe.Config.Services {
+		config, err := recipe.GetComposeConfig(nil)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, service := range config.Services {
 			img, err := reference.ParseNormalizedNamed(service.Image)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			regVersions, err := client.GetRegistryTags(img)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			image := reference.Path(img)
-			logrus.Debugf("retrieved %s from remote registry for %s", regVersions, image)
+			log.Debug(i18n.G("retrieved %s from remote registry for %s", regVersions, image))
 			image = formatter.StripTagMeta(image)
 
 			switch img.(type) {
 			case reference.NamedTagged:
 				if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) {
-					logrus.Debugf("%s not considered semver-like", img.(reference.NamedTagged).Tag())
+					log.Debug(i18n.G("%s not considered semver-like", img.(reference.NamedTagged).Tag()))
 				}
 			default:
-				logrus.Warnf("unable to read tag for image %s, is it missing? skipping upgrade for %s", image, service.Name)
+				log.Warn(i18n.G("unable to read tag for image %s, is it missing? skipping upgrade for %s", image, service.Name))
 				continue
 			}
 
 			tag, err := tagcmp.Parse(img.(reference.NamedTagged).Tag())
 			if err != nil {
-				logrus.Warnf("unable to parse %s, error was: %s, skipping upgrade for %s", image, err.Error(), service.Name)
+				log.Warn(i18n.G("unable to parse %s, error was: %s, skipping upgrade for %s", image, err.Error(), service.Name))
 				continue
 			}
 
-			logrus.Debugf("parsed %s for %s", tag, service.Name)
+			log.Debug(i18n.G("parsed %s for %s", tag, service.Name))
 
 			var compatible []tagcmp.Tag
 			for _, regVersion := range regVersions {
@@ -186,18 +175,18 @@ You may invoke this command in "wizard" mode and be prompted for input:
 				}
 			}
 
-			logrus.Debugf("detected potential upgradable tags %s for %s", compatible, service.Name)
+			log.Debug(i18n.G("detected potential upgradable tags %s for %s", compatible, service.Name))
 
 			sort.Sort(tagcmp.ByTagDesc(compatible))
 
-			if len(compatible) == 0 && !internal.AllTags {
-				logrus.Info(fmt.Sprintf("no new versions available for %s, assuming %s is the latest (use -a/--all-tags to see all anyway)", image, tag))
+			if len(compatible) == 0 && !allTags {
+				log.Info(i18n.G("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
 			}
 
 			catlVersions, err := recipePkg.VersionsOfService(recipe.Name, service.Name, internal.Offline)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			compatibleStrings := []string{"skip"}
@@ -213,7 +202,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 				}
 			}
 
-			logrus.Debugf("detected compatible upgradable tags %s for %s", compatibleStrings, service.Name)
+			log.Debug(i18n.G("detected compatible upgradable tags %s for %s", compatibleStrings, service.Name))
 
 			var upgradeTag string
 			_, ok := servicePins[service.Name]
@@ -230,13 +219,13 @@ You may invoke this command in "wizard" mode and be prompted for input:
 						}
 					}
 					if contains {
-						logrus.Infof("upgrading service %s from %s to %s (pinned tag: %s)", service.Name, tag.String(), upgradeTag, pinnedTagString)
+						log.Info(i18n.G("upgrading service %s from %s to %s (pinned tag: %s)", service.Name, tag.String(), upgradeTag, pinnedTagString))
 					} else {
-						logrus.Infof("service %s, image %s pinned to %s, no compatible upgrade found", service.Name, servicePins[service.Name].image, pinnedTagString)
+						log.Info(i18n.G("service %s, image %s pinned to %s, no compatible upgrade found", service.Name, servicePins[service.Name].image, pinnedTagString))
 						continue
 					}
 				} else {
-					logrus.Fatalf("service %s is at version %s, but pinned to %s, please correct your compose.yml file manually!", service.Name, tag.String(), pinnedTag.String())
+					log.Fatal(i18n.G("service %s is at version %s, but pinned to %s, please correct your compose.yml file manually!", service.Name, tag.String(), pinnedTag.String()))
 					continue
 				}
 			} else {
@@ -244,7 +233,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 {
@@ -253,17 +242,17 @@ You may invoke this command in "wizard" mode and be prompted for input:
 						}
 					}
 					if upgradeTag == "" {
-						logrus.Warnf("not upgrading from %s to %s for %s, because the upgrade type is more serious than what user wants", tag.String(), compatible[0].String(), image)
+						log.Warn(i18n.G("not upgrading from %s to %s for %s, because the upgrade type is more serious than what user wants", tag.String(), compatible[0].String(), image))
 						continue
 					}
 				} 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 {
+					msg := i18n.G("upgrade to which tag? (service: %s, image: %s, tag: %s)", service.Name, image, tag)
+					if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) || allTags {
 						tag := img.(reference.NamedTagged).Tag()
-						if !internal.AllTags {
-							logrus.Warning(fmt.Sprintf("unable to determine versioning semantics of %s, listing all tags", tag))
+						if !allTags {
+							log.Warn(i18n.G("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)
+						msg = i18n.G("upgrade to which tag? (service: %s, tag: %s)", service.Name, tag)
 						compatibleStrings = []string{"skip"}
 						for _, regVersion := range regVersions {
 							compatibleStrings = append(compatibleStrings, regVersion)
@@ -294,12 +283,12 @@ You may invoke this command in "wizard" mode and be prompted for input:
 					} else {
 						prompt := &survey.Select{
 							Message: msg,
-							Help:    "enter / return to confirm, choose 'skip' to not upgrade this tag, vim mode is enabled",
+							Help:    i18n.G("enter / return to confirm, choose 'skip' to not upgrade this tag, vim mode is enabled"),
 							VimMode: true,
 							Options: compatibleStrings,
 						}
 						if err := survey.AskOne(prompt, &upgradeTag); err != nil {
-							logrus.Fatal(err)
+							log.Fatal(err)
 						}
 					}
 				}
@@ -307,14 +296,14 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			if upgradeTag != "skip" {
 				ok, err := recipe.UpdateTag(image, upgradeTag)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 				if ok {
-					logrus.Infof("tag upgraded from %s to %s for %s", tag.String(), upgradeTag, image)
+					log.Info(i18n.G("tag upgraded from %s to %s for %s", tag.String(), upgradeTag, image))
 				}
 			} else {
 				if !internal.NoInput {
-					logrus.Warnf("not upgrading %s, skipping as requested", image)
+					log.Warn(i18n.G("not upgrading %s, skipping as requested", image))
 				}
 			}
 		}
@@ -323,33 +312,77 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			if internal.MachineReadable {
 				jsonstring, err := json.Marshal(upgradeList)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 
 				fmt.Println(string(jsonstring))
 
-				return nil
+				return
 			}
 
 			for _, upgrade := range upgradeList {
-				logrus.Infof("can upgrade service: %s, image: %s, tag: %s ::\n", upgrade.Service, upgrade.Image, upgrade.Tag)
+				log.Info(i18n.G("can upgrade service: %s, image: %s, tag: %s ::", upgrade.Service, upgrade.Image, upgrade.Tag))
 				for _, utag := range upgrade.UpgradeTags {
-					logrus.Infof("    %s\n", utag)
+					log.Infof("    %s", utag)
 				}
 			}
 		}
 
-		isClean, err := gitPkg.IsClean(recipeDir)
+		isClean, err := gitPkg.IsClean(recipe.Dir)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		if !isClean {
-			logrus.Infof("%s currently has these unstaged changes 👇", recipe.Name)
-			if err := gitPkg.DiffUnstaged(recipeDir); err != nil {
-				logrus.Fatal(err)
+			log.Info(i18n.G("%s currently has these unstaged changes 👇", recipe.Name))
+			if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
+				log.Fatal(err)
 			}
 		}
-
-		return nil
 	},
 }
+
+var (
+	allTags bool
+)
+
+func init() {
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&internal.Major,
+		i18n.G("major"),
+		i18n.G("x"),
+		false,
+		i18n.G("increase the major part of the version"),
+	)
+
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&internal.Minor,
+		i18n.G("minor"),
+		i18n.G("y"),
+		false,
+		i18n.G("increase the minor part of the version"),
+	)
+
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&internal.Patch,
+		i18n.G("patch"),
+		i18n.G("z"),
+		false,
+		i18n.G("increase the patch part of the version"),
+	)
+
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		i18n.G("machine"),
+		i18n.G("m"),
+		false,
+		i18n.G("print machine-readable output"),
+	)
+
+	RecipeUpgradeCommand.Flags().BoolVarP(
+		&allTags,
+		i18n.G("all-tags"),
+		i18n.GC("a", "recipe upgrade"),
+		false,
+		i18n.G("list all tags, not just upgrades"),
+	)
+}

cli/recipe/version.go

@@ -3,86 +3,141 @@ package recipe
 import (
 	"fmt"
 	"sort"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"github.com/olekukonko/tablewriter"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"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]
-	}
-}
+// translators: `abra recipe versions` aliases. use a comma separated list of aliases
+// with no spaces in between
+var recipeVersionsAliases = i18n.G("v")
 
-var recipeVersionCommand = cli.Command{
-	Name:        "versions",
-	Aliases:     []string{"v"},
-	Usage:       "List recipe versions",
-	ArgsUsage:   "<recipe>",
-	Description: "Versions are read from the recipe catalogue.",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
-		internal.NoInputFlag,
-		internal.MachineReadableFlag,
+var RecipeVersionCommand = &cobra.Command{
+	// translators: `recipe versions` command
+	Use:     i18n.G("versions <recipe> [flags]"),
+	Aliases: strings.Split(recipeVersionsAliases, ","),
+	// translators: Short description for `recipe versions` command
+	Short: i18n.G("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,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipe(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		var warnMessages []string
+
+		recipe := internal.ValidateRecipe(args, cmd.Name())
 
 		catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		recipeMeta, ok := catl[recipe.Name]
 		if !ok {
-			logrus.Fatalf("%s is not published on the catalogue?", recipe.Name)
+			warnMessages = append(warnMessages, i18n.G("retrieved versions from local recipe repository"))
+
+			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}
 		}
 
 		if len(recipeMeta.Versions) == 0 {
-			logrus.Fatalf("%s has no catalogue published versions?", recipe.Name)
+			log.Fatal(i18n.G("%s has no published versions?", recipe.Name))
 		}
 
-		tableCols := []string{"version", "service", "image", "tag"}
-		aggregated_table := formatter.CreateTable(tableCols)
 		for i := len(recipeMeta.Versions) - 1; i >= 0; i-- {
-			table := formatter.CreateTable(tableCols)
+			table, err := formatter.CreateTable()
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			table.Headers(i18n.G("SERVICE"), i18n.G("IMAGE"), i18n.G("TAG"), i18n.G("VERSION"))
+
 			for version, meta := range recipeMeta.Versions[i] {
-				var versions [][]string
+				var allRows [][]string
+				var rows [][]string
+
 				for service, serviceMeta := range meta {
-					versions = append(versions, []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(versions, sortServiceByName(versions))
+				sort.Slice(rows, sortServiceByName(rows))
 
-				for _, version := range versions {
-					table.Append(version)
-					aggregated_table.Append(version)
-				}
+				table.Rows(rows...)
 
 				if !internal.MachineReadable {
-					table.SetAutoMergeCellsByColumnIndex([]int{0})
-					table.SetAlignment(tablewriter.ALIGN_LEFT)
-					table.Render()
-					fmt.Println()
+					if err := formatter.PrintTable(table); err != nil {
+						log.Fatal(err)
+					}
+					continue
+				}
+
+				if internal.MachineReadable {
+					sort.Slice(allRows, sortServiceByName(allRows))
+					headers := []string{i18n.G("VERSION"), i18n.G("SERVICE"), i18n.G("NAME"), i18n.G("TAG")}
+					out, err := formatter.ToJSON(headers, allRows)
+					if err != nil {
+						log.Fatal(i18n.G("unable to render to JSON: %s", err))
+					}
+					fmt.Println(out)
+					continue
 				}
 			}
 		}
-		if internal.MachineReadable {
-			aggregated_table.JSONRender()
-		}
 
-		return nil
+		if !internal.MachineReadable {
+			for _, warnMsg := range warnMessages {
+				log.Warn(warnMsg)
+			}
+		}
 	},
 }
+
+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,
+		i18n.G("machine"),
+		i18n.G("m"),
+		false,
+		i18n.G("print machine-readable output"),
+	)
+}

cli/run.go

@@ -0,0 +1,315 @@
+package cli
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+
+	"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/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	charmLog "github.com/charmbracelet/log"
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
+)
+
+var (
+	// translators: `abra` usage template. please translate only words like
+	// "Aliases" and "Example" and nothing inside the {{ ... }}
+	usageTemplate = i18n.G(`Usage:{{if .Runnable}}
+  {{.UseLine}}{{end}}{{if .HasAvailableSubCommands}}
+  {{.CommandPath}} [command]{{end}}{{if gt (len .Aliases) 0}}
+
+Aliases:
+  {{.NameAndAliases}}{{end}}{{if .HasExample}}
+
+Examples:
+{{.Example}}{{end}}{{if .HasAvailableSubCommands}}
+
+Available Commands:{{range .Commands}}{{if (or .IsAvailableCommand (eq .Name "help"))}}
+  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}
+
+Flags:
+{{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasAvailableInheritedFlags}}
+
+Global Flags:
+{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasHelpSubCommands}}
+
+Additional help topics:{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}}
+  {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
+
+Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}
+`)
+
+	helpCmd = &cobra.Command{
+		Use: i18n.G("help [command]"),
+		// translators: Short description for `help` command
+		Short: i18n.G("Help about any command"),
+		Long: i18n.G(`Help provides help for any command in the application.
+Simply type abra help [path to command] for full details.`),
+		Run: func(c *cobra.Command, args []string) {
+			cmd, _, e := c.Root().Find(args)
+			if cmd == nil || e != nil {
+				c.Print(i18n.G("unknown help topic %#q\n", args))
+				if err := c.Root().Usage(); err != nil {
+					log.Fatal(err)
+				}
+			} else {
+				cmd.InitDefaultHelpFlag()
+				cmd.InitDefaultVersionFlag()
+				if err := cmd.Help(); err != nil {
+					log.Fatal(err)
+				}
+			}
+		},
+	}
+)
+
+func Run(version, commit string) {
+	rootCmd := &cobra.Command{
+		// translators: `abra` binary name
+		Use: i18n.G("abra [cmd] [args] [flags]"),
+		// translators: Short description for `abra` binary
+		Short: i18n.G("The Co-op Cloud command-line utility belt 🎩🐇"),
+		// translators: Long description for `abra` binary. This needs to be
+		// translated in the same way as the Short description so that everything
+		// matches up
+		Long: i18n.G(`The Co-op Cloud command-line utility belt 🎩🐇
+
+Config:
+  $ABRA_DIR: %s`, config.ABRA_DIR),
+		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
+		ValidArgs: []string{
+			// translators: `abra app` command for autocompletion
+			i18n.G("app"),
+			// translators: `abra autocomplete` command for autocompletion
+			i18n.G("autocomplete"),
+			// translators: `abra catalogue` command for autocompletion
+			i18n.G("catalogue"),
+			// translators: `abra man` command for autocompletion
+			i18n.G("man"),
+			// translators: `abra recipe` command for autocompletion
+			i18n.G("recipe"),
+			// translators: `abra server` command for autocompletion
+			i18n.G("server"),
+			// translators: `abra upgrade` command for autocompletion
+			i18n.G("upgrade"),
+		},
+		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+			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) {
+							return errors.New(i18n.G("unable to create %s: %s", path, 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.Debug(i18n.G(
+				"abra version: %s, commit: %s, lang: %s",
+				version, formatter.SmallSHA(commit), i18n.Locale,
+			))
+
+			return nil
+		},
+	}
+
+	rootCmd.CompletionOptions.DisableDefaultCmd = true
+	rootCmd.SetUsageTemplate(usageTemplate)
+	rootCmd.SetHelpCommand(helpCmd)
+
+	// translators: `abra man` aliases. use a comma separated list of aliases
+	// with no spaces in between
+	manAliases := i18n.G("m")
+
+	manCommand := &cobra.Command{
+		// translators: `man` command
+		Use:     i18n.G("man [flags]"),
+		Aliases: strings.Split(manAliases, ","),
+		// translators: Short description for `man` command
+		Short: i18n.G("Generate manpage"),
+		Example: i18n.G(`  # 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(i18n.G("unable to proceed, %s does not exist?", manDir))
+			}
+
+			err := doc.GenManTree(rootCmd, header, manDir)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			log.Info(i18n.G("don't forget to run 'sudo mandb'"))
+		},
+	}
+
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.Debug,
+		"debug",
+		"d",
+		false,
+		i18n.G("show debug messages"),
+	)
+
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.NoInput,
+		"no-input",
+		"n",
+		false,
+		i18n.G("toggle non-interactive mode"),
+	)
+
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.Offline,
+		"offline",
+		"o",
+		false,
+		i18n.G("prefer offline & filesystem access"),
+	)
+
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.Help,
+		i18n.G("help"),
+		i18n.G("h"),
+		false,
+		i18n.G("help for abra"),
+	)
+
+	rootCmd.Flags().BoolVarP(
+		&internal.Version,
+		i18n.G("version"),
+		i18n.G("v"),
+		false,
+		i18n.G("version for abra"),
+	)
+
+	catalogue.CatalogueCommand.AddCommand(
+		catalogue.CatalogueGenerateCommand,
+		catalogue.CatalogueSyncCommand,
+	)
+
+	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.AppMoveCommand,
+		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,51 +1,156 @@
 package server
 
 import (
-	"errors"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"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"
 	"coopcloud.tech/abra/pkg/dns"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/server"
 	sshPkg "coopcloud.tech/abra/pkg/ssh"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var local bool
-var localFlag = &cli.BoolFlag{
-	Name:        "local, l",
-	Usage:       "Use local server",
-	Destination: &local,
+// translators: `abra server add` aliases. use a comma separated list of
+// aliases with no spaces in between
+var serverAddAliases = i18n.GC("a", "server add")
+
+var ServerAddCommand = &cobra.Command{
+	// translators: `server add` command
+	Use:     i18n.G("add [[server] | --local] [flags]"),
+	Aliases: strings.Split(serverAddAliases, ","),
+	// translators: Short description for `server add` command
+	Short: i18n.G("Add a new server"),
+	Long: i18n.G(`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: i18n.G("  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(i18n.G("cannot use [server] and --local together"))
+		}
+
+		if len(args) == 0 && !local {
+			log.Fatal(i18n.G("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(i18n.G("attempting to create client for %s", name))
+
+			if _, err := client.New(name, timeout); err != nil {
+				cleanUp(name)
+				log.Fatal(err)
+			}
+
+			if created {
+				log.Info(i18n.G("local server successfully added"))
+			} else {
+				log.Warn(i18n.G("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(i18n.G("unable to create local context: %s", err))
+		}
+
+		log.Debug(i18n.G("attempting to create client for %s", name))
+
+		if _, err := client.New(name, timeout); err != nil {
+			cleanUp(name)
+			log.Fatal(i18n.G("ssh %s error: %s", name, sshPkg.Fatal(name, err)))
+		}
+
+		if created {
+			log.Info(i18n.G("%s successfully added", name))
+
+			if _, err := dns.EnsureIPv4(name); err != nil {
+				log.Warn(i18n.G("unable to resolve IPv4 for %s", name))
+			}
+
+			return
+		}
+
+		log.Warn(i18n.G("%s already exists", name))
+	},
 }
 
-func cleanUp(domainName string) {
-	if domainName != "default" {
-		logrus.Infof("cleaning up context for %s", domainName)
-		if err := client.DeleteContext(domainName); err != nil {
-			logrus.Fatal(err)
+// cleanUp cleans up the partially created context/client details for a failed
+// "server add" attempt.
+func cleanUp(name string) {
+	if name != "default" {
+		log.Debug(i18n.G("serverAdd: cleanUp: cleaning up context for %s", name))
+		if err := client.DeleteContext(name); err != nil {
+			log.Fatal(err)
 		}
 	}
 
-	logrus.Infof("attempting to clean up server directory for %s", domainName)
-
-	serverDir := filepath.Join(config.SERVERS_DIR, domainName)
+	serverDir := filepath.Join(config.SERVERS_DIR, name)
 	files, err := config.GetAllFilesInDirectory(serverDir)
 	if err != nil {
-		logrus.Fatalf("unable to list files in %s: %s", serverDir, err)
+		log.Fatal(i18n.G("serverAdd: cleanUp: unable to list files in %s: %s", serverDir, err))
 	}
 
 	if len(files) > 0 {
-		logrus.Warnf("aborting clean up of %s because it is not empty", serverDir)
+		log.Debug(i18n.G("serverAdd: cleanUp: %s is not empty, aborting cleanup", serverDir))
 		return
 	}
 
 	if err := os.RemoveAll(serverDir); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(i18n.G("serverAdd: cleanUp: failed to remove %s: %s", serverDir, err))
 	}
 }
 
@@ -53,124 +158,54 @@ func cleanUp(domainName string) {
 // Docker manages SSH connection details. These are stored to disk in
 // ~/.docker. Abra can manage this completely for the user, so it's an
 // implementation detail.
-func newContext(c *cli.Context, domainName string) error {
+func newContext(name string) (bool, error) {
 	store := contextPkg.NewDefaultDockerContextStore()
 	contexts, err := store.Store.List()
 	if err != nil {
-		return err
+		return false, err
 	}
 
 	for _, context := range contexts {
-		if context.Name == domainName {
-			logrus.Debugf("context for %s already exists", domainName)
-			return nil
+		if context.Name == name {
+			log.Debug(i18n.G("context for %s already exists", name))
+			return false, nil
 		}
 	}
 
-	logrus.Debugf("creating context with domain %s", domainName)
+	log.Debugf(i18n.G("creating context with domain %s", name))
 
-	if err := client.CreateContext(domainName); err != nil {
-		return err
+	if err := client.CreateContext(name); err != nil {
+		return false, nil
 	}
 
-	return nil
+	return true, nil
 }
 
 // createServerDir creates the ~/.abra/servers/... directory for a new server.
-func createServerDir(domainName string) error {
-	if err := server.CreateServerDir(domainName); err != nil {
+func createServerDir(name string) (bool, error) {
+	if err := server.CreateServerDir(name); err != nil {
 		if !os.IsExist(err) {
-			return err
+			return false, err
 		}
-		logrus.Debugf("server dir for %s already created", domainName)
+
+		log.Debug(i18n.G("server dir for %s already created", name))
+
+		return false, nil
 	}
 
-	return nil
+	return true, nil
 }
 
-var serverAddCommand = cli.Command{
-	Name:    "add",
-	Aliases: []string{"a"},
-	Usage:   "Add a server to your configuration",
-	Description: `
-Add a new server to your configuration so that it can be managed by Abra.
+var (
+	local bool
+)
 
-Abra uses the SSH command-line to discover connection details for your server.
-It is advised to configure an entry per-host in your ~/.ssh/config for each
-server. For example:
-
-Host example.com
-  Hostname example.com
-  User exampleUser
-  Port 12345
-  IdentityFile ~/.ssh/example@somewhere
-
-Abra can then load SSH connection details from this configuratiion with:
-
-    abra server add example.com
-
-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.
-`,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		localFlag,
-	},
-	Before:    internal.SubCommandBefore,
-	ArgsUsage: "<domain>",
-	Action: func(c *cli.Context) error {
-		if len(c.Args()) > 0 && local || !internal.ValidateSubCmdFlags(c) {
-			err := errors.New("cannot use <domain> and --local together")
-			internal.ShowSubcommandHelpAndError(c, err)
-		}
-
-		var domainName string
-		if local {
-			domainName = "default"
-		} else {
-			domainName = internal.ValidateDomain(c)
-		}
-
-		if local {
-			if err := createServerDir(domainName); err != nil {
-				logrus.Fatal(err)
-			}
-
-			logrus.Infof("attempting to create client for %s", domainName)
-			if _, err := client.New(domainName); err != nil {
-				cleanUp(domainName)
-				logrus.Fatal(err)
-			}
-
-			logrus.Info("local server added")
-
-			return nil
-		}
-
-		if _, err := dns.EnsureIPv4(domainName); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := createServerDir(domainName); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := newContext(c, domainName); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Infof("attempting to create client for %s", domainName)
-		if _, err := client.New(domainName); err != nil {
-			cleanUp(domainName)
-			logrus.Debugf("failed to construct client for %s, saw %s", domainName, err.Error())
-			logrus.Fatal(sshPkg.Fatal(domainName, err))
-		}
-
-		logrus.Infof("%s added", domainName)
-
-		return nil
-	},
+func init() {
+	ServerAddCommand.Flags().BoolVarP(
+		&local,
+		i18n.G("local"),
+		i18n.G("l"),
+		false,
+		i18n.G("use local server"),
+	)
 }

cli/server/list.go

@@ -1,110 +1,110 @@
 package server
 
 import (
+	"fmt"
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/context"
+	contextPkg "coopcloud.tech/abra/pkg/context"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/cli/cli/connhelper/ssh"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var problemsFilter bool
+// translators: `abra server list` aliases. use a comma separated list of
+// aliases with no spaces in between
+var serverListAliases = i18n.G("ls")
 
-var problemsFilterFlag = &cli.BoolFlag{
-	Name:        "problems, p",
-	Usage:       "Show only servers with potential connection problems",
-	Destination: &problemsFilter,
-}
-
-var serverListCommand = cli.Command{
-	Name:    "list",
-	Aliases: []string{"ls"},
-	Usage:   "List managed servers",
-	Flags: []cli.Flag{
-		problemsFilterFlag,
-		internal.DebugFlag,
-		internal.MachineReadableFlag,
-		internal.OfflineFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		dockerContextStore := context.NewDefaultDockerContextStore()
+var ServerListCommand = &cobra.Command{
+	// translators: `server list` command
+	Use:     i18n.G("list [flags]"),
+	Aliases: strings.Split(serverListAliases, ","),
+	// translators: Short description for `server list` command
+	Short: i18n.G("List managed servers"),
+	Args:  cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
+		dockerContextStore := contextPkg.NewDefaultDockerContextStore()
 		contexts, err := dockerContextStore.Store.List()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		tableColumns := []string{"name", "host", "user", "port"}
-		table := formatter.CreateTable(tableColumns)
+		table, err := formatter.CreateTable()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		headers := []string{i18n.G("NAME"), i18n.G("HOST")}
+		table.Headers(headers...)
 
 		serverNames, err := config.ReadServerNames()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
+		var rows [][]string
 		for _, serverName := range serverNames {
 			var row []string
-			for _, ctx := range contexts {
-				endpoint, err := context.GetContextEndpoint(ctx)
+			for _, dockerCtx := range contexts {
+				endpoint, err := contextPkg.GetContextEndpoint(dockerCtx)
 				if err != nil && strings.Contains(err.Error(), "does not exist") {
 					// No local context found, we can continue safely
 					continue
 				}
 
-				if ctx.Name == serverName {
+				if dockerCtx.Name == serverName {
 					sp, err := ssh.ParseURL(endpoint)
 					if err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 
 					if sp.Host == "" {
-						sp.Host = "unknown"
-					}
-					if sp.User == "" {
-						sp.User = "unknown"
-					}
-					if sp.Port == "" {
-						sp.Port = "unknown"
+						sp.Host = i18n.G("unknown")
 					}
 
-					row = []string{serverName, sp.Host, sp.User, sp.Port}
+					row = []string{serverName, sp.Host}
+					rows = append(rows, row)
 				}
 			}
 
 			if len(row) == 0 {
 				if serverName == "default" {
-					row = []string{serverName, "local", "n/a", "n/a"}
+					row = []string{serverName, i18n.G("local")}
 				} else {
-					row = []string{serverName, "unknown", "unknown", "unknown"}
+					row = []string{serverName, i18n.G("unknown")}
 				}
+				rows = append(rows, row)
 			}
 
-			if problemsFilter {
-				for _, val := range row {
-					if val == "unknown" {
-						table.Append(row)
-						break
-					}
-				}
-			} else {
-				table.Append(row)
-			}
+			table.Row(row...)
 		}
 
 		if internal.MachineReadable {
-			table.JSONRender()
-		} else {
-			if problemsFilter && table.NumLines() == 0 {
-				logrus.Info("all servers wired up correctly 👏")
-			} else {
-				table.Render()
+			out, err := formatter.ToJSON(headers, rows)
+			if err != nil {
+				log.Fatal(i18n.G("unable to render to JSON: %s", err))
 			}
+
+			fmt.Println(out)
+
+			return
 		}
 
-		return nil
+		if err := formatter.PrintTable(table); err != nil {
+			log.Fatal(err)
+		}
 	},
 }
+
+func init() {
+	ServerListCommand.Flags().BoolVarP(
+		&internal.MachineReadable,
+		i18n.G("machine"),
+		i18n.G("m"),
+		false,
+		i18n.G("print machine-readable output"),
+	)
+}

cli/server/prune.go

@@ -1,103 +1,111 @@
 package server
 
 import (
-	"context"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
-var allFilter bool
+// translators: `abra server prune` aliases. use a comma separated list of
+// aliases with no spaces in between
+var serverPruneliases = i18n.G("p")
 
-var allFilterFlag = &cli.BoolFlag{
-	Name:        "all, a",
-	Usage:       "Remove all unused images not just dangling ones",
-	Destination: &allFilter,
-}
+var ServerPruneCommand = &cobra.Command{
+	// translators: `server prune` command
+	Use:     i18n.G("prune <server> [flags]"),
+	Aliases: strings.Split(serverPruneliases, ","),
+	// translators: Short description for `server prune` command
+	Short: i18n.G("Prune resources on a server"),
+	Long: i18n.G(`Prunes unused containers, networks, and dangling images.
 
-var volumesFilter bool
-
-var volumesFilterFlag = &cli.BoolFlag{
-	Name:        "volumes, v",
-	Usage:       "Prune volumes. This will remove app data, Be Careful!",
-	Destination: &volumesFilter,
-}
-
-var serverPruneCommand = cli.Command{
-	Name:    "prune",
-	Aliases: []string{"p"},
-	Usage:   "Prune a managed server; Runs a docker system prune",
-	Description: `
-Prunes unused containers, networks, and dangling images.
-
-If passing "-v/--volumes" then volumes not connected to a deployed app will
-also be removed. This can result in unwanted data loss if not used carefully.
-	`,
-	ArgsUsage: "[<server>]",
-	Flags: []cli.Flag{
-		allFilterFlag,
-		volumesFilterFlag,
-		internal.DebugFlag,
-		internal.OfflineFlag,
-		internal.NoInputFlag,
+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,
-	BashComplete: autocomplete.ServerNameComplete,
-	Action: func(c *cli.Context) error {
-		serverName := internal.ValidateServer(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		serverName := internal.ValidateServer(args)
 
 		cl, err := client.New(serverName)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		var args filters.Args
+		var filterArgs filters.Args
 
-		ctx := context.Background()
-		cr, err := cl.ContainersPrune(ctx, args)
+		cr, err := cl.ContainersPrune(cmd.Context(), filterArgs)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
-		logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
+		log.Info(i18n.G("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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted))
+		log.Info(i18n.G("networks pruned: %d", len(nr.NetworksDeleted)))
 
 		pruneFilters := filters.NewArgs()
 		if allFilter {
-			logrus.Debugf("removing all images, not only dangling ones")
+			log.Debug(i18n.G("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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed)
-		logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
+		log.Info(i18n.G("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 {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			volSpaceReclaimed := formatter.ByteCountSI(vr.SpaceReclaimed)
-			logrus.Infof("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed)
+			log.Info(i18n.G("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed))
 		}
 
-		return nil
+		return
 	},
 }
+
+var (
+	allFilter     bool
+	volumesFilter bool
+)
+
+func init() {
+	ServerPruneCommand.Flags().BoolVarP(
+		&allFilter,
+		i18n.G("all"),
+		i18n.GC("a", "server prune"),
+		false,
+		i18n.G("remove all unused images"),
+	)
+
+	ServerPruneCommand.Flags().BoolVarP(
+		&volumesFilter,
+		i18n.G("volumes"),
+		i18n.G("v"),
+		false,
+		i18n.G("remove volumes"),
+	)
+}

cli/server/remove.go

@@ -3,46 +3,52 @@ package server
 import (
 	"os"
 	"path/filepath"
+	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/spf13/cobra"
 )
 
-var serverRemoveCommand = cli.Command{
-	Name:      "remove",
-	Aliases:   []string{"rm"},
-	ArgsUsage: "<server>",
-	Usage:     "Remove a managed server",
-	Description: `Remove a managed server.
+// translators: `abra server remove` aliases. use a comma separated list of
+// aliases with no spaces in between
+var serverRemoveAliases = i18n.G("rm")
 
-Abra will remove the internal bookkeeping (~/.abra/servers/...) and underlying
-client connection context. This server will then be lost in time, like tears in
-rain.
-`,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.OfflineFlag,
+var ServerRemoveCommand = &cobra.Command{
+	// translators: `server remove` command
+	Use:     i18n.G("remove <server> [flags]"),
+	Aliases: strings.Split(serverRemoveAliases, ","),
+	// translators: Short description for `server remove` command
+	Short: i18n.G("Remove a managed server"),
+	Long: i18n.G(`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.`),
+	Args: cobra.ExactArgs(1),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		return autocomplete.ServerNameComplete()
 	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.ServerNameComplete,
-	Action: func(c *cli.Context) error {
-		serverName := internal.ValidateServer(c)
+	Run: func(cmd *cobra.Command, args []string) {
+		serverName := internal.ValidateServer(args)
 
 		if err := client.DeleteContext(serverName); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if err := os.RemoveAll(filepath.Join(config.SERVERS_DIR, serverName)); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Infof("server at %s has been lost in time, like tears in rain", serverName)
+		log.Info(i18n.G("%s is now lost in time, like tears in rain", serverName))
 
-		return nil
+		return
 	},
 }

cli/server/server.go

@@ -1,18 +1,21 @@
 package server
 
 import (
-	"github.com/urfave/cli"
+	"strings"
+
+	"coopcloud.tech/abra/pkg/i18n"
+	"github.com/spf13/cobra"
 )
 
+// translators: `abra server` aliases. use a comma separated list of aliases
+// with no spaces in between
+var serverAliases = i18n.G("s")
+
 // ServerCommand defines the `abra server` command and its subcommands
-var ServerCommand = cli.Command{
-	Name:    "server",
-	Aliases: []string{"s"},
-	Usage:   "Manage servers",
-	Subcommands: []cli.Command{
-		serverAddCommand,
-		serverListCommand,
-		serverRemoveCommand,
-		serverPruneCommand,
-	},
+var ServerCommand = &cobra.Command{
+	// translators: `server` command group
+	Use:     i18n.G("server [cmd] [args] [flags]"),
+	Aliases: strings.Split(serverAliases, ","),
+	// translators: Short description for `server` command group
+	Short: i18n.G("Manage servers"),
 }

cli/updater/updater.go

@@ -1,504 +0,0 @@
-package updater
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/lint"
-	"coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/abra/pkg/upstream/convert"
-	"coopcloud.tech/abra/pkg/upstream/stack"
-	"coopcloud.tech/tagcmp"
-	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/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-const SERVER = "localhost"
-
-var majorUpdate bool
-var majorFlag = &cli.BoolFlag{
-	Name:        "major, m",
-	Usage:       "Also check for major updates",
-	Destination: &majorUpdate,
-}
-
-var updateAll bool
-var allFlag = &cli.BoolFlag{
-	Name:        "all, 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",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		majorFlag,
-		internal.OfflineFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-It reads the deployed app versions and looks for new versions in the recipe
-catalogue. If a new patch/minor version is available, a notification is
-printed. To include major versions use the --major flag.
-`,
-	Action: func(c *cli.Context) error {
-		cl, err := client.New("default")
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		stacks, err := stack.GetStacks(cl)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		for _, stackInfo := range stacks {
-			stackName := stackInfo.Name
-			recipeName, err := getLabel(cl, stackName, "recipe")
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if recipeName != "" {
-				_, err = getLatestUpgrade(cl, stackName, recipeName)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-			}
-		}
-
-		return nil
-	},
-}
-
-// UpgradeApp upgrades apps.
-var UpgradeApp = cli.Command{
-	Name:      "upgrade",
-	Aliases:   []string{"u"},
-	Usage:     "Upgrade apps",
-	ArgsUsage: "<stack-name> <recipe>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.ChaosFlag,
-		majorFlag,
-		allFlag,
-		internal.OfflineFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-Upgrade an app by specifying its stack name and recipe. By passing "--all"
-instead, every deployed app is upgraded. For each apps with enabled auto
-updates 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. Don't do that, it will probably
-break things. Only apps that are not deployed with "--chaos" are upgraded, to
-update chaos deployments use the "--chaos" flag. Use it with care.
-`,
-	Action: func(c *cli.Context) error {
-		cl, err := client.New("default")
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !updateAll {
-			stackName := c.Args().Get(0)
-			recipeName := c.Args().Get(1)
-			err = tryUpgrade(cl, stackName, recipeName)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			return nil
-		}
-
-		stacks, err := stack.GetStacks(cl)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		for _, stackInfo := range stacks {
-			stackName := stackInfo.Name
-			recipeName, err := getLabel(cl, stackName, "recipe")
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			err = tryUpgrade(cl, stackName, recipeName)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		return nil
-	},
-}
-
-// getLabel reads docker labels from running services in the format of "coop-cloud.${STACK_NAME}.${LABEL}".
-func getLabel(cl *dockerclient.Client, stackName string, label string) (string, error) {
-	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 "", err
-	}
-
-	for _, service := range services {
-		labelKey := fmt.Sprintf("coop-cloud.%s.%s", stackName, label)
-		if labelValue, ok := service.Spec.Labels[labelKey]; ok {
-			return labelValue, nil
-		}
-	}
-
-	logrus.Debugf("no %s label found for %s", label, stackName)
-
-	return "", nil
-}
-
-// getBoolLabel reads a boolean docker label from running services
-func getBoolLabel(cl *dockerclient.Client, stackName string, label string) (bool, error) {
-	lableValue, err := getLabel(cl, stackName, label)
-	if err != nil {
-		return false, err
-	}
-
-	if lableValue != "" {
-		value, err := strconv.ParseBool(lableValue)
-		if err != nil {
-			return false, err
-		}
-
-		return value, nil
-	}
-
-	logrus.Debugf("Boolean label %s could not be found for %s, set default to false.", label, stackName)
-
-	return false, nil
-}
-
-// getEnv reads env variables from docker services.
-func getEnv(cl *dockerclient.Client, stackName string) (config.AppEnv, error) {
-	envMap := 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 nil, err
-	}
-
-	for _, service := range services {
-		envList := service.Spec.TaskTemplate.ContainerSpec.Env
-		for _, envString := range envList {
-			splitString := strings.SplitN(envString, "=", 2)
-			if len(splitString) != 2 {
-				logrus.Debugf("can't separate key from value: %s (this variable is probably unset)", envString)
-				continue
-			}
-			k := splitString[0]
-			v := splitString[1]
-			logrus.Debugf("For %s read env %s with value: %s from docker service", stackName, k, v)
-			envMap[k] = v
-		}
-	}
-
-	return envMap, nil
-}
-
-// getLatestUpgrade returns the latest available version for an app respecting
-// the "--major" flag if it is newer than the currently deployed version.
-func getLatestUpgrade(cl *dockerclient.Client, stackName string, recipeName string) (string, error) {
-	deployedVersion, err := getDeployedVersion(cl, stackName, recipeName)
-	if err != nil {
-		return "", err
-	}
-
-	availableUpgrades, err := getAvailableUpgrades(cl, stackName, recipeName, deployedVersion)
-	if err != nil {
-		return "", err
-	}
-
-	if len(availableUpgrades) == 0 {
-		logrus.Debugf("no available upgrades for %s", stackName)
-		return "", nil
-	}
-
-	var chosenUpgrade string
-	if len(availableUpgrades) > 0 {
-		chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
-		logrus.Infof("%s (%s) can be upgraded from version %s to %s", stackName, recipeName, deployedVersion, chosenUpgrade)
-	}
-
-	return chosenUpgrade, nil
-}
-
-// getDeployedVersion returns the currently deployed version of an app.
-func getDeployedVersion(cl *dockerclient.Client, stackName string, recipeName string) (string, error) {
-	logrus.Debugf("Retrieve deployed version whether %s is already deployed", stackName)
-
-	isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
-	if err != nil {
-		return "", err
-	}
-
-	if !isDeployed {
-		return "", fmt.Errorf("%s is not deployed?", stackName)
-	}
-
-	if deployedVersion == "unknown" {
-		return "", fmt.Errorf("failed to determine deployed version of %s", stackName)
-	}
-
-	return deployedVersion, nil
-}
-
-// getAvailableUpgrades returns all available versions of an app that are newer
-// than the deployed version. It only includes major upgrades if the "--major"
-// flag is set.
-func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName string,
-	deployedVersion string) ([]string, error) {
-	catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
-	if err != nil {
-		return nil, err
-	}
-
-	versions, err := recipe.GetRecipeCatalogueVersions(recipeName, catl)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(versions) == 0 {
-		logrus.Warnf("no published releases for %s in the recipe catalogue?", recipeName)
-		return nil, nil
-	}
-
-	var availableUpgrades []string
-	for _, version := range versions {
-		parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
-		if err != nil {
-			return nil, err
-		}
-
-		parsedVersion, err := tagcmp.Parse(version)
-		if err != nil {
-			return nil, err
-		}
-
-		versionDelta, err := parsedDeployedVersion.UpgradeDelta(parsedVersion)
-		if err != nil {
-			return nil, err
-		}
-
-		if 0 < versionDelta.UpgradeType() && (versionDelta.UpgradeType() < 4 || majorUpdate) {
-			availableUpgrades = append(availableUpgrades, version)
-		}
-	}
-
-	logrus.Debugf("Available updates for %s: %s", stackName, availableUpgrades)
-
-	return availableUpgrades, nil
-}
-
-// processRecipeRepoVersion clones, pulls, checks out the version and lints the
-// recipe repository.
-func processRecipeRepoVersion(recipe recipe.Recipe, version string) error {
-	if err := recipe.EnsureExists(); err != nil {
-		return err
-	}
-
-	if err := recipe.EnsureUpToDate(); err != nil {
-		return err
-	}
-
-	if err := recipe.EnsureVersion(version); err != nil {
-		return err
-	}
-
-	if err := recipe.LoadConfig(); err != nil {
-		return err
-	}
-	if err := lint.LintForErrors(recipe); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// mergeAbraShEnv merges abra.sh env vars into the app env vars.
-func mergeAbraShEnv(recipeName string, env config.AppEnv) error {
-	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, recipeName, "abra.sh")
-	abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
-	if err != nil {
-		return err
-	}
-
-	for k, v := range abraShEnv {
-		logrus.Debugf("read v:%s k: %s", v, k)
-		env[k] = v
-	}
-
-	return nil
-}
-
-// createDeployConfig merges and enriches the compose config for the deployment.
-func createDeployConfig(recipeName string, stackName string, env config.AppEnv) (*composetypes.Config, stack.Deploy, error) {
-	env["STACK_NAME"] = stackName
-
-	deployOpts := stack.Deploy{
-		Namespace:    stackName,
-		Prune:        false,
-		ResolveImage: stack.ResolveImageAlways,
-	}
-
-	composeFiles, err := config.GetComposeFiles(recipeName, env)
-	if err != nil {
-		return nil, deployOpts, err
-	}
-
-	deployOpts.Composefiles = composeFiles
-	compose, err := config.GetAppComposeConfig(stackName, deployOpts, env)
-	if err != nil {
-		return nil, deployOpts, err
-	}
-
-	config.ExposeAllEnv(stackName, compose, env)
-
-	// after the upgrade the deployment won't be in chaos state anymore
-	config.SetChaosLabel(compose, stackName, false)
-	config.SetRecipeLabel(compose, stackName, recipeName)
-	config.SetUpdateLabel(compose, stackName, env)
-
-	return compose, deployOpts, nil
-}
-
-// tryUpgrade performs the upgrade if all the requirements are fulfilled.
-func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error {
-	if recipeName == "" {
-		logrus.Debugf("don't update %s due to missing recipe name", stackName)
-		return nil
-	}
-
-	chaos, err := getBoolLabel(cl, stackName, "chaos")
-	if err != nil {
-		return err
-	}
-
-	if chaos && !internal.Chaos {
-		logrus.Debugf("don't update %s due to chaos deployment", stackName)
-		return nil
-	}
-
-	updatesEnabled, err := getBoolLabel(cl, stackName, "autoupdate")
-	if err != nil {
-		return err
-	}
-
-	if !updatesEnabled {
-		logrus.Debugf("don't update %s due to disabled auto updates or missing ENABLE_AUTO_UPDATE env", stackName)
-		return nil
-	}
-
-	upgradeVersion, err := getLatestUpgrade(cl, stackName, recipeName)
-	if err != nil {
-		return err
-	}
-
-	if upgradeVersion == "" {
-		logrus.Debugf("don't update %s due to no new version", stackName)
-		return nil
-	}
-
-	err = upgrade(cl, stackName, recipeName, upgradeVersion)
-
-	return err
-}
-
-// upgrade performs all necessary steps to upgrade an app.
-func upgrade(cl *dockerclient.Client, stackName, recipeName,
-	upgradeVersion string) error {
-	env, err := getEnv(cl, stackName)
-	if err != nil {
-		return err
-	}
-
-	app := config.App{
-		Name:   stackName,
-		Recipe: recipeName,
-		Server: SERVER,
-		Env:    env,
-	}
-
-	recipe, err := recipe.Get(recipeName)
-	if err != nil {
-		return err
-	}
-
-	if err = processRecipeRepoVersion(recipe, upgradeVersion); err != nil {
-		return err
-	}
-
-	if err = mergeAbraShEnv(recipeName, app.Env); err != nil {
-		return err
-	}
-
-	compose, deployOpts, err := createDeployConfig(recipeName, stackName, app.Env)
-	if err != nil {
-		return err
-	}
-
-	logrus.Infof("upgrade %s (%s) to version %s", stackName, recipeName, upgradeVersion)
-
-	err = stack.RunDeploy(cl, deployOpts, compose, stackName, true)
-
-	return err
-}
-
-func newAbraApp(version, commit string) *cli.App {
-	app := &cli.App{
-		Name: "kadabra",
-		Usage: `The Co-op Cloud auto-updater
-    ____                           ____ _                 _
-   / ___|___         ___  _ __    / ___| | ___  _   _  __| |
-  | |   / _ \ _____ / _ \| '_ \  | |   | |/ _ \| | | |/ _' |
-  | |__| (_) |_____| (_) | |_) | | |___| | (_) | |_| | (_| |
-   \____\___/       \___/| .__/   \____|_|\___/ \__,_|\__,_|
-                         |_|
-`,
-		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
-		Commands: []cli.Command{
-			Notify,
-			UpgradeApp,
-		},
-	}
-
-	app.Before = func(c *cli.Context) error {
-		logrus.Debugf("kadabra version %s, commit %s", version, commit)
-		return nil
-	}
-
-	return app
-}
-
-// RunApp runs CLI abra app.
-func RunApp(version, commit string) {
-	app := newAbraApp(version, commit)
-
-	if err := app.Run(os.Args); err != nil {
-		logrus.Fatal(err)
-	}
-}

cli/upgrade.go

@@ -0,0 +1,64 @@
+// Package cli provides the interface for the command-line.
+package cli
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/spf13/cobra"
+)
+
+// translators: `abra upgrade` aliases. use a comma separated list of aliases with
+// no spaces in between
+var upgradeAliases = i18n.G("u")
+
+// UpgradeCommand upgrades abra in-place.
+var UpgradeCommand = &cobra.Command{
+	// translators: `upgrade` command
+	Use:     i18n.G("upgrade [flags]"),
+	Aliases: strings.Split(upgradeAliases, ","),
+	// translators: Short description for `upgrade` command
+	Short: i18n.G("Upgrade abra"),
+	Long: i18n.G(`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: i18n.G("  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(i18n.G("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,
+		i18n.G("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)
 }

cmd/kadabra/main.go

@@ -1,23 +0,0 @@
-// Package main provides the command-line entrypoint.
-package main
-
-import (
-	"coopcloud.tech/abra/cli/updater"
-)
-
-// Version is the current version of Kadabra.
-var Version string
-
-// Commit is the current git commit of Kadabra.
-var Commit string
-
-func main() {
-	if Version == "" {
-		Version = "dev"
-	}
-	if Commit == "" {
-		Commit = "       "
-	}
-
-	updater.RunApp(Version, Commit)
-}

go.mod

@@ -1,133 +1,162 @@
 module coopcloud.tech/abra
 
-go 1.21
+go 1.24.0
+
+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/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4
-	github.com/distribution/distribution v2.8.3+incompatible
-	github.com/docker/cli v26.1.4+incompatible
-	github.com/docker/docker v26.1.4+incompatible
+	github.com/charmbracelet/bubbles v0.21.0
+	github.com/charmbracelet/bubbletea v1.3.10
+	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 v28.4.0+incompatible
+	github.com/docker/docker v28.4.0+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/olekukonko/tablewriter v0.0.5
+	github.com/evertras/bubble-table v0.19.2
+	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/sirupsen/logrus v1.9.3
-	gotest.tools/v3 v3.5.1
+	github.com/schollz/progressbar/v3 v3.18.0
+	golang.org/x/term v0.35.0
+	gopkg.in/yaml.v3 v3.0.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/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/atotto/clipboard v0.1.4 // 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/cloudflare/circl v1.3.9 // indirect
+	github.com/charmbracelet/colorprofile v0.3.2 // indirect
+	github.com/charmbracelet/x/ansi v0.10.2 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.13 // indirect
+	github.com/charmbracelet/x/term v0.2.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.2.0 // 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/cpuguy83/go-md2man/v2 v2.0.4 // 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.5.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/distribution/reference v0.6.0 // indirect
-	github.com/docker/distribution v2.7.1+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/distribution v2.8.3+incompatible // 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/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-logr/logr v1.4.2 // 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.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // indirect
+	github.com/go-viper/mapstructure/v2 v2.4.0 // 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.27.2 // 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/mattn/go-colorable v0.1.13 // indirect
+	github.com/kevinburke/ssh_config v1.4.0 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.3.0 // 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.19 // 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/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/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/reflow v0.3.0 // 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/pjbgf/sha1cd v0.5.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.54.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/prometheus/client_model v0.6.2 // indirect
+	github.com/prometheus/common v0.66.1 // 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/skeema/knownhosts v1.2.2 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
+	github.com/skeema/knownhosts v1.3.1 // indirect
+	github.com/spf13/pflag v1.0.10 // 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.52.0 // indirect
-	go.opentelemetry.io/otel v1.27.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.27.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.27.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0 // indirect
-	go.opentelemetry.io/otel/metric v1.27.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.27.0 // indirect
-	go.opentelemetry.io/otel/sdk/metric v1.27.0 // indirect
-	go.opentelemetry.io/otel/trace v1.27.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
-	golang.org/x/crypto v0.24.0 // indirect
-	golang.org/x/net v0.26.0 // indirect
-	golang.org/x/sync v0.7.0 // indirect
-	golang.org/x/term v0.21.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-20240617180043-68d350f18fd4 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240617180043-68d350f18fd4 // indirect
-	google.golang.org/grpc v1.64.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.2.1 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.8.0 // indirect
+	go.yaml.in/yaml/v2 v2.4.3 // indirect
+	golang.org/x/crypto v0.42.0 // indirect
+	golang.org/x/exp v0.0.0-20250911091902-df9299821621 // indirect
+	golang.org/x/net v0.44.0 // indirect
+	golang.org/x/text v0.29.0 // indirect
+	golang.org/x/time v0.13.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250929231259-57b25ae835d4 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 // indirect
+	google.golang.org/grpc v1.75.1 // indirect
+	google.golang.org/protobuf v1.36.9 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
 require (
-	github.com/buger/goterm v1.0.4
-	github.com/containerd/containerd v1.7.18 // 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/facebookgo/stack v0.0.0-20160209184415-751773369052 // 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.2 // indirect
+	github.com/sergi/go-diff v1.4.0 // indirect
+	github.com/spf13/cobra v1.10.1
+	github.com/stretchr/testify v1.11.1
 	github.com/theupdateframework/notary v0.7.0 // indirect
-	github.com/urfave/cli v1.22.15
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
-	golang.org/x/sys v0.21.0
+	golang.org/x/sys v0.36.0
 )

go.sum

@@ -22,21 +22,21 @@ cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIA
 cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
 cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
 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-20250818180036-0ec1b205b5ca h1:gSD53tBAsbIGq4SnFfq+mEep6foekQ2a5ea7b38qkm0=
+coopcloud.tech/tagcmp v0.0.0-20250818180036-0ec1b205b5ca/go.mod h1:ESVm0wQKcbcFi06jItF3rI7enf4Jt2PvbkWpDDHk1DQ=
+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=
-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=
+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-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=
@@ -49,12 +49,9 @@ github.com/Azure/go-autorest/logger v0.2.0/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZ
 github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/toml v1.0.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
-github.com/BurntSushi/toml v1.3.2/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/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4 h1:vdT7QwBhJJEVNFMBNhRSFDRCB6O16T28VhvqRgqFyn8=
-github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4/go.mod h1:SvXOG8ElV28oAiG9zv91SDe5+9PfIr7PPccpr8YyXNs=
 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=
 github.com/Microsoft/go-winio v0.4.15-0.20190919025122-fc70bd9a86b5/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw=
@@ -76,22 +73,19 @@ github.com/Microsoft/hcsshim v0.8.15/go.mod h1:x38A4YbHbdxJtc0sF6oIz+RG0npwSCAvn
 github.com/Microsoft/hcsshim v0.8.16/go.mod h1:o5/SZqmR7x9JNKsW3pu+nqHm0MF8vbA+VxGOoXdC600=
 github.com/Microsoft/hcsshim v0.8.21/go.mod h1:+w2gRZ5ReXQhFOrvSQeNfhrYB/dg3oDwTOcER2fw4I4=
 github.com/Microsoft/hcsshim v0.9.2/go.mod h1:7pLA8lDk46WKDWlVsENo92gC0XFa8rbKfyFRBqxEbCc=
-github.com/Microsoft/hcsshim v0.11.5 h1:haEcLNpj9Ka1gd3B3tAEs9CpE0c+1IhoL59w/exYU38=
-github.com/Microsoft/hcsshim v0.11.5/go.mod h1:MV8xMfmECjl5HdO7U/3/hFVnkmSBjAjmA09d4bExKcU=
 github.com/Microsoft/hcsshim/test v0.0.0-20201218223536-d3e5debf77da/go.mod h1:5hlzMzRKMLyo42nCZ9oml8AdTlq/0cvIaBv6tK1RehU=
 github.com/Microsoft/hcsshim/test v0.0.0-20210227013316-43a75bb4edd3/go.mod h1:mw7qgWloBUl75W/gVH3cQszUg1+gUITj7D6NY7ywVnY=
 github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
 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.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=
 github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
 github.com/Shopify/logrus-bugsnag v0.0.0-20170309145241-6dbc35f2c30d/go.mod h1:HI8ITrYtUY+O+ZhtlqUnD8+KwNPOyugEhfP9fdUIaEQ=
-github.com/Shopify/logrus-bugsnag v0.0.0-20171204204709-577dee27f20d h1:UrqY+r/OJnIp5u0s1SbQ8dVfLCZJsnvazdBP5hS4iRs=
 github.com/Shopify/logrus-bugsnag v0.0.0-20171204204709-577dee27f20d/go.mod h1:HI8ITrYtUY+O+ZhtlqUnD8+KwNPOyugEhfP9fdUIaEQ=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
@@ -105,7 +99,13 @@ github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
+github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
+github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
 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=
@@ -120,28 +120,44 @@ github.com/blang/semver v3.1.0+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnweb
 github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
 github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
 github.com/bshuster-repo/logrus-logstash-hook v0.4.1/go.mod h1:zsTqEiSzDgAa/8GZR7E1qaXrhYNDKBYy5/dWPTIflbk=
-github.com/buger/goterm v1.0.4 h1:Z9YvGmOih81P0FbVtEYTFF6YsSgxSUKEhf/f9bTMXbY=
-github.com/buger/goterm v1.0.4/go.mod h1:HiFWV3xnkolgrBV3mY8m0X0Pumt4zg4QhbdOzQtB8tE=
 github.com/buger/jsonparser v0.0.0-20180808090653-f4dd9f5a6b44/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s=
 github.com/bugsnag/bugsnag-go v0.0.0-20141110184014-b1d153021fcd/go.mod h1:2oa8nejYd4cQ/b0hMIopN0lCRxU0bueqREvZLWFrtK8=
-github.com/bugsnag/bugsnag-go v1.0.5-0.20150529004307-13fd6b8acda0 h1:s7+5BfS4WFJoVF9pnB8kBk03S7pZXRdKamnV0FOl5Sc=
 github.com/bugsnag/bugsnag-go v1.0.5-0.20150529004307-13fd6b8acda0/go.mod h1:2oa8nejYd4cQ/b0hMIopN0lCRxU0bueqREvZLWFrtK8=
-github.com/bugsnag/osext v0.0.0-20130617224835-0dd3f918b21b h1:otBG+dV+YK+Soembjv71DPz3uX/V/6MMlSyD9JBQ6kQ=
 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/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/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
+github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
+github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=
+github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=
+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.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
+github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
+github.com/charmbracelet/x/ansi v0.10.2 h1:ith2ArZS0CJG30cIUfID1LXN7ZFXRCww6RUvAPA+Pzw=
+github.com/charmbracelet/x/ansi v0.10.2/go.mod h1:HbLdJjQH4UH4AqA2HpRWuWNluRE6zxJH/yteYEYCFa8=
+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-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ=
+github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/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=
@@ -152,11 +168,11 @@ github.com/cilium/ebpf v0.4.0/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJ
 github.com/cilium/ebpf v0.6.2/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJXRs=
 github.com/cilium/ebpf v0.7.0/go.mod h1:/oI2+1shJiTGAMgl6/RgJr36Eo1jzrRcAWbcXO2usCA=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cloudflare/cfssl v0.0.0-20180223231731-4e2dcbde5004 h1:lkAMpLVBDaj17e85keuznYcH5rqI438v41pKcBl4ZxQ=
+github.com/clipperhouse/uax29/v2 v2.2.0 h1:ChwIKnQN3kcZteTXMgb1wztSgaU+ZemkgWdohwgs8tY=
+github.com/clipperhouse/uax29/v2 v2.2.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
 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.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=
@@ -195,8 +211,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.18 h1:jqjZTQNfXGoEaZdW1WwPU0RqSn1Bm2Ay/KJPUuO8nao=
-github.com/containerd/containerd v1.7.18/go.mod h1:IYEk9/IO6wAPUz2bCMVUbsfXjzw5UNP5fLz4PsUygQ4=
 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=
@@ -204,6 +218,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=
@@ -226,6 +244,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=
@@ -272,8 +292,9 @@ 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 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
-github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+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 +302,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.5.0 h1:hIAhkRBMQ8nIeuVwcAoymp7MY4oherZdAxD+m0u9zaw=
+github.com/cyphar/filepath-securejoin v0.5.0/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=
@@ -297,29 +318,28 @@ github.com/denverdino/aliyungo v0.0.0-20190125010748-a747050bb1ba/go.mod h1:dV8l
 github.com/dgrijalva/jwt-go v0.0.0-20170104182250-a601269ab70c/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/distribution/distribution v2.8.3+incompatible h1:RlpEXBLq/WPXYvBYMDAmBX/SnhD67qwtvW/DzKc8pAo=
-github.com/distribution/distribution v2.8.3+incompatible/go.mod h1:EgLm2NgWtdKgzF9NpMzUKgzmR7AMmb0VQi2B+ZzDRjc=
 github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
 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 v26.1.4+incompatible h1:I8PHdc0MtxEADqYJZvhBrW9bo8gawKwwenxRM7/rLu8=
-github.com/docker/cli v26.1.4+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v28.4.0+incompatible h1:RBcf3Kjw2pMtwui5V0DIMdyeab8glEw5QY0UUU4C9kY=
+github.com/docker/cli v28.4.0+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 h1:a5mlkVzth6W5A4fOsS3D2EO5BUmsJpcB+cRlLU7cSug=
 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 v26.1.4+incompatible h1:vuTpXDuoga+Z38m1OZHzl7NKisKWaWlhjQk7IDPSLsU=
-github.com/docker/docker v26.1.4+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v28.4.0+incompatible h1:KVC7bz5zJY/4AZe/78BIvCnPsLaC9T/zh72xnlrTTOk=
+github.com/docker/docker v28.4.0+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=
@@ -337,8 +357,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=
@@ -349,10 +369,12 @@ 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/facebookgo/stack v0.0.0-20160209184415-751773369052 h1:JWuenKqqX8nojtoVVWjGfOF9635RETekkoH6Cc9SX0A=
-github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg=
+github.com/evertras/bubble-table v0.19.2 h1:u77oiM6JlRR+CvS5FZc3Hz+J6iEsvEDcR5kO8OFb1Yw=
+github.com/evertras/bubble-table v0.19.2/go.mod h1:ifHujS1YxwnYSOgcR2+m3GnJ84f7CVU/4kUOxUCjEbQ=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
 github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
@@ -362,8 +384,6 @@ github.com/form3tech-oss/jwt-go v3.2.2+incompatible/go.mod h1:pbq4aXjuKjdthFRnoD
 github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
-github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
 github.com/fullsailor/pkcs7 v0.0.0-20190404230743-d7302db945fa/go.mod h1:KnogPXtdwXqoenmZCw6S+25EAm2MkxbG0deNDu4cbSA=
 github.com/fvbommel/sortorder v1.1.0 h1:fUmoe+HLsBTctBDoaBwpQo5N+nrCp8g/BjKb/6ZQmYw=
 github.com/fvbommel/sortorder v1.1.0/go.mod h1:uk88iVf1ovNn1iLfgUVU2F9o5eO30ui720w+kxuqRs0=
@@ -371,16 +391,16 @@ 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.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=
@@ -389,11 +409,13 @@ github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
+github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
 github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
 github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU=
 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=
@@ -407,9 +429,10 @@ github.com/go-openapi/spec v0.19.3/go.mod h1:FpwSN1ksY1eteniUU7X0N/BgJ7a4WvBFVA8
 github.com/go-openapi/swag v0.0.0-20160704191624-1d0bd113de87/go.mod h1:DXUve3Dpr1UfpPtxFw+EFuQ41HhCWZfha5jSVRG7C7I=
 github.com/go-openapi/swag v0.19.2/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
 github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
-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.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=
@@ -424,7 +447,6 @@ github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zV
 github.com/gogo/protobuf v1.2.2-0.20190723190241-65acae22fc9d/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
 github.com/gogo/protobuf v1.3.0/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
 github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
-github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -433,8 +455,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=
@@ -461,7 +483,6 @@ github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/certificate-transparency-go v1.0.10-0.20180222191210-5ab67e519c93 h1:jc2UWq7CbdszqeH6qu1ougXMIUBfSy8Pbh/anURYbGI=
 github.com/google/certificate-transparency-go v1.0.10-0.20180222191210-5ab67e519c93/go.mod h1:QeJfpSbVSfYc7RgB3gJFj9cbuQMMchQxrWXz8Ruopmg=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
@@ -473,8 +494,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=
@@ -493,6 +514,8 @@ github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
 github.com/googleapis/gnostic v0.4.1/go.mod h1:LRhVm6pbyptWbWbuZ38d1eyptfvIytN3ir6b65WBswg=
@@ -513,9 +536,8 @@ github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgf
 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/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/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 h1:8Tjv8EJ+pM1xP8mK6egEbD1OgnVTyacbefKhmbLhIhU=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2/go.mod h1:pkJQ2tZHJ0aFOVEEot6oZmaVEZcRme73eIFmhiVuRWs=
 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=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
@@ -526,11 +548,10 @@ github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVH
 github.com/hashicorp/go-multierror v0.0.0-20161216184304-ed905158d874/go.mod h1:JMRHfdO9jKNzS/+BTlxCjKNQHg/jZAft8U7LloJvN7I=
 github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
 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=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec h1:qv2VnGeEQHchGaZ/u7lxST/RaJw+cv273q79D81Xbog=
 github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec/go.mod h1:Q48J4R4DvxnHolD5P8pOtXigYlRuPLGl6moFx3ulM68=
@@ -547,9 +568,7 @@ github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLf
 github.com/j-keck/arping v0.0.0-20160618110441-2cf9dc699c56/go.mod h1:ymszkNOg6tORTn+6F6j+Jc8TOr5osrynvN6ivFWZ2GA=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
-github.com/jinzhu/gorm v0.0.0-20170222002820-5409931a1bb8 h1:CZkYfurY6KGhVtlalI4QwQ6T0Cu6iuY3e0x5RLu96WE=
 github.com/jinzhu/gorm v0.0.0-20170222002820-5409931a1bb8/go.mod h1:Vla75njaFJ8clLU1W44h34PjIkijhjHIYnZxMqCdxqo=
-github.com/jinzhu/inflection v0.0.0-20170102125226-1c35d901db3d h1:jRQLvyVGL+iVtDElaEIDdKwpPqUIZJfzkNLV34htpEc=
 github.com/jinzhu/inflection v0.0.0-20170102125226-1c35d901db3d/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.1/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
@@ -565,11 +584,10 @@ 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=
-github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
+github.com/kevinburke/ssh_config v1.4.0 h1:6xxtP5bZ2E4NF5tuQulISpTO2z8XbtH8cg1PWkxoFkQ=
+github.com/kevinburke/ssh_config v1.4.0/go.mod h1:q2RIzfka+BXARoNexmF9gkxEX7DmvbW9P4hIVx2Kg4M=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
@@ -577,8 +595,10 @@ 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/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
+github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 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=
@@ -594,10 +614,15 @@ 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.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
+github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/magiconair/properties v1.5.3/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
-github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
@@ -606,17 +631,18 @@ 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.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-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.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
+github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
+github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
 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=
@@ -637,29 +663,33 @@ github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v0.0.0-20150613213606-2caf8efc9366/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
-github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 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.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=
@@ -668,7 +698,16 @@ 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/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/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
+github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
+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=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
@@ -677,8 +716,6 @@ github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLA
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/onsi/ginkgo v0.0.0-20151202141238-7f8ab55aaf3b/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
@@ -695,8 +732,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=
@@ -705,8 +742,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=
@@ -729,15 +766,12 @@ github.com/opencontainers/selinux v1.6.0/go.mod h1:VVGKuOLlE7v4PJyT6h7mNWvq1rzqi
 github.com/opencontainers/selinux v1.8.0/go.mod h1:RScLhm78qiWa2gbVCcGkC7tCGdgk3ogry1nUQF8Evvo=
 github.com/opencontainers/selinux v1.8.2/go.mod h1:MUIHuUEvKB1wtJjQdOyYRgOnLD2xAPP8dBsCoU0KuF8=
 github.com/opencontainers/selinux v1.10.0/go.mod h1:2i0OySw99QjzBBQByd1Gr9gSjvuho1lHsJxIJ3gGbJI=
-github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pelletier/go-toml v1.8.1/go.mod h1:T2/BmBdy8dvIRq1a/8aqjN41wvWlN4lrapLU/GW4pbc=
-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.5.0 h1:a+UkboSi1znleCDUNT3M5YxjOnN1fz2FhN48FlwCxs0=
+github.com/pjbgf/sha1cd v0.5.0/go.mod h1:lhpGlyHLpQZoxMv8HcgXvZEhcGs0PG/vsZnEJ7H0iCM=
 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=
@@ -753,23 +787,23 @@ 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.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
+github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
 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=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 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.54.0 h1:ZlZy0BgJhTwVZUn7dLOkwCZHUkrAqd3WYtcFCWnM1D8=
-github.com/prometheus/common v0.54.0/go.mod h1:/TQgMJP5CuVYveyT7n/0Ix8yLNNXy9yRSkhnLTHPDIQ=
+github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
+github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
 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=
@@ -781,29 +815,30 @@ github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+Gx
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 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.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 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/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=
@@ -815,45 +850,40 @@ 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=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
-github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc=
 github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
 github.com/spf13/cast v0.0.0-20150508191742-4d07383ffe94/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg=
-github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
 github.com/spf13/cobra v0.0.1/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
 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.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
+github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
 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=
 github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.0/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 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.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.10/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=
 github.com/stefanberger/go-pkcs11uri v0.0.0-20201008174630-78d3cae3a980/go.mod h1:AO3tvPzVZ/ayst6UlUKUv6rcPQInYe3IknH3jYhAKu8=
 github.com/stretchr/objx v0.0.0-20180129172003-8a3f7159479f/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v0.0.0-20180303142811-b89eecf5ca5d/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
@@ -861,11 +891,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.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-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.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 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=
@@ -883,8 +910,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 v1.22.15 h1:nuqt+pdC/KqswQKhETJjo7pvn/k4xMUxgW6liI7XpnM=
-github.com/urfave/cli v1.22.15/go.mod h1:wSan1hmo5zeyLGBjRJbzRTNk8gwoYa2B9n4q9dmRIc0=
 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=
@@ -905,6 +930,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=
@@ -923,35 +950,39 @@ 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.52.0 h1:9l89oX4ba9kHbBol3Xin3leYJ+252h0zszDtBwyKe2A=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.52.0/go.mod h1:XLZfZboOJWHNKUv7eH0inh0E9VV6eWDFB/9yJyTLPp0=
-go.opentelemetry.io/otel v1.27.0 h1:9BZoF3yMK/O1AafMiQTVu0YDj5Ea4hPhxCs7sGva+cg=
-go.opentelemetry.io/otel v1.27.0/go.mod h1:DMpAK8fzYRzs+bi3rS5REupisuqTheUlSZJ1WnZaPAQ=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.27.0 h1:bFgvUr3/O4PHj3VQcFEuYKvRZJX1SJDQ+11JXuSB3/w=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.27.0/go.mod h1:xJntEd2KL6Qdg5lwp97HMLQDVeAhrYxmzFseAMDPQ8I=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.27.0 h1:R9DE4kQ4k+YtfLI2ULwX82VtNQ2J8yZmA7ZIF/D+7Mc=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.27.0/go.mod h1:OQFyQVrDlbe+R7xrEyDr/2Wr67Ol0hRUgsfA+V5A95s=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0 h1:qFffATk0X+HD+f1Z8lswGiOQYKHRlzfmdJm0wEaVrFA=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0/go.mod h1:MOiCmryaYtc+V0Ei+Tx9o5S1ZjA7kzLucuVuyzBZloQ=
+go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
+go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0 h1:RbKq8BG0FI8OiXhBfcRtqqHcZcka+gU3cskNuf05R18=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0/go.mod h1:h06DGIukJOevXaj/xrNjhi/2098RZzcLTbc0jDAUbsg=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0 h1:vl9obrcoWVKp/lwl8tRE33853I8Xru9HFbw/skNeLs8=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0/go.mod h1:GAXRxmLJcVM3u22IjTg74zWBrRCKq8BnOqUVLodpcpw=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 h1:GqRJVj7UmLjCVyVJ3ZFLdPRmhDUp2zFmQe3RHIOsw24=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0/go.mod h1:ri3aaHSmCTVYu2AWv44YMauwAQc0aqI9gHKIcSbI1pU=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0 h1:lwI4Dc5leUqENgGuQImwLo4WnuXFPetmPpkLi2IrX54=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0/go.mod h1:Kz/oCE7z5wuyhPxsXDuaPteSWqjSBD5YaSdbxZYGbGk=
 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.27.0 h1:hvj3vdEKyeCi4YaYfNjv2NUje8FqKqUY8IlF0FxV/ik=
-go.opentelemetry.io/otel/metric v1.27.0/go.mod h1:mVFgmRlhljgBiuk/MP/oKylr4hs85GZAylncepAX/ak=
-go.opentelemetry.io/otel/sdk v1.27.0 h1:mlk+/Y1gLPLn84U4tI8d3GNJmGT/eXe3ZuOXN9kTWmI=
-go.opentelemetry.io/otel/sdk v1.27.0/go.mod h1:Ha9vbLwJE6W86YstIywK2xFfPjbWlCuwPtMkKdz/Y4A=
-go.opentelemetry.io/otel/sdk/metric v1.27.0 h1:5uGNOlpXi+Hbo/DRoI31BSb1v+OGcpv2NemcCrOL8gI=
-go.opentelemetry.io/otel/sdk/metric v1.27.0/go.mod h1:we7jJVrYN2kh3mVBlswtPU22K0SA+769l93J6bsyvqw=
-go.opentelemetry.io/otel/trace v1.27.0 h1:IqYb813p7cmbHk0a5y6pD5JPakbVfftRXABGt5/Rscw=
-go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39SuvvstaLBl+l4=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 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.8.0 h1:fRAZQDcAFHySxpJ1TwlA1cJ4tvcrw7nXl9xWWC8N5CE=
+go.opentelemetry.io/proto/otlp v1.8.0/go.mod h1:tIeYOeNBU4cvmPqpaji1P+KbB4Oloai8wN4rWzRrFF0=
 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=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0=
+go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8=
 golang.org/x/crypto v0.0.0-20171113213409-9f005a07e0d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181009213950-7c1a557ab941/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
@@ -970,10 +1001,8 @@ 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.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
 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=
@@ -984,6 +1013,8 @@ 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-20250911091902-df9299821621 h1:2id6c1/gto0kaHYyrixvknJ8tUK/Qs5IsmBtrc+FtgU=
+golang.org/x/exp v0.0.0-20250911091902-df9299821621/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk=
 golang.org/x/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 +1037,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 +1078,8 @@ 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.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
+golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
+golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
 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 +1097,6 @@ 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/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=
@@ -1137,12 +1161,12 @@ golang.org/x/sys v0.0.0-20201202213521-69691e467435/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210331175145-43e1dd70ce54/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 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=
@@ -1150,23 +1174,14 @@ 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.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.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
+golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 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.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
-golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
+golang.org/x/term v0.35.0 h1:bZBVKBudEyhRcajGcNc3jIfWPqV4y/Kt2XcoigOWtDQ=
+golang.org/x/term v0.35.0/go.mod h1:TPGtkTLesOwf2DE8CgVYiZinHAOuy5AYUYT1lENIZnA=
 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=
@@ -1176,18 +1191,16 @@ 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.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
 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.13.0 h1:eUlYslOIt32DgYD6utsuUeHs4d7AsEYLuIAdg7FlYgI=
+golang.org/x/time v0.13.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
 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=
@@ -1233,11 +1246,12 @@ 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=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
+gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
 google.golang.org/api v0.0.0-20160322025152-9bf6e6e569ff/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
 google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
@@ -1282,10 +1296,10 @@ 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-20240617180043-68d350f18fd4 h1:MuYw1wJzT+ZkybKfaOXKp5hJiZDn2iHaXRw0mRYdHSc=
-google.golang.org/genproto/googleapis/api v0.0.0-20240617180043-68d350f18fd4/go.mod h1:px9SlOOZBg1wM1zdnr8jEL4CNGUBZ+ZKYtNPApNQc4c=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240617180043-68d350f18fd4 h1:Di6ANFilr+S60a4S61ZM00vLdw0IrQOSMS2/6mrnOU0=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240617180043-68d350f18fd4/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
+google.golang.org/genproto/googleapis/api v0.0.0-20250929231259-57b25ae835d4 h1:8XJ4pajGwOlasW+L13MnEGA8W4115jJySQtVfS2/IBU=
+google.golang.org/genproto/googleapis/api v0.0.0-20250929231259-57b25ae835d4/go.mod h1:NnuHhy+bxcg30o7FnVAZbXsPHUDQ9qKWAQKCD7VxFtk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 h1:i8QOKZfYg6AbGVZzUAY3LrNWCKF8O6zFisU9Wl9RER4=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4/go.mod h1:HSkG/KdJWusxU1F6CNrwNDjBMgisKxGnc5dAZfT0mjQ=
 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=
@@ -1305,8 +1319,8 @@ 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.64.0 h1:KH3VH9y/MgNQg1dE7b3XfVK0GsPSIzJwdF617gUSbvY=
-google.golang.org/grpc v1.64.0/go.mod h1:oxjF8E3FBnjp+/gVFYdWacaLDx9na1aqy9oovLpxQYg=
+google.golang.org/grpc v1.75.1 h1:/ODCNEuf9VghjgO3rqLcfg8fiOP0nSluljWFlDxELLI=
+google.golang.org/grpc v1.75.1/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
 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=
@@ -1320,11 +1334,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.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw=
+google.golang.org/protobuf v1.36.9/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
 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=
 gopkg.in/cenkalti/backoff.v2 v2.2.1/go.mod h1:S0QdOvT2AlerfSBkp0O+dk+bbIMaNbEmVk876gPCthU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20141024133853-64131543e789/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -1340,7 +1353,6 @@ gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKW
 gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
 gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
-gopkg.in/rethinkdb/rethinkdb-go.v6 v6.2.1 h1:d4KQkxAaAiRY2h5Zqis161Pv91A37uZyJOx73duwUwM=
 gopkg.in/rethinkdb/rethinkdb-go.v6 v6.2.1/go.mod h1:WbjuEoo1oadwzQ4apSDU+JTvmllEHtsNHS6y7vFc7iw=
 gopkg.in/square/go-jose.v2 v2.2.2/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
 gopkg.in/square/go-jose.v2 v2.3.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
@@ -1364,8 +1376,8 @@ gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 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=

pkg/app/app.go

@@ -1,42 +1,687 @@
 package app
 
 import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"regexp"
+	"sort"
 	"strings"
 
+	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
-	"github.com/sirupsen/logrus"
+	"coopcloud.tech/abra/pkg/envfile"
+	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/upstream/convert"
+	"coopcloud.tech/abra/pkg/upstream/stack"
+
+	"coopcloud.tech/abra/pkg/log"
+	loader "coopcloud.tech/abra/pkg/upstream/stack"
+	composetypes "github.com/docker/cli/cli/compose/types"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/schollz/progressbar/v3"
 )
 
 // Get retrieves an app
-func Get(appName string) (config.App, error) {
-	files, err := config.LoadAppFiles("")
+func Get(appName string) (App, error) {
+	files, err := LoadAppFiles("")
 	if err != nil {
-		return config.App{}, err
+		return App{}, err
 	}
 
-	app, err := config.GetApp(files, appName)
+	app, err := GetApp(files, appName)
 	if err != nil {
-		return config.App{}, err
+		return App{}, err
 	}
 
-	logrus.Debugf("retrieved %s for %s", app, appName)
+	log.Debug(i18n.G("loaded app %s: %s", appName, app))
 
 	return app, nil
 }
 
-// deployedServiceSpec represents a deployed service of an app.
-type deployedServiceSpec struct {
-	Name    string
-	Version string
+// GetApp loads an apps settings, reading it from file, in preparation to use
+// it. It should only be used when ready to use the env file to keep IO
+// operations down.
+func GetApp(apps AppFiles, name AppName) (App, error) {
+	appFile, exists := apps[name]
+	if !exists {
+		return App{}, errors.New(i18n.G("cannot find app with name %s", name))
+	}
+
+	app, err := ReadAppEnvFile(appFile, name)
+	if err != nil {
+		return App{}, err
+	}
+
+	return app, nil
 }
 
-// VersionSpec represents a deployed app and associated metadata.
-type VersionSpec map[string]deployedServiceSpec
+// GetApps returns a slice of Apps with their env files read from a given
+// slice of AppFiles.
+func GetApps(appFiles AppFiles, recipeFilter string) ([]App, error) {
+	var apps []App
 
-// ParseServiceName parses a $STACK_NAME_$SERVICE_NAME service label.
-func ParseServiceName(label string) string {
-	idx := strings.LastIndex(label, "_")
-	serviceName := label[idx+1:]
-	logrus.Debugf("parsed %s as service name from %s", serviceName, label)
-	return serviceName
+	for name := range appFiles {
+		app, err := GetApp(appFiles, name)
+		if err != nil {
+			return nil, err
+		}
+
+		if recipeFilter != "" {
+			if app.Recipe.Name == recipeFilter {
+				apps = append(apps, app)
+			}
+		} else {
+			apps = append(apps, app)
+		}
+	}
+
+	return apps, nil
+}
+
+// App reprents an app with its env file read into memory
+type App struct {
+	Name   AppName
+	Recipe recipe.Recipe
+	Domain string
+	Env    envfile.AppEnv
+	Server string
+	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
+type AppName = string
+
+// AppFile represents app env files on disk without reading the contents
+type AppFile struct {
+	Path   string
+	Server string
+}
+
+// AppFiles is a slice of appfiles
+type AppFiles map[AppName]AppFile
+
+// See documentation of config.StackName
+func (a App) StackName() string {
+	if _, exists := a.Env["STACK_NAME"]; exists {
+		return a.Env["STACK_NAME"]
+	}
+
+	stackName := StackName(a.Name)
+
+	a.Env["STACK_NAME"] = stackName
+
+	return stackName
+}
+
+// StackName gets whatever the docker safe (uses the right delimiting
+// character, e.g. "_") stack name is for the app. In general, you don't want
+// to use this to show anything to end-users, you want use a.Name instead.
+func StackName(appName string) string {
+	stackName := SanitiseAppName(appName)
+
+	if len(stackName) > config.MAX_SANITISED_APP_NAME_LENGTH {
+		log.Debug(i18n.G("trimming %s to %s to avoid runtime limits", stackName, stackName[:config.MAX_SANITISED_APP_NAME_LENGTH]))
+		stackName = stackName[:config.MAX_SANITISED_APP_NAME_LENGTH]
+	}
+
+	return stackName
+}
+
+// Filters retrieves app filters for querying the container runtime. By default
+// it filters on all services in the app. It is also possible to pass an
+// otional list of service names, which get filtered instead.
+//
+// Due to upstream issues, filtering works different depending on what you're
+// querying. So, for example, secrets don't work with regex! The caller needs
+// to implement their own validation that the right secrets are matched. In
+// order to handle these cases, we provide the `appendServiceNames` /
+// `exactMatch` modifiers.
+func (a App) Filters(appendServiceNames, exactMatch bool, services ...string) (filters.Args, error) {
+	filters := filters.NewArgs()
+	if len(services) > 0 {
+		for _, serviceName := range services {
+			filters.Add("name", ServiceFilter(a.StackName(), serviceName, exactMatch))
+		}
+		return filters, nil
+	}
+
+	// When not appending the service name, just add one filter for the whole
+	// stack.
+	if !appendServiceNames {
+		f := fmt.Sprintf("%s", a.StackName())
+		if exactMatch {
+			f = fmt.Sprintf("^%s", f)
+		}
+		filters.Add("name", f)
+		return filters, nil
+	}
+
+	composeFiles, err := a.Recipe.GetComposeFiles(a.Env)
+	if err != nil {
+		return filters, err
+	}
+
+	opts := stack.Deploy{Composefiles: composeFiles}
+	compose, err := GetAppComposeConfig(a.Recipe.Name, opts, a.Env)
+	if err != nil {
+		return filters, err
+	}
+
+	for _, service := range compose.Services {
+		f := ServiceFilter(a.StackName(), service.Name, exactMatch)
+		filters.Add("name", f)
+	}
+
+	return filters, nil
+}
+
+// ServiceFilter creates a filter string for filtering a service in the docker
+// container runtime. When exact match is true, it uses regex to match the
+// string exactly.
+func ServiceFilter(stack, service string, exact bool) string {
+	if exact {
+		return fmt.Sprintf("^%s_%s", stack, service)
+	}
+	return fmt.Sprintf("%s_%s", stack, service)
+}
+
+// ByServer sort a slice of Apps
+type ByServer []App
+
+func (a ByServer) Len() int      { return len(a) }
+func (a ByServer) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a ByServer) Less(i, j int) bool {
+	return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
+}
+
+// ByServerAndRecipe sort a slice of Apps
+type ByServerAndRecipe []App
+
+func (a ByServerAndRecipe) Len() int      { return len(a) }
+func (a ByServerAndRecipe) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a ByServerAndRecipe) Less(i, j int) bool {
+	if a[i].Server == a[j].Server {
+		return strings.ToLower(a[i].Recipe.Name) < strings.ToLower(a[j].Recipe.Name)
+	}
+	return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
+}
+
+// ByRecipe sort a slice of Apps
+type ByRecipe []App
+
+func (a ByRecipe) Len() int      { return len(a) }
+func (a ByRecipe) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a ByRecipe) Less(i, j int) bool {
+	return strings.ToLower(a[i].Recipe.Name) < strings.ToLower(a[j].Recipe.Name)
+}
+
+// ByName sort a slice of Apps
+type ByName []App
+
+func (a ByName) Len() int      { return len(a) }
+func (a ByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a ByName) Less(i, j int) bool {
+	return strings.ToLower(a[i].Name) < strings.ToLower(a[j].Name)
+}
+
+func ReadAppEnvFile(appFile AppFile, name AppName) (App, error) {
+	env, err := envfile.ReadEnv(appFile.Path)
+	if err != nil {
+		return App{}, errors.New(i18n.G("env file for %s couldn't be read: %s", name, err.Error()))
+	}
+
+	app, err := NewApp(env, name, appFile)
+	if err != nil {
+		return App{}, errors.New(i18n.G("env file for %s has issues: %s", name, err.Error()))
+	}
+
+	return app, nil
+}
+
+// NewApp creates new App object
+func NewApp(env envfile.AppEnv, name string, appFile AppFile) (App, error) {
+	domain := env["DOMAIN"]
+
+	recipeName, exists := env["RECIPE"]
+	if !exists {
+		recipeName, exists = env["TYPE"]
+		if !exists {
+			return App{}, errors.New(i18n.G("%s is missing the TYPE env var?", name))
+		}
+	}
+
+	return App{
+		Name:   name,
+		Domain: domain,
+		Recipe: recipe.Get(recipeName),
+		Env:    env,
+		Server: appFile.Server,
+		Path:   appFile.Path,
+	}, nil
+}
+
+// LoadAppFiles gets all app files for a given set of servers or all servers.
+func LoadAppFiles(servers ...string) (AppFiles, error) {
+	appFiles := make(AppFiles)
+	if len(servers) == 1 {
+		if servers[0] == "" {
+			// Empty servers flag, one string will always be passed
+			var err error
+			servers, err = config.GetAllFoldersInDirectory(config.SERVERS_DIR)
+			if err != nil {
+				return appFiles, err
+			}
+		}
+	}
+
+	log.Debug(i18n.G("collecting metadata from %v servers: %s", len(servers), strings.Join(servers, ", ")))
+
+	for _, server := range servers {
+		serverDir := path.Join(config.SERVERS_DIR, server)
+		files, err := config.GetAllFilesInDirectory(serverDir)
+		if err != nil {
+			return appFiles, errors.New(i18n.G("server %s doesn't exist? Run \"abra server ls\" to check", server))
+		}
+
+		for _, file := range files {
+			appName := strings.TrimSuffix(file.Name(), ".env")
+			appFilePath := path.Join(config.SERVERS_DIR, server, file.Name())
+			appFiles[appName] = AppFile{
+				Path:   appFilePath,
+				Server: server,
+			}
+		}
+	}
+
+	return appFiles, nil
+}
+
+// GetAppServiceNames retrieves a list of app service names.
+func GetAppServiceNames(appName string) ([]string, error) {
+	var serviceNames []string
+
+	appFiles, err := LoadAppFiles("")
+	if err != nil {
+		return serviceNames, err
+	}
+
+	app, err := GetApp(appFiles, appName)
+	if err != nil {
+		return serviceNames, err
+	}
+
+	composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
+	if err != nil {
+		return serviceNames, err
+	}
+
+	opts := stack.Deploy{Composefiles: composeFiles}
+	compose, err := GetAppComposeConfig(app.Recipe.Name, opts, app.Env)
+	if err != nil {
+		return serviceNames, err
+	}
+
+	for _, service := range compose.Services {
+		serviceNames = append(serviceNames, service.Name)
+	}
+
+	return serviceNames, nil
+}
+
+// GetAppNames retrieves a list of app names.
+func GetAppNames() ([]string, error) {
+	var appNames []string
+
+	appFiles, err := LoadAppFiles("")
+	if err != nil {
+		return appNames, err
+	}
+
+	apps, err := GetApps(appFiles, "")
+	if err != nil {
+		return appNames, err
+	}
+
+	for _, app := range apps {
+		appNames = append(appNames, app.Name)
+	}
+
+	return appNames, nil
+}
+
+// TemplateAppEnvSample copies the example env file for the app into the users
+// env files.
+func TemplateAppEnvSample(r recipe.Recipe, appName, server, domain string) error {
+	envSample, err := os.ReadFile(r.SampleEnvPath)
+	if err != nil {
+		return err
+	}
+
+	appEnvPath := path.Join(config.ABRA_DIR, "servers", server, fmt.Sprintf("%s.env", appName))
+	if _, err := os.Stat(appEnvPath); !os.IsNotExist(err) {
+		return errors.New(i18n.G("%s already exists?", appEnvPath))
+	}
+
+	err = os.WriteFile(appEnvPath, envSample, 0o664)
+	if err != nil {
+		return err
+	}
+
+	read, err := os.ReadFile(appEnvPath)
+	if err != nil {
+		return err
+	}
+
+	newContents := strings.Replace(
+		string(read),
+		fmt.Sprintf("%s.example.com", r.Name),
+		domain,
+		-1,
+	)
+
+	err = os.WriteFile(appEnvPath, []byte(newContents), 0)
+	if err != nil {
+		return err
+	}
+
+	log.Debug(i18n.G("copied & templated %s to %s", r.SampleEnvPath, appEnvPath))
+
+	return nil
+}
+
+// SanitiseAppName makes a app name usable with Docker by replacing illegal
+// characters.
+func SanitiseAppName(name string) string {
+	return strings.ReplaceAll(name, ".", "_")
+}
+
+// GetAppStatuses queries servers to check the deployment status of given apps.
+func GetAppStatuses(apps []App, MachineReadable bool) (map[string]map[string]string, error) {
+	statuses := make(map[string]map[string]string)
+
+	servers := make(map[string]struct{})
+	for _, app := range apps {
+		if _, ok := servers[app.Server]; !ok {
+			servers[app.Server] = struct{}{}
+		}
+	}
+
+	var bar *progressbar.ProgressBar
+	if !MachineReadable {
+		bar = formatter.CreateProgressbar(len(servers), i18n.G("querying remote servers..."))
+	}
+
+	ch := make(chan stack.StackStatus, len(servers))
+	for server := range servers {
+		cl, err := client.New(server)
+		if err != nil {
+			log.Warn(err)
+			ch <- stack.StackStatus{}
+			continue
+		}
+
+		go func(s string) {
+			ch <- stack.GetAllDeployedServices(cl, s)
+			if !MachineReadable {
+				bar.Add(1)
+			}
+		}(server)
+	}
+
+	for range servers {
+		status := <-ch
+		if status.Err != nil {
+			return statuses, status.Err
+		}
+
+		for _, service := range status.Services {
+			result := make(map[string]string)
+			name := service.Spec.Labels[convert.LabelNamespace]
+
+			if _, ok := statuses[name]; !ok {
+				result["status"] = "deployed"
+			}
+
+			labelKey := fmt.Sprintf("coop-cloud.%s.chaos", name)
+			chaos, ok := service.Spec.Labels[labelKey]
+			if ok {
+				result["chaos"] = chaos
+			}
+
+			labelKey = fmt.Sprintf("coop-cloud.%s.chaos-version", name)
+			if chaosVersion, ok := service.Spec.Labels[labelKey]; ok {
+				result["chaosVersion"] = chaosVersion
+			}
+
+			labelKey = fmt.Sprintf("coop-cloud.%s.version", name)
+			if version, ok := service.Spec.Labels[labelKey]; ok {
+				result["version"] = version
+			} else {
+				continue
+			}
+
+			statuses[name] = result
+		}
+	}
+
+	log.Debug(i18n.G("retrieved app statuses: %s", statuses))
+
+	return statuses, nil
+}
+
+// GetAppComposeConfig retrieves a compose specification for a recipe. This
+// specification is the result of a merge of all the compose.**.yml files in
+// the recipe repository.
+func GetAppComposeConfig(recipe string, opts stack.Deploy, appEnv envfile.AppEnv) (*composetypes.Config, error) {
+	compose, err := loader.LoadComposefile(opts, appEnv)
+	if err != nil {
+		return &composetypes.Config{}, err
+	}
+
+	log.Debug(i18n.G("retrieved %s for %s", compose.Filename, recipe))
+
+	return compose, nil
+}
+
+// ExposeAllEnv exposes all env variables to the app container
+func ExposeAllEnv(stackName string, compose *composetypes.Config, appEnv envfile.AppEnv) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			log.Debug(i18n.G("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.Debug(i18n.G("%s: %s: %s", stackName, k, value))
+				}
+			}
+		}
+	}
+}
+
+func CheckEnv(app App) ([]envfile.EnvVar, error) {
+	var envVars []envfile.EnvVar
+
+	envSample, err := app.Recipe.SampleEnv()
+	if err != nil {
+		return envVars, err
+	}
+
+	var keys []string
+	for key := range envSample {
+		keys = append(keys, key)
+	}
+
+	sort.Strings(keys)
+
+	for _, key := range keys {
+		if _, ok := app.Env[key]; ok {
+			envVars = append(envVars, envfile.EnvVar{Name: key, Present: true})
+		} else {
+			envVars = append(envVars, envfile.EnvVar{Name: key, Present: false})
+		}
+	}
+
+	return envVars, nil
+}
+
+// ReadAbraShCmdNames reads the names of commands.
+func ReadAbraShCmdNames(abraSh string) ([]string, error) {
+	var cmdNames []string
+
+	file, err := os.Open(abraSh)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return cmdNames, nil
+		}
+		return cmdNames, err
+	}
+	defer file.Close()
+
+	cmdNameRegex, err := regexp.Compile(`(\w+)(\(\).*\{)`)
+	if err != nil {
+		return cmdNames, err
+	}
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		matches := cmdNameRegex.FindStringSubmatch(line)
+		if len(matches) > 0 {
+			cmdNames = append(cmdNames, matches[1])
+		}
+	}
+
+	if len(cmdNames) > 0 {
+		log.Debug(i18n.G("read %s from %s", strings.Join(cmdNames, " "), abraSh))
+	} else {
+		log.Debug(i18n.G("read 0 command names from %s", abraSh))
+	}
+
+	return cmdNames, nil
+}
+
+// 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()
+
+	var (
+		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
+		}
+
+		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.Debug(i18n.G("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)
+	}
+
+	if err := scanner.Err(); err != nil {
+		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)
+		}
+	} else {
+		log.Debug(i18n.G("skipping writing version %s because dry run", version))
+	}
+
+	if !skipped {
+		log.Debug(i18n.G("version %s saved to %s.env", version, a.Domain))
+	} else {
+		log.Debug(i18n.G("skipping version %s write as already exists in %s.env", version, a.Domain))
+	}
+
+	return nil
 }

pkg/app/app_test.go

@@ -1,4 +1,4 @@
-package config_test
+package app_test
 
 import (
 	"encoding/json"
@@ -6,46 +6,49 @@ import (
 	"reflect"
 	"testing"
 
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/envfile"
 	"coopcloud.tech/abra/pkg/recipe"
+	testPkg "coopcloud.tech/abra/pkg/test"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestNewApp(t *testing.T) {
-	app, err := config.NewApp(ExpectedAppEnv, AppName, ExpectedAppFile)
+	app, err := appPkg.NewApp(testPkg.ExpectedAppEnv, testPkg.AppName, testPkg.ExpectedAppFile)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(app, ExpectedApp) {
-		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, ExpectedApp)
+	if !reflect.DeepEqual(app, testPkg.ExpectedApp) {
+		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, testPkg.ExpectedApp)
 	}
 }
 
 func TestReadAppEnvFile(t *testing.T) {
-	app, err := config.ReadAppEnvFile(ExpectedAppFile, AppName)
+	app, err := appPkg.ReadAppEnvFile(testPkg.ExpectedAppFile, testPkg.AppName)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(app, ExpectedApp) {
-		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, ExpectedApp)
+	if !reflect.DeepEqual(app, testPkg.ExpectedApp) {
+		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, testPkg.ExpectedApp)
 	}
 }
 
 func TestGetApp(t *testing.T) {
-	app, err := config.GetApp(ExpectedAppFiles, AppName)
+	app, err := appPkg.GetApp(testPkg.ExpectedAppFiles, testPkg.AppName)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(app, ExpectedApp) {
-		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, ExpectedApp)
+	if !reflect.DeepEqual(app, testPkg.ExpectedApp) {
+		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, testPkg.ExpectedApp)
 	}
 }
 
 func TestGetComposeFiles(t *testing.T) {
-	offline := true
-	r, err := recipe.Get2("abra-test-recipe", offline)
+	r := recipe.Get("abra-test-recipe")
+	err := r.EnsureExists()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -57,32 +60,32 @@ func TestGetComposeFiles(t *testing.T) {
 		{
 			map[string]string{},
 			[]string{
-				fmt.Sprintf("%s/%s/compose.yml", config.RECIPES_DIR, r.Name),
+				fmt.Sprintf("%s/compose.yml", r.Dir),
 			},
 		},
 		{
 			map[string]string{"COMPOSE_FILE": "compose.yml"},
 			[]string{
-				fmt.Sprintf("%s/%s/compose.yml", config.RECIPES_DIR, r.Name),
+				fmt.Sprintf("%s/compose.yml", r.Dir),
 			},
 		},
 		{
 			map[string]string{"COMPOSE_FILE": "compose.extra_secret.yml"},
 			[]string{
-				fmt.Sprintf("%s/%s/compose.extra_secret.yml", config.RECIPES_DIR, r.Name),
+				fmt.Sprintf("%s/compose.extra_secret.yml", r.Dir),
 			},
 		},
 		{
 			map[string]string{"COMPOSE_FILE": "compose.yml:compose.extra_secret.yml"},
 			[]string{
-				fmt.Sprintf("%s/%s/compose.yml", config.RECIPES_DIR, r.Name),
-				fmt.Sprintf("%s/%s/compose.extra_secret.yml", config.RECIPES_DIR, r.Name),
+				fmt.Sprintf("%s/compose.yml", r.Dir),
+				fmt.Sprintf("%s/compose.extra_secret.yml", r.Dir),
 			},
 		},
 	}
 
 	for _, test := range tests {
-		composeFiles, err := config.GetComposeFiles(r.Name, test.appEnv)
+		composeFiles, err := r.GetComposeFiles(test.appEnv)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -91,8 +94,8 @@ func TestGetComposeFiles(t *testing.T) {
 }
 
 func TestGetComposeFilesError(t *testing.T) {
-	offline := true
-	r, err := recipe.Get2("abra-test-recipe", offline)
+	r := recipe.Get("abra-test-recipe")
+	err := r.EnsureExists()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -103,7 +106,7 @@ func TestGetComposeFilesError(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		_, err := config.GetComposeFiles(r.Name, test.appEnv)
+		_, err := r.GetComposeFiles(test.appEnv)
 		if err == nil {
 			t.Fatalf("should have failed: %v", test.appEnv)
 		}
@@ -112,16 +115,16 @@ func TestGetComposeFilesError(t *testing.T) {
 
 func TestFilters(t *testing.T) {
 	oldDir := config.RECIPES_DIR
-	config.RECIPES_DIR = "./testdir"
+	config.RECIPES_DIR = "./testdata"
 	defer func() {
 		config.RECIPES_DIR = oldDir
 	}()
 
-	app, err := config.NewApp(config.AppEnv{
+	app, err := appPkg.NewApp(envfile.AppEnv{
 		"DOMAIN": "test.example.com",
 		"RECIPE": "test-recipe",
-	}, "test_example_com", config.AppFile{
-		Path:   "./testdir/filtertest.end",
+	}, "test_example_com", appPkg.AppFile{
+		Path:   "./testdata/filtertest.end",
 		Server: "local",
 	})
 	if err != nil {
@@ -195,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

@@ -0,0 +1,90 @@
+package app
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	composetypes "github.com/docker/cli/cli/compose/types"
+)
+
+// SetRecipeLabel adds the label 'coop-cloud.${STACK_NAME}.recipe=${RECIPE}' to the app container
+// to signal which recipe is connected to the deployed app
+func SetRecipeLabel(compose *composetypes.Config, stackName string, recipe string) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			log.Debug(i18n.G("set recipe label 'coop-cloud.%s.recipe' to %s for %s", stackName, recipe, stackName))
+			labelKey := fmt.Sprintf("coop-cloud.%s.recipe", stackName)
+			service.Deploy.Labels[labelKey] = recipe
+		}
+	}
+}
+
+// SetChaosLabel adds the label 'coop-cloud.${STACK_NAME}.chaos=true/false' to the app container
+// to signal if the app is deployed in chaos mode
+func SetChaosLabel(compose *composetypes.Config, stackName string, chaos bool) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			log.Debug(i18n.G("set label 'coop-cloud.%s.chaos' to %v for %s", stackName, chaos, stackName))
+			labelKey := fmt.Sprintf("coop-cloud.%s.chaos", stackName)
+			service.Deploy.Labels[labelKey] = strconv.FormatBool(chaos)
+		}
+	}
+}
+
+// SetChaosVersionLabel adds the label 'coop-cloud.${STACK_NAME}.chaos-version=$(GIT_COMMIT)' to the app container
+func SetChaosVersionLabel(compose *composetypes.Config, stackName string, chaosVersion string) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			log.Debug(i18n.G("set label 'coop-cloud.%s.chaos-version' to %v for %s", stackName, chaosVersion, stackName))
+			labelKey := fmt.Sprintf("coop-cloud.%s.chaos-version", stackName)
+			service.Deploy.Labels[labelKey] = chaosVersion
+		}
+	}
+}
+
+func SetVersionLabel(compose *composetypes.Config, stackName string, version string) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			log.Debug(i18n.G("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
+		}
+	}
+}
+
+// GetLabel reads docker labels in the format of "coop-cloud.${STACK_NAME}.${LABEL}" from the local compose files
+func GetLabel(compose *composetypes.Config, stackName string, label string) string {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			labelKey := fmt.Sprintf("coop-cloud.%s.%s", stackName, label)
+			log.Debug(i18n.G("get label '%s'", labelKey))
+			if labelValue, ok := service.Deploy.Labels[labelKey]; ok {
+				return labelValue
+			}
+		}
+	}
+	log.Debug(i18n.G("no %s label found for %s", label, stackName))
+	return ""
+}
+
+// GetTimeoutFromLabel reads the timeout value from docker label
+// `coop-cloud.${STACK_NAME}.timeout=...` if present. A value is present if the
+// operator uses a `TIMEOUT=...` in their app env.
+func GetTimeoutFromLabel(compose *composetypes.Config, stackName string) (int, error) {
+	var timeout int
+
+	if timeoutLabel := GetLabel(compose, stackName, "timeout"); timeoutLabel != "" {
+		log.Debug(i18n.G("timeout label: %s", timeoutLabel))
+
+		var err error
+		timeout, err = strconv.Atoi(timeoutLabel)
+		if err != nil {
+			return timeout, errors.New(i18n.G("unable to convert timeout label %s to int: %s", timeoutLabel, err))
+		}
+	}
+
+	return timeout, nil
+}

pkg/app/compose_test.go

@@ -0,0 +1,62 @@
+package app_test
+
+import (
+	"testing"
+
+	appPkg "coopcloud.tech/abra/pkg/app"
+	testPkg "coopcloud.tech/abra/pkg/test"
+	stack "coopcloud.tech/abra/pkg/upstream/stack"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetTimeoutFromLabel(t *testing.T) {
+	testPkg.MkServerAppRecipe()
+	defer testPkg.RmServerAppRecipe()
+
+	tests := []struct {
+		configuredTimeout string
+		expectedTimeout   int
+	}{
+		{"0", 0},
+		{"DOESNTEXIST", 0}, // NOTE(d1): test when missing from .env
+		{"80", 80},
+		{"120", 120},
+	}
+
+	for _, test := range tests {
+		app, err := appPkg.GetApp(testPkg.ExpectedAppFiles, testPkg.AppName)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if test.configuredTimeout != "DOESNTEXIST" {
+			app.Env["TIMEOUT"] = test.configuredTimeout
+		}
+
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		deployOpts := stack.Deploy{
+			Composefiles: composeFiles,
+			Namespace:    app.StackName(),
+			Prune:        false,
+			ResolveImage: stack.ResolveImageAlways,
+			Detach:       false,
+		}
+
+		compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		timeout, err := appPkg.GetTimeoutFromLabel(compose, app.StackName())
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, timeout, test.expectedTimeout)
+	}
+}

pkg/autocomplete/autocomplete.go

@@ -1,102 +1,135 @@
 package autocomplete
 
 import (
-	"fmt"
+	"sort"
+	"strings"
 
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/app"
+	appPkg "coopcloud.tech/abra/pkg/app"
+	"coopcloud.tech/abra/pkg/i18n"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/spf13/cobra"
 )
 
 // AppNameComplete copletes app names.
-func AppNameComplete(c *cli.Context) {
-	appNames, err := config.GetAppNames()
+func AppNameComplete() ([]string, cobra.ShellCompDirective) {
+	appFiles, err := app.LoadAppFiles("")
 	if err != nil {
-		logrus.Warn(err)
+		err := i18n.G("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
 
-	if c.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) {
-	serviceNames, err := config.GetAppServiceNames(appName)
+func ServiceNameComplete(appName string) ([]string, cobra.ShellCompDirective) {
+	serviceNames, err := app.GetAppServiceNames(appName)
 	if err != nil {
-		return
-	}
-	for _, s := range serviceNames {
-		fmt.Println(s)
+		err := i18n.G("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
+
+	return serviceNames, cobra.ShellCompDirectiveDefault
 }
 
 // RecipeNameComplete completes recipe names.
-func RecipeNameComplete(c *cli.Context) {
-	catl, err := recipe.ReadRecipeCatalogue(false)
+func RecipeNameComplete() ([]string, cobra.ShellCompDirective) {
+	catl, err := recipe.ReadRecipeCatalogue(true)
 	if err != nil {
-		logrus.Warn(err)
+		err := i18n.G("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
 
-	if c.NArg() > 0 {
-		return
+	localRecipes, err := recipe.GetRecipesLocal()
+	if err != nil && !strings.Contains(err.Error(), "empty") {
+		err := i18n.G("autocomplete failed: %s", err)
+		return []string{err}, cobra.ShellCompDirectiveError
 	}
 
+	var recipeNames []string
 	for name := range catl {
-		fmt.Println(name)
+		recipeNames = append(recipeNames, name)
 	}
+
+	for _, recipeLocal := range localRecipes {
+		recipeNames = append(recipeNames, recipeLocal)
+	}
+
+	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 {
-		logrus.Warn(err)
+		err := i18n.G("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(c *cli.Context) {
-	files, err := config.LoadAppFiles("")
+func ServerNameComplete() ([]string, cobra.ShellCompDirective) {
+	files, err := app.LoadAppFiles("")
 	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	if c.NArg() > 0 {
-		return
+		err := i18n.G("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(c *cli.Context) {
-	if c.NArg() > 0 {
-		return
+// CommandNameComplete completes recipe commands.
+func CommandNameComplete(appName string) ([]string, cobra.ShellCompDirective) {
+	app, err := app.Get(appName)
+	if err != nil {
+		err := i18n.G("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 := i18n.G("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 := i18n.G("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"
@@ -8,21 +9,21 @@ import (
 
 	"coopcloud.tech/abra/pkg/config"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
 )
 
 // 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) {
-		logrus.Warnf("local recipe catalogue is missing, retrieving now")
+		log.Debug(i18n.G("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
 		}
-
-		logrus.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(i18n.G("%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"
-		logrus.Debugf(msg, config.CATALOGUE_DIR)
+		log.Debug(i18n.G("cannot ensure %s is up-to-date, no git remotes configured", config.CATALOGUE_DIR))
 		return nil
 	}
 
@@ -82,7 +81,7 @@ func EnsureUpToDate() error {
 		}
 	}
 
-	logrus.Debugf("fetched latest git changes for %s", config.CATALOGUE_DIR)
+	log.Debug(i18n.G("fetched latest git changes for %s", config.CATALOGUE_DIR))
 
 	return nil
 }

pkg/client/client.go

@@ -4,37 +4,71 @@ package client
 import (
 	"context"
 	"errors"
-	"fmt"
 	"net/http"
 	"os"
+	"path"
+	"strings"
 	"time"
 
+	"coopcloud.tech/abra/pkg/config"
 	contextPkg "coopcloud.tech/abra/pkg/context"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	sshPkg "coopcloud.tech/abra/pkg/ssh"
 	commandconnPkg "coopcloud.tech/abra/pkg/upstream/commandconn"
 	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
+// Conf is a Docker client configuration.
+type Conf struct {
+	Timeout int
+}
+
+// Opt is a Docker client option.
+type Opt func(c *Conf)
+
+// WithTimeout specifies a timeout for a Docker client.
+func WithTimeout(timeout int) Opt {
+	return func(c *Conf) {
+		c.Timeout = timeout
+	}
+}
+
 // New initiates a new Docker client. New client connections are validated so
 // that we ensure connections via SSH to the daemon can succeed. It takes into
 // account that you may only want the local client and not communicate via SSH.
 // For this use-case, please pass "default" as the contextName.
-func New(serverName string) (*client.Client, error) {
+func New(serverName string, opts ...Opt) (*client.Client, error) {
 	var clientOpts []client.Opt
 
-	if serverName != "default" {
-		context, err := GetContext(serverName)
-		if err != nil {
-			return nil, fmt.Errorf("unknown server, run \"abra server add %s\"?", serverName)
+	ctx, err := GetContext(serverName)
+	if err != nil {
+		serverDir := path.Join(config.SERVERS_DIR, serverName)
+		if _, err := os.Stat(serverDir); err == nil {
+			return nil, errors.New(i18n.G("server missing context, run \"abra server add %s\"?", serverName))
 		}
 
-		ctxEndpoint, err := contextPkg.GetContextEndpoint(context)
-		if err != nil {
-			return nil, err
+		return nil, errors.New(i18n.G("unknown server, run \"abra server add %s\"?", serverName))
+	}
+
+	ctxEndpoint, err := contextPkg.GetContextEndpoint(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var isUnix bool
+	if strings.Contains(ctxEndpoint, "unix://") {
+		isUnix = true
+	}
+
+	if serverName != "default" && !isUnix {
+		conf := &Conf{}
+
+		for _, opt := range opts {
+			opt(conf)
 		}
 
-		helper, err := commandconnPkg.NewConnectionHelper(ctxEndpoint)
+		helper, err := commandconnPkg.NewConnectionHelper(ctxEndpoint, conf.Timeout)
 		if err != nil {
 			return nil, err
 		}
@@ -65,7 +99,7 @@ func New(serverName string) (*client.Client, error) {
 		return nil, err
 	}
 
-	logrus.Debugf("created client for %s", serverName)
+	log.Debug(i18n.G("created client for %s", serverName))
 
 	info, err := cl.Info(context.Background())
 	if err != nil {
@@ -73,11 +107,11 @@ func New(serverName string) (*client.Client, error) {
 	}
 
 	if info.Swarm.LocalNodeState == "inactive" {
-		if serverName != "default" {
-			return cl, fmt.Errorf("swarm mode not enabled on %s?", serverName)
-		} else {
-			return cl, errors.New("swarm mode not enabled on local server?")
+		if serverName != "default" && !isUnix {
+			return cl, errors.New(i18n.G("swarm mode not enabled on %s?", serverName))
 		}
+
+		return cl, errors.New(i18n.G("swarm mode not enabled on local server?"))
 	}
 
 	return cl, nil

pkg/client/configs.go

@@ -0,0 +1,39 @@
+package client
+
+import (
+	"context"
+	"errors"
+
+	"coopcloud.tech/abra/pkg/i18n"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/docker/docker/client"
+)
+
+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(i18n.G("conf %s: %s", confName, err))
+		}
+	}
+	return nil
+}

pkg/client/context.go

@@ -5,11 +5,12 @@ import (
 	"fmt"
 
 	"coopcloud.tech/abra/pkg/context"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	commandconnPkg "coopcloud.tech/abra/pkg/upstream/commandconn"
 	dConfig "github.com/docker/cli/cli/config"
 	"github.com/docker/cli/cli/context/docker"
 	contextStore "github.com/docker/cli/cli/context/store"
-	"github.com/sirupsen/logrus"
 )
 
 type Context = contextStore.Metadata
@@ -22,7 +23,7 @@ func CreateContext(contextName string) error {
 		return err
 	}
 
-	logrus.Debugf("created the %s context", contextName)
+	log.Debug(i18n.G("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(i18n.G("context 'default' cannot be removed"))
 	}
 
 	if _, err := GetContext(name); err != nil {

pkg/client/registry.go

@@ -2,8 +2,10 @@ package client
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
+	"coopcloud.tech/abra/pkg/i18n"
 	"github.com/containers/image/docker"
 	"github.com/containers/image/types"
 	"github.com/distribution/reference"
@@ -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(i18n.G("failed to parse image %s, saw: %s", img, err.Error()))
 	}
 
 	ctx := context.Background()

pkg/client/secret.go

@@ -7,7 +7,7 @@ import (
 	"github.com/docker/docker/client"
 )
 
-func StoreSecret(cl *client.Client, secretName, secretValue, server string) error {
+func StoreSecret(cl *client.Client, secretName, secretValue string) error {
 	ann := swarm.Annotations{Name: secretName}
 	spec := swarm.SecretSpec{Annotations: ann, Data: []byte(secretValue)}
 
@@ -17,3 +17,11 @@ func StoreSecret(cl *client.Client, secretName, secretValue, server string) erro
 
 	return nil
 }
+
+func GetSecretNames(secrets []swarm.Secret) []string {
+	var secretNames []string
+	for _, secret := range secrets {
+		secretNames = append(secretNames, secret.Spec.Name)
+	}
+	return secretNames
+}

pkg/client/secret_test.go

@@ -0,0 +1,58 @@
+package client
+
+import (
+	"testing"
+
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetSecretNames(t *testing.T) {
+	tests := []struct {
+		name        string
+		secrets     []swarm.Secret
+		expected    []string
+		description string
+	}{
+		{
+			name:        "empty secrets list",
+			secrets:     []swarm.Secret{},
+			expected:    nil,
+			description: "should return nil for empty input",
+		},
+		{
+			name: "single secret",
+			secrets: []swarm.Secret{
+				{Spec: swarm.SecretSpec{Annotations: swarm.Annotations{Name: "database_password"}}},
+			},
+			expected:    []string{"database_password"},
+			description: "should return single secret name",
+		},
+		{
+			name: "multiple secrets",
+			secrets: []swarm.Secret{
+				{Spec: swarm.SecretSpec{Annotations: swarm.Annotations{Name: "db_password"}}},
+				{Spec: swarm.SecretSpec{Annotations: swarm.Annotations{Name: "api_key"}}},
+				{Spec: swarm.SecretSpec{Annotations: swarm.Annotations{Name: "ssl_cert"}}},
+			},
+			expected:    []string{"db_password", "api_key", "ssl_cert"},
+			description: "should return all secret names in order",
+		},
+		{
+			name: "secrets with empty names",
+			secrets: []swarm.Secret{
+				{Spec: swarm.SecretSpec{Annotations: swarm.Annotations{Name: ""}}},
+				{Spec: swarm.SecretSpec{Annotations: swarm.Annotations{Name: "valid_name"}}},
+			},
+			expected:    []string{"", "valid_name"},
+			description: "should include empty names if present",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := GetSecretNames(tt.secrets)
+			assert.Equal(t, tt.expected, result, tt.description)
+		})
+	}
+}

pkg/client/volumes.go

@@ -2,13 +2,14 @@ package client
 
 import (
 	"context"
-	"fmt"
+	"errors"
 	"time"
 
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/volume"
 	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
 func GetVolumes(cl *client.Client, ctx context.Context, server string, fs filters.Args) ([]*volume.Volume, error) {
@@ -37,7 +38,7 @@ func RemoveVolumes(cl *client.Client, ctx context.Context, volumeNames []string,
 			return cl.VolumeRemove(context.Background(), volName, force)
 		})
 		if err != nil {
-			return fmt.Errorf("volume %s: %s", volName, err)
+			return errors.New(i18n.G("volume %s: %s", volName, err))
 		}
 	}
 	return nil
@@ -54,9 +55,9 @@ func retryFunc(retries int, fn func() error) error {
 		}
 		if i+1 < retries {
 			sleep := time.Duration(i+1) * time.Duration(i+1)
-			logrus.Infof("%s: waiting %d seconds before next retry", err, sleep)
+			log.Info(i18n.G("%s: waiting %d seconds before next retry", err, sleep))
 			time.Sleep(sleep * time.Second)
 		}
 	}
-	return fmt.Errorf("%d retries failed", retries)
+	return errors.New(i18n.G("%d retries failed", retries))
 }

pkg/compose/compose.go

@@ -1,158 +0,0 @@
-package compose
-
-import (
-	"fmt"
-	"io/ioutil"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/upstream/stack"
-	loader "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/distribution/reference"
-	composetypes "github.com/docker/cli/cli/compose/types"
-	"github.com/sirupsen/logrus"
-)
-
-// UpdateTag updates an image tag in-place on file system local compose files.
-func UpdateTag(pattern, image, tag, recipeName string) (bool, error) {
-	composeFiles, err := filepath.Glob(pattern)
-	if err != nil {
-		return false, err
-	}
-
-	logrus.Debugf("considering %s config(s) for tag update", strings.Join(composeFiles, ", "))
-
-	for _, composeFile := range composeFiles {
-		opts := stack.Deploy{Composefiles: []string{composeFile}}
-
-		envSamplePath := path.Join(config.RECIPES_DIR, recipeName, ".env.sample")
-		sampleEnv, err := config.ReadEnv(envSamplePath)
-		if err != nil {
-			return false, err
-		}
-
-		compose, err := loader.LoadComposefile(opts, sampleEnv)
-		if err != nil {
-			return false, err
-		}
-
-		for _, service := range compose.Services {
-			if service.Image == "" {
-				continue // may be a compose.$optional.yml file
-			}
-
-			img, _ := reference.ParseNormalizedNamed(service.Image)
-			if err != nil {
-				return false, err
-			}
-
-			var composeTag string
-			switch img.(type) {
-			case reference.NamedTagged:
-				composeTag = img.(reference.NamedTagged).Tag()
-			default:
-				logrus.Debugf("unable to parse %s, skipping", img)
-				continue
-			}
-
-			composeImage := formatter.StripTagMeta(reference.Path(img))
-
-			logrus.Debugf("parsed %s from %s", composeTag, service.Image)
-
-			if image == composeImage {
-				bytes, err := ioutil.ReadFile(composeFile)
-				if err != nil {
-					return false, err
-				}
-
-				old := fmt.Sprintf("%s:%s", composeImage, composeTag)
-				new := fmt.Sprintf("%s:%s", composeImage, tag)
-				replacedBytes := strings.Replace(string(bytes), old, new, -1)
-
-				logrus.Debugf("updating %s to %s in %s", old, new, compose.Filename)
-
-				if err := ioutil.WriteFile(compose.Filename, []byte(replacedBytes), 0764); err != nil {
-					return false, err
-				}
-			}
-		}
-	}
-
-	return false, nil
-}
-
-// UpdateLabel updates a label in-place on file system local compose files.
-func UpdateLabel(pattern, serviceName, label, recipeName string) error {
-	composeFiles, err := filepath.Glob(pattern)
-	if err != nil {
-		return err
-	}
-
-	logrus.Debugf("considering %s config(s) for label update", strings.Join(composeFiles, ", "))
-
-	for _, composeFile := range composeFiles {
-		opts := stack.Deploy{Composefiles: []string{composeFile}}
-
-		envSamplePath := path.Join(config.RECIPES_DIR, recipeName, ".env.sample")
-		sampleEnv, err := config.ReadEnv(envSamplePath)
-		if err != nil {
-			return err
-		}
-
-		compose, err := loader.LoadComposefile(opts, sampleEnv)
-		if err != nil {
-			return err
-		}
-
-		serviceExists := false
-		var service composetypes.ServiceConfig
-		for _, s := range compose.Services {
-			if s.Name == serviceName {
-				service = s
-				serviceExists = true
-			}
-		}
-
-		if !serviceExists {
-			continue
-		}
-
-		discovered := false
-		for oldLabel, value := range service.Deploy.Labels {
-			if strings.HasPrefix(oldLabel, "coop-cloud") && strings.Contains(oldLabel, "version") {
-				discovered = true
-
-				bytes, err := ioutil.ReadFile(composeFile)
-				if err != nil {
-					return err
-				}
-
-				old := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", value)
-				replacedBytes := strings.Replace(string(bytes), old, label, -1)
-
-				if old == label {
-					logrus.Warnf("%s is already set, nothing to do?", label)
-					return nil
-				}
-
-				logrus.Debugf("updating %s to %s in %s", old, label, compose.Filename)
-
-				if err := ioutil.WriteFile(compose.Filename, []byte(replacedBytes), 0764); err != nil {
-					return err
-				}
-
-				logrus.Infof("synced label %s to service %s", label, serviceName)
-			}
-		}
-
-		if !discovered {
-			logrus.Warn("no existing label found, automagic insertion not supported yet")
-			logrus.Fatalf("add '- \"%s\"' manually to the 'app' service in %s", label, composeFile)
-		}
-	}
-
-	return nil
-}

pkg/config/abra.go

@@ -0,0 +1,122 @@
+package config
+
+import (
+	"os"
+	"path"
+	"path/filepath"
+
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"gopkg.in/yaml.v3"
+)
+
+// LoadAbraConfig returns the abra configuration. It tries to find a abra
+// configuration file (see findAbraConfig for lookup logic). When no
+// configuration was found it returns the default config.
+func LoadAbraConfig() Abra {
+	wd, _ := os.Getwd()
+	configFile := findAbraConfig(wd)
+	if configFile == "" {
+		log.Debug(i18n.G("no config file found"))
+		return Abra{}
+	}
+	data, err := os.ReadFile(configFile)
+	if err != nil {
+		// Do nothing, when an error occurs
+		log.Debug(i18n.G("error reading config file: %s", err))
+		return Abra{}
+	}
+
+	config := Abra{}
+	err = yaml.Unmarshal(data, &config)
+	if err != nil {
+		// Do nothing, when an error occurs
+		log.Debug(i18n.G("error loading config file: %s", err))
+		return Abra{}
+	}
+	log.Debug(i18n.G("config file loaded from: %s", configFile))
+	config.configPath = filepath.Dir(configFile)
+	return config
+}
+
+// findAbraConfig recursively looks for a abra.y(a)ml file in the given directory.
+// When the file was not found it calls the function again with the parent
+// directory until the home directory is hit. When no abra config was found it
+// returns an empty string.
+func findAbraConfig(dir string) string {
+	dir, err := filepath.Abs(dir)
+	if err != nil {
+		return ""
+	}
+	if dir == os.ExpandEnv("$HOME") || dir == "/" {
+		return ""
+	}
+	p := path.Join(dir, "abra.yaml")
+	if _, err := os.Stat(p); err == nil {
+		return p
+	}
+	p = path.Join(dir, "abra.yml")
+	if _, err := os.Stat(p); err == nil {
+		return p
+	}
+	return findAbraConfig(filepath.Dir(dir))
+}
+
+// Abra defines the configuration file for abra.
+type Abra struct {
+	configPath string
+	AbraDir    string `yaml:"abraDir"`
+}
+
+// GetAbraDir returns the abra dir. It has the following logic:
+// 1. check if $ABRA_DIR is set
+// 2. check if abraDir was set in a config file
+// 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(i18n.G("read abra dir from $ABRA_DIR"))
+		return dir
+	}
+	if a.AbraDir != "" {
+		log.Debug(i18n.G("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(i18n.G("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) 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()
+	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"
+
+	MISSING_DEFAULT = "-"
+
+	UNKNOWN_DEFAULT = "unknown"
+)

pkg/config/abra_test.go

@@ -0,0 +1,133 @@
+package config
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestFindAbraConfig(t *testing.T) {
+	wd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+	tests := []struct {
+		Dir    string
+		Config string
+	}{
+		{
+			Dir:    "testdata/abraconfig1",
+			Config: filepath.Join(wd, "testdata/abraconfig1/abra.yaml"),
+		},
+		{
+			Dir:    "testdata/abraconfig1/subdir",
+			Config: filepath.Join(wd, "testdata/abraconfig1/abra.yaml"),
+		},
+		{
+			Dir:    "testdata/abraconfig2",
+			Config: filepath.Join(wd, "testdata/abraconfig2/abra.yml"),
+		},
+		{
+			Dir:    "testdata/abraconfig2/subdir",
+			Config: filepath.Join(wd, "testdata/abraconfig2/abra.yml"),
+		},
+		{
+			Dir:    "testdata",
+			Config: "",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.Dir, func(t *testing.T) {
+			config := findAbraConfig(tc.Dir)
+			if config != tc.Config {
+				t.Errorf("\nwant: %s\ngot:  %s", tc.Config, config)
+			}
+		})
+	}
+}
+
+func TestLoadAbraConfigGetAbraDir(t *testing.T) {
+	wd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+	t.Setenv("ABRA_DIR", "")
+
+	t.Run("default", func(t *testing.T) {
+		cfg := LoadAbraConfig()
+		wantAbraDir := os.ExpandEnv("$HOME/.abra")
+		if cfg.GetAbraDir() != wantAbraDir {
+			t.Errorf("\nwant: %s\ngot:  %s", wantAbraDir, cfg.GetAbraDir())
+		}
+	})
+
+	t.Run("from config file", func(t *testing.T) {
+		t.Cleanup(func() { os.Chdir(wd) })
+		err = os.Chdir(filepath.Join(wd, "testdata/abraconfig1"))
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		cfg := LoadAbraConfig()
+		wantAbraDir := filepath.Join(wd, "testdata/abraconfig1/foobar")
+		if cfg.GetAbraDir() != wantAbraDir {
+			t.Errorf("\nwant: %s\ngot:  %s", wantAbraDir, cfg.GetAbraDir())
+		}
+	})
+
+	t.Run("default when config file is empty", func(t *testing.T) {
+		t.Cleanup(func() { os.Chdir(wd) })
+		err := os.Chdir(filepath.Join(wd, "testdata/abraconfig2"))
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		cfg := LoadAbraConfig()
+		wantAbraDir := os.ExpandEnv("$HOME/.abra")
+		if cfg.GetAbraDir() != wantAbraDir {
+			t.Errorf("\nwant: %s\ngot:  %s", wantAbraDir, cfg.GetAbraDir())
+		}
+	})
+
+	t.Run("from env variable", func(t *testing.T) {
+		t.Setenv("ABRA_DIR", "foo")
+		cfg := LoadAbraConfig()
+		wantAbraDir := "foo"
+		if cfg.GetAbraDir() != wantAbraDir {
+			t.Errorf("\nwant: %s\ngot:  %s", wantAbraDir, cfg.GetAbraDir())
+		}
+	})
+}
+
+func TestLoadAbraConfigServersDir(t *testing.T) {
+	wd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+	t.Setenv("ABRA_DIR", "")
+
+	t.Run("default", func(t *testing.T) {
+		cfg := LoadAbraConfig()
+		wantServersDir := os.ExpandEnv("$HOME/.abra/servers")
+		if cfg.GetServersDir() != wantServersDir {
+			t.Errorf("\nwant: %s\ngot:  %s", wantServersDir, cfg.GetServersDir())
+		}
+	})
+
+	t.Run("from config file", func(t *testing.T) {
+		t.Cleanup(func() { os.Chdir(wd) })
+		err = os.Chdir(filepath.Join(wd, "testdata/abraconfig1"))
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		cfg := LoadAbraConfig()
+		log.Println(cfg)
+		wantServersDir := filepath.Join(wd, "testdata/abraconfig1/foobar/servers")
+		if cfg.GetServersDir() != wantServersDir {
+			t.Errorf("\nwant: %s\ngot:  %s", wantServersDir, cfg.GetServersDir())
+		}
+	})
+}

pkg/config/app.go

@@ -1,627 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"strconv"
-	"strings"
-
-	"github.com/schollz/progressbar/v3"
-
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/upstream/convert"
-	loader "coopcloud.tech/abra/pkg/upstream/stack"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	composetypes "github.com/docker/cli/cli/compose/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/sirupsen/logrus"
-)
-
-// Type aliases to make code hints easier to understand
-
-// AppEnv is a map of the values in an apps env config
-type AppEnv = map[string]string
-
-// AppModifiers is a map of modifiers in an apps env config
-type AppModifiers = map[string]map[string]string
-
-// AppName is AppName
-type AppName = string
-
-// AppFile represents app env files on disk without reading the contents
-type AppFile struct {
-	Path   string
-	Server string
-}
-
-// AppFiles is a slice of appfiles
-type AppFiles map[AppName]AppFile
-
-// App reprents an app with its env file read into memory
-type App struct {
-	Name   AppName
-	Recipe string
-	Domain string
-	Env    AppEnv
-	Server string
-	Path   string
-}
-
-// See documentation of config.StackName
-func (a App) StackName() string {
-	if _, exists := a.Env["STACK_NAME"]; exists {
-		return a.Env["STACK_NAME"]
-	}
-
-	stackName := StackName(a.Name)
-
-	a.Env["STACK_NAME"] = stackName
-
-	return stackName
-}
-
-// StackName gets whatever the docker safe (uses the right delimiting
-// character, e.g. "_") stack name is for the app. In general, you don't want
-// to use this to show anything to end-users, you want use a.Name instead.
-func StackName(appName string) string {
-	stackName := SanitiseAppName(appName)
-
-	if len(stackName) > MAX_SANITISED_APP_NAME_LENGTH {
-		logrus.Debugf("trimming %s to %s to avoid runtime limits", stackName, stackName[:MAX_SANITISED_APP_NAME_LENGTH])
-		stackName = stackName[:MAX_SANITISED_APP_NAME_LENGTH]
-	}
-
-	return stackName
-}
-
-// Filters retrieves app filters for querying the container runtime. By default
-// it filters on all services in the app. It is also possible to pass an
-// otional list of service names, which get filtered instead.
-//
-// Due to upstream issues, filtering works different depending on what you're
-// querying. So, for example, secrets don't work with regex! The caller needs
-// to implement their own validation that the right secrets are matched. In
-// order to handle these cases, we provide the `appendServiceNames` /
-// `exactMatch` modifiers.
-func (a App) Filters(appendServiceNames, exactMatch bool, services ...string) (filters.Args, error) {
-	filters := filters.NewArgs()
-	if len(services) > 0 {
-		for _, serviceName := range services {
-			filters.Add("name", ServiceFilter(a.StackName(), serviceName, exactMatch))
-		}
-		return filters, nil
-	}
-
-	// When not appending the service name, just add one filter for the whole
-	// stack.
-	if !appendServiceNames {
-		f := fmt.Sprintf("%s", a.StackName())
-		if exactMatch {
-			f = fmt.Sprintf("^%s", f)
-		}
-		filters.Add("name", f)
-		return filters, nil
-	}
-
-	composeFiles, err := GetComposeFiles(a.Recipe, a.Env)
-	if err != nil {
-		return filters, err
-	}
-
-	opts := stack.Deploy{Composefiles: composeFiles}
-	compose, err := GetAppComposeConfig(a.Recipe, opts, a.Env)
-	if err != nil {
-		return filters, err
-	}
-
-	for _, service := range compose.Services {
-		f := ServiceFilter(a.StackName(), service.Name, exactMatch)
-		filters.Add("name", f)
-	}
-
-	return filters, nil
-}
-
-// ServiceFilter creates a filter string for filtering a service in the docker
-// container runtime. When exact match is true, it uses regex to match the
-// string exactly.
-func ServiceFilter(stack, service string, exact bool) string {
-	if exact {
-		return fmt.Sprintf("^%s_%s", stack, service)
-	}
-	return fmt.Sprintf("%s_%s", stack, service)
-}
-
-// ByServer sort a slice of Apps
-type ByServer []App
-
-func (a ByServer) Len() int      { return len(a) }
-func (a ByServer) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a ByServer) Less(i, j int) bool {
-	return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
-}
-
-// ByServerAndRecipe sort a slice of Apps
-type ByServerAndRecipe []App
-
-func (a ByServerAndRecipe) Len() int      { return len(a) }
-func (a ByServerAndRecipe) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a ByServerAndRecipe) Less(i, j int) bool {
-	if a[i].Server == a[j].Server {
-		return strings.ToLower(a[i].Recipe) < strings.ToLower(a[j].Recipe)
-	}
-	return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
-}
-
-// ByRecipe sort a slice of Apps
-type ByRecipe []App
-
-func (a ByRecipe) Len() int      { return len(a) }
-func (a ByRecipe) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a ByRecipe) Less(i, j int) bool {
-	return strings.ToLower(a[i].Recipe) < strings.ToLower(a[j].Recipe)
-}
-
-// ByName sort a slice of Apps
-type ByName []App
-
-func (a ByName) Len() int      { return len(a) }
-func (a ByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a ByName) Less(i, j int) bool {
-	return strings.ToLower(a[i].Name) < strings.ToLower(a[j].Name)
-}
-
-func ReadAppEnvFile(appFile AppFile, name AppName) (App, error) {
-	env, err := ReadEnv(appFile.Path)
-	if err != nil {
-		return App{}, fmt.Errorf("env file for %s couldn't be read: %s", name, err.Error())
-	}
-
-	logrus.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())
-	}
-
-	return app, nil
-}
-
-// NewApp creates new App object
-func NewApp(env AppEnv, name string, appFile AppFile) (App, error) {
-	domain := env["DOMAIN"]
-
-	recipe, exists := env["RECIPE"]
-	if !exists {
-		recipe, exists = env["TYPE"]
-		if !exists {
-			return App{}, fmt.Errorf("%s is missing the TYPE env var?", name)
-		}
-	}
-
-	return App{
-		Name:   name,
-		Domain: domain,
-		Recipe: recipe,
-		Env:    env,
-		Server: appFile.Server,
-		Path:   appFile.Path,
-	}, nil
-}
-
-// LoadAppFiles gets all app files for a given set of servers or all servers.
-func LoadAppFiles(servers ...string) (AppFiles, error) {
-	appFiles := make(AppFiles)
-	if len(servers) == 1 {
-		if servers[0] == "" {
-			// Empty servers flag, one string will always be passed
-			var err error
-			servers, err = GetAllFoldersInDirectory(SERVERS_DIR)
-			if err != nil {
-				return appFiles, err
-			}
-		}
-	}
-
-	logrus.Debugf("collecting metadata from %v servers: %s", len(servers), strings.Join(servers, ", "))
-
-	for _, server := range servers {
-		serverDir := path.Join(SERVERS_DIR, server)
-		files, err := GetAllFilesInDirectory(serverDir)
-		if err != nil {
-			return appFiles, fmt.Errorf("server %s doesn't exist? Run \"abra server ls\" to check", server)
-		}
-
-		for _, file := range files {
-			appName := strings.TrimSuffix(file.Name(), ".env")
-			appFilePath := path.Join(SERVERS_DIR, server, file.Name())
-			appFiles[appName] = AppFile{
-				Path:   appFilePath,
-				Server: server,
-			}
-		}
-	}
-
-	return appFiles, nil
-}
-
-// GetApp loads an apps settings, reading it from file, in preparation to use
-// it. It should only be used when ready to use the env file to keep IO
-// operations down.
-func GetApp(apps AppFiles, name AppName) (App, error) {
-	appFile, exists := apps[name]
-	if !exists {
-		return App{}, fmt.Errorf("cannot find app with name %s", name)
-	}
-
-	app, err := ReadAppEnvFile(appFile, name)
-	if err != nil {
-		return App{}, err
-	}
-
-	return app, nil
-}
-
-// GetApps returns a slice of Apps with their env files read from a given
-// slice of AppFiles.
-func GetApps(appFiles AppFiles, recipeFilter string) ([]App, error) {
-	var apps []App
-
-	for name := range appFiles {
-		app, err := GetApp(appFiles, name)
-		if err != nil {
-			return nil, err
-		}
-
-		if recipeFilter != "" {
-			if app.Recipe == recipeFilter {
-				apps = append(apps, app)
-			}
-		} else {
-			apps = append(apps, app)
-		}
-	}
-
-	return apps, nil
-}
-
-// GetAppServiceNames retrieves a list of app service names.
-func GetAppServiceNames(appName string) ([]string, error) {
-	var serviceNames []string
-
-	appFiles, err := LoadAppFiles("")
-	if err != nil {
-		return serviceNames, err
-	}
-
-	app, err := GetApp(appFiles, appName)
-	if err != nil {
-		return serviceNames, err
-	}
-
-	composeFiles, err := GetComposeFiles(app.Recipe, app.Env)
-	if err != nil {
-		return serviceNames, err
-	}
-
-	opts := stack.Deploy{Composefiles: composeFiles}
-	compose, err := GetAppComposeConfig(app.Recipe, opts, app.Env)
-	if err != nil {
-		return serviceNames, err
-	}
-
-	for _, service := range compose.Services {
-		serviceNames = append(serviceNames, service.Name)
-	}
-
-	return serviceNames, nil
-}
-
-// GetAppNames retrieves a list of app names.
-func GetAppNames() ([]string, error) {
-	var appNames []string
-
-	appFiles, err := LoadAppFiles("")
-	if err != nil {
-		return appNames, err
-	}
-
-	apps, err := GetApps(appFiles, "")
-	if err != nil {
-		return appNames, err
-	}
-
-	for _, app := range apps {
-		appNames = append(appNames, app.Name)
-	}
-
-	return appNames, nil
-}
-
-// TemplateAppEnvSample copies the example env file for the app into the users
-// env files.
-func TemplateAppEnvSample(recipeName, appName, server, domain string) error {
-	envSamplePath := path.Join(RECIPES_DIR, recipeName, ".env.sample")
-	envSample, err := ioutil.ReadFile(envSamplePath)
-	if err != nil {
-		return err
-	}
-
-	appEnvPath := path.Join(ABRA_DIR, "servers", server, fmt.Sprintf("%s.env", appName))
-	if _, err := os.Stat(appEnvPath); !os.IsNotExist(err) {
-		return fmt.Errorf("%s already exists?", appEnvPath)
-	}
-
-	err = ioutil.WriteFile(appEnvPath, envSample, 0o664)
-	if err != nil {
-		return err
-	}
-
-	read, err := ioutil.ReadFile(appEnvPath)
-	if err != nil {
-		return err
-	}
-
-	newContents := strings.Replace(string(read), recipeName+".example.com", domain, -1)
-
-	err = ioutil.WriteFile(appEnvPath, []byte(newContents), 0)
-	if err != nil {
-		return err
-	}
-
-	logrus.Debugf("copied & templated %s to %s", envSamplePath, appEnvPath)
-
-	return nil
-}
-
-// SanitiseAppName makes a app name usable with Docker by replacing illegal
-// characters.
-func SanitiseAppName(name string) string {
-	return strings.ReplaceAll(name, ".", "_")
-}
-
-// GetAppStatuses queries servers to check the deployment status of given apps.
-func GetAppStatuses(apps []App, MachineReadable bool) (map[string]map[string]string, error) {
-	statuses := make(map[string]map[string]string)
-
-	servers := make(map[string]struct{})
-	for _, app := range apps {
-		if _, ok := servers[app.Server]; !ok {
-			servers[app.Server] = struct{}{}
-		}
-	}
-
-	var bar *progressbar.ProgressBar
-	if !MachineReadable {
-		bar = formatter.CreateProgressbar(len(servers), "querying remote servers...")
-	}
-
-	ch := make(chan stack.StackStatus, len(servers))
-	for server := range servers {
-		cl, err := client.New(server)
-		if err != nil {
-			return statuses, err
-		}
-
-		go func(s string) {
-			ch <- stack.GetAllDeployedServices(cl, s)
-			if !MachineReadable {
-				bar.Add(1)
-			}
-		}(server)
-	}
-
-	for range servers {
-		status := <-ch
-		if status.Err != nil {
-			return statuses, status.Err
-		}
-
-		for _, service := range status.Services {
-			result := make(map[string]string)
-			name := service.Spec.Labels[convert.LabelNamespace]
-
-			if _, ok := statuses[name]; !ok {
-				result["status"] = "deployed"
-			}
-
-			labelKey := fmt.Sprintf("coop-cloud.%s.chaos", name)
-			chaos, ok := service.Spec.Labels[labelKey]
-			if ok {
-				result["chaos"] = chaos
-			}
-
-			labelKey = fmt.Sprintf("coop-cloud.%s.chaos-version", name)
-			if chaosVersion, ok := service.Spec.Labels[labelKey]; ok {
-				result["chaosVersion"] = chaosVersion
-			}
-
-			labelKey = fmt.Sprintf("coop-cloud.%s.autoupdate", name)
-			if autoUpdate, ok := service.Spec.Labels[labelKey]; ok {
-				result["autoUpdate"] = autoUpdate
-			} else {
-				result["autoUpdate"] = "false"
-			}
-
-			labelKey = fmt.Sprintf("coop-cloud.%s.version", name)
-			if version, ok := service.Spec.Labels[labelKey]; ok {
-				result["version"] = version
-			} else {
-				continue
-			}
-
-			statuses[name] = result
-		}
-	}
-
-	logrus.Debugf("retrieved app statuses: %s", statuses)
-
-	return statuses, nil
-}
-
-// ensurePathExists ensures that a path exists.
-func ensurePathExists(path string) error {
-	if _, err := os.Stat(path); err != nil && os.IsNotExist(err) {
-		return err
-	}
-	return nil
-}
-
-// GetComposeFiles gets the list of compose files for an app (or recipe if you
-// don't already have an app) which should be merged into a composetypes.Config
-// while respecting the COMPOSE_FILE env var.
-func GetComposeFiles(recipe string, appEnv AppEnv) ([]string, error) {
-	var composeFiles []string
-
-	composeFileEnvVar, ok := appEnv["COMPOSE_FILE"]
-	if !ok {
-		path := fmt.Sprintf("%s/%s/compose.yml", RECIPES_DIR, recipe)
-		if err := ensurePathExists(path); err != nil {
-			return composeFiles, err
-		}
-		logrus.Debugf("no COMPOSE_FILE detected, loading default: %s", path)
-		composeFiles = append(composeFiles, path)
-		return composeFiles, nil
-	}
-
-	if !strings.Contains(composeFileEnvVar, ":") {
-		path := fmt.Sprintf("%s/%s/%s", RECIPES_DIR, recipe, composeFileEnvVar)
-		if err := ensurePathExists(path); err != nil {
-			return composeFiles, err
-		}
-		logrus.Debugf("COMPOSE_FILE detected, loading %s", path)
-		composeFiles = append(composeFiles, path)
-		return composeFiles, nil
-	}
-
-	numComposeFiles := strings.Count(composeFileEnvVar, ":") + 1
-	envVars := strings.SplitN(composeFileEnvVar, ":", numComposeFiles)
-	if len(envVars) != numComposeFiles {
-		return composeFiles, fmt.Errorf("COMPOSE_FILE (=\"%s\") parsing failed?", composeFileEnvVar)
-	}
-
-	for _, file := range envVars {
-		path := fmt.Sprintf("%s/%s/%s", RECIPES_DIR, recipe, file)
-		if err := ensurePathExists(path); err != nil {
-			return composeFiles, err
-		}
-		composeFiles = append(composeFiles, path)
-	}
-
-	logrus.Debugf("COMPOSE_FILE detected (%s), loading %s", composeFileEnvVar, strings.Join(envVars, ", "))
-	logrus.Debugf("retrieved %s configs for %s", strings.Join(composeFiles, ", "), recipe)
-
-	return composeFiles, nil
-}
-
-// GetAppComposeConfig retrieves a compose specification for a recipe. This
-// specification is the result of a merge of all the compose.**.yml files in
-// the recipe repository.
-func GetAppComposeConfig(recipe string, opts stack.Deploy, appEnv AppEnv) (*composetypes.Config, error) {
-	compose, err := loader.LoadComposefile(opts, appEnv)
-	if err != nil {
-		return &composetypes.Config{}, err
-	}
-
-	logrus.Debugf("retrieved %s for %s", compose.Filename, recipe)
-
-	return compose, nil
-}
-
-// ExposeAllEnv exposes all env variables to the app container
-func ExposeAllEnv(stackName string, compose *composetypes.Config, appEnv AppEnv) {
-	for _, service := range compose.Services {
-		if service.Name == "app" {
-			logrus.Debugf("Add the following environment to the app service config of %s:", stackName)
-			for k, v := range appEnv {
-				_, exists := service.Environment[k]
-				if !exists {
-					value := v
-					service.Environment[k] = &value
-					logrus.Debugf("Add Key: %s Value: %s to %s", k, value, stackName)
-				}
-			}
-		}
-	}
-}
-
-// SetRecipeLabel adds the label 'coop-cloud.${STACK_NAME}.recipe=${RECIPE}' to the app container
-// to signal which recipe is connected to the deployed app
-func SetRecipeLabel(compose *composetypes.Config, stackName string, recipe string) {
-	for _, service := range compose.Services {
-		if service.Name == "app" {
-			logrus.Debugf("set recipe label 'coop-cloud.%s.recipe' to %s for %s", stackName, recipe, stackName)
-			labelKey := fmt.Sprintf("coop-cloud.%s.recipe", stackName)
-			service.Deploy.Labels[labelKey] = recipe
-		}
-	}
-}
-
-// SetChaosLabel adds the label 'coop-cloud.${STACK_NAME}.chaos=true/false' to the app container
-// to signal if the app is deployed in chaos mode
-func SetChaosLabel(compose *composetypes.Config, stackName string, chaos bool) {
-	for _, service := range compose.Services {
-		if service.Name == "app" {
-			logrus.Debugf("set label 'coop-cloud.%s.chaos' to %v for %s", stackName, chaos, stackName)
-			labelKey := fmt.Sprintf("coop-cloud.%s.chaos", stackName)
-			service.Deploy.Labels[labelKey] = strconv.FormatBool(chaos)
-		}
-	}
-}
-
-// SetChaosVersionLabel adds the label 'coop-cloud.${STACK_NAME}.chaos-version=$(GIT_COMMIT)' to the app container
-func SetChaosVersionLabel(compose *composetypes.Config, stackName string, chaosVersion string) {
-	for _, service := range compose.Services {
-		if service.Name == "app" {
-			logrus.Debugf("set label 'coop-cloud.%s.chaos-version' to %v for %s", stackName, chaosVersion, stackName)
-			labelKey := fmt.Sprintf("coop-cloud.%s.chaos-version", stackName)
-			service.Deploy.Labels[labelKey] = chaosVersion
-		}
-	}
-}
-
-// SetUpdateLabel adds env ENABLE_AUTO_UPDATE as label to enable/disable the
-// auto update process for this app. The default if this variable is not set is to disable
-// the auto update process.
-func SetUpdateLabel(compose *composetypes.Config, stackName string, appEnv AppEnv) {
-	for _, service := range compose.Services {
-		if service.Name == "app" {
-			enable_auto_update, exists := appEnv["ENABLE_AUTO_UPDATE"]
-			if !exists {
-				enable_auto_update = "false"
-			}
-			logrus.Debugf("set label 'coop-cloud.%s.autoupdate' to %s for %s", stackName, enable_auto_update, stackName)
-			labelKey := fmt.Sprintf("coop-cloud.%s.autoupdate", stackName)
-			service.Deploy.Labels[labelKey] = enable_auto_update
-		}
-	}
-}
-
-// GetLabel reads docker labels in the format of "coop-cloud.${STACK_NAME}.${LABEL}" from the local compose files
-func GetLabel(compose *composetypes.Config, stackName string, label string) string {
-	for _, service := range compose.Services {
-		if service.Name == "app" {
-			labelKey := fmt.Sprintf("coop-cloud.%s.%s", stackName, label)
-			logrus.Debugf("get label '%s'", labelKey)
-			if labelValue, ok := service.Deploy.Labels[labelKey]; ok {
-				return labelValue
-			}
-		}
-	}
-	logrus.Debugf("no %s label found for %s", label, stackName)
-	return ""
-}
-
-// GetTimeoutFromLabel reads the timeout value from docker label "coop-cloud.${STACK_NAME}.TIMEOUT" and returns 50 as default value
-func GetTimeoutFromLabel(compose *composetypes.Config, stackName string) (int, error) {
-	timeout := 50 // Default Timeout
-	var err error = nil
-	if timeoutLabel := GetLabel(compose, stackName, "timeout"); timeoutLabel != "" {
-		logrus.Debugf("timeout label: %s", timeoutLabel)
-		timeout, err = strconv.Atoi(timeoutLabel)
-	}
-	return timeout, err
-}

pkg/config/env.go

@@ -1,51 +1,23 @@
 package config
 
 import (
-	"bufio"
-	"fmt"
+	"errors"
 	"io/fs"
 	"io/ioutil"
 	"os"
 	"path"
 	"path/filepath"
-	"regexp"
-	"sort"
 	"strings"
 
-	"git.coopcloud.tech/coop-cloud/godotenv"
-	"github.com/sirupsen/logrus"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 )
 
-// getBaseDir retrieves the Abra base directory.
-func getBaseDir() string {
-	home := os.ExpandEnv("$HOME/.abra")
-	if customAbraDir, exists := os.LookupEnv("ABRA_DIR"); exists && customAbraDir != "" {
-		home = customAbraDir
-	}
-	return home
-}
-
-var ABRA_DIR = getBaseDir()
-var SERVERS_DIR = path.Join(ABRA_DIR, "servers")
-var RECIPES_DIR = path.Join(ABRA_DIR, "recipes")
-var VENDOR_DIR = path.Join(ABRA_DIR, "vendor")
-var BACKUP_DIR = path.Join(ABRA_DIR, "backups")
-var CATALOGUE_DIR = path.Join(ABRA_DIR, "catalogue")
-var RECIPES_JSON = path.Join(ABRA_DIR, "catalogue", "recipes.json")
-var REPOS_BASE_URL = "https://git.coopcloud.tech/coop-cloud"
-var CATALOGUE_JSON_REPO_NAME = "recipes-catalogue-json"
-var SSH_URL_TEMPLATE = "ssh://git@git.coopcloud.tech:2222/coop-cloud/%s.git"
-
 const MAX_SANITISED_APP_NAME_LENGTH = 45
 const MAX_DOCKER_SECRET_LENGTH = 64
 
 var BackupbotLabel = "coop-cloud.backupbot.enabled"
 
-// 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"}
-
 // GetServers retrieves all servers.
 func GetServers() ([]string, error) {
 	var servers []string
@@ -55,37 +27,16 @@ func GetServers() ([]string, error) {
 		return servers, err
 	}
 
-	logrus.Debugf("retrieved %v servers: %s", len(servers), servers)
-
-	return servers, nil
-}
-
-// ReadEnv loads an app envivornment into a map.
-func ReadEnv(filePath string) (AppEnv, error) {
-	var envVars AppEnv
-
-	envVars, _, err := godotenv.Read(filePath)
-	if err != nil {
-		return nil, err
+	var filtered []string
+	for _, s := range servers {
+		if !strings.HasPrefix(s, ".") {
+			filtered = append(filtered, s)
+		}
 	}
 
-	logrus.Debugf("read %s from %s", envVars, filePath)
+	log.Debug(i18n.G("retrieved %v servers: %s", len(filtered), filtered))
 
-	return envVars, nil
-}
-
-// ReadEnv loads an app envivornment and their modifiers in two different maps.
-func ReadEnvWithModifiers(filePath string) (AppEnv, AppModifiers, error) {
-	var envVars AppEnv
-
-	envVars, mods, err := godotenv.Read(filePath)
-	if err != nil {
-		return nil, mods, err
-	}
-
-	logrus.Debugf("read %s from %s", envVars, filePath)
-
-	return envVars, mods, nil
+	return filtered, nil
 }
 
 // ReadServerNames retrieves all server names.
@@ -96,7 +47,7 @@ func ReadServerNames() ([]string, error) {
 		return nil, err
 	}
 
-	logrus.Debugf("read %s from %s", strings.Join(serverNames, ","), SERVERS_DIR)
+	log.Debug(i18n.G("read %s from %s", strings.Join(serverNames, ","), SERVERS_DIR))
 
 	return serverNames, nil
 }
@@ -120,7 +71,7 @@ func GetAllFilesInDirectory(directory string) ([]fs.FileInfo, error) {
 
 		realPath, err := filepath.EvalSymlinks(filePath)
 		if err != nil {
-			logrus.Warningf("broken symlink in your abra config folders: %s", filePath)
+			log.Warn(i18n.G("broken symlink in your abra config folders: %s", filePath))
 		} else {
 			realFile, err := os.Stat(realPath)
 			if err != nil {
@@ -144,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(i18n.G("directory is empty: %s", directory))
 	}
 
 	for _, file := range files {
@@ -153,7 +104,7 @@ func GetAllFoldersInDirectory(directory string) ([]string, error) {
 			filePath := path.Join(directory, file.Name())
 			realDir, err := filepath.EvalSymlinks(filePath)
 			if err != nil {
-				logrus.Warningf("broken symlink in your abra config folders: %s", filePath)
+				log.Warn(i18n.G("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())
@@ -163,119 +114,3 @@ func GetAllFoldersInDirectory(directory string) ([]string, error) {
 
 	return folders, nil
 }
-
-// ReadAbraShEnvVars reads env vars from an abra.sh recipe file.
-func ReadAbraShEnvVars(abraSh string) (map[string]string, error) {
-	envVars := make(map[string]string)
-
-	file, err := os.Open(abraSh)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return envVars, nil
-		}
-		return envVars, err
-	}
-	defer file.Close()
-
-	exportRegex, err := regexp.Compile(`^export\s+(\w+=\w+)`)
-	if err != nil {
-		return envVars, err
-	}
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		txt := scanner.Text()
-		if exportRegex.MatchString(txt) {
-			splitVals := strings.Split(txt, "export ")
-			envVarDef := splitVals[len(splitVals)-1]
-			keyVal := strings.Split(envVarDef, "=")
-			if len(keyVal) != 2 {
-				return envVars, fmt.Errorf("couldn't parse %s", txt)
-			}
-			envVars[keyVal[0]] = keyVal[1]
-		}
-	}
-
-	if len(envVars) > 0 {
-		logrus.Debugf("read %s from %s", envVars, abraSh)
-	} else {
-		logrus.Debugf("read 0 env var exports from %s", abraSh)
-	}
-
-	return envVars, nil
-}
-
-type EnvVar struct {
-	Name    string
-	Present bool
-}
-
-func CheckEnv(app App) ([]EnvVar, error) {
-	var envVars []EnvVar
-
-	envSamplePath := path.Join(RECIPES_DIR, app.Recipe, ".env.sample")
-	if _, err := os.Stat(envSamplePath); err != nil {
-		if os.IsNotExist(err) {
-			return envVars, fmt.Errorf("%s does not exist?", envSamplePath)
-		}
-		return envVars, err
-	}
-
-	envSample, err := ReadEnv(envSamplePath)
-	if err != nil {
-		return envVars, err
-	}
-
-	var keys []string
-	for key := range envSample {
-		keys = append(keys, key)
-	}
-
-	sort.Strings(keys)
-
-	for _, key := range keys {
-		if _, ok := app.Env[key]; ok {
-			envVars = append(envVars, EnvVar{Name: key, Present: true})
-		} else {
-			envVars = append(envVars, EnvVar{Name: key, Present: false})
-		}
-	}
-
-	return envVars, nil
-}
-
-// ReadAbraShCmdNames reads the names of commands.
-func ReadAbraShCmdNames(abraSh string) ([]string, error) {
-	var cmdNames []string
-
-	file, err := os.Open(abraSh)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return cmdNames, nil
-		}
-		return cmdNames, err
-	}
-	defer file.Close()
-
-	cmdNameRegex, err := regexp.Compile(`(\w+)(\(\).*\{)`)
-	if err != nil {
-		return cmdNames, err
-	}
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := scanner.Text()
-		matches := cmdNameRegex.FindStringSubmatch(line)
-		if len(matches) > 0 {
-			cmdNames = append(cmdNames, matches[1])
-		}
-	}
-
-	if len(cmdNames) > 0 {
-		logrus.Debugf("read %s from %s", strings.Join(cmdNames, " "), abraSh)
-	} else {
-		logrus.Debugf("read 0 command names from %s", abraSh)
-	}
-
-	return cmdNames, nil
-}

pkg/config/testdata/abraconfig1/abra.yaml

@@ -0,0 +1 @@
+abraDir: foobar

pkg/container/container.go

@@ -2,16 +2,18 @@ package container
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strings"
 
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
 	"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/client"
-	"github.com/sirupsen/logrus"
 )
 
 // 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(i18n.G("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, i18n.G("%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(i18n.G("expected 1 container but found %v: %s", len(containers), strings.Join(containersRaw, " ")))
 			return types.Container{}, err
 		}
 
-		logrus.Warnf("ambiguous container list received, prompting for input")
+		log.Warnf(i18n.G("ambiguous container list received, prompting for input"))
 
 		var response string
 		prompt := &survey.Select{
-			Message: "which container are you looking for?",
+			Message: i18n.G("which container are you looking for?"),
 			Options: containersRaw,
 		}
 
@@ -64,7 +66,7 @@ func GetContainer(c context.Context, cl *client.Client, filters filters.Args, no
 			}
 		}
 
-		logrus.Panic("failed to match chosen container")
+		log.Fatal(i18n.G("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

@@ -3,6 +3,7 @@ package context
 import (
 	"errors"
 
+	"coopcloud.tech/abra/pkg/i18n"
 	"github.com/docker/cli/cli/command"
 	dConfig "github.com/docker/cli/cli/config"
 	"github.com/docker/cli/cli/context"
@@ -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(i18n.G("context lacks Docker endpoint"))
 		return "", err
 	}
 	return endpointmeta.Host, nil

pkg/deploy/utils.go

@@ -0,0 +1,320 @@
+package deploy
+
+import (
+	"context"
+	"errors"
+	"sort"
+	"strings"
+
+	appPkg "coopcloud.tech/abra/pkg/app"
+	"coopcloud.tech/abra/pkg/envfile"
+	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/secret"
+
+	"github.com/distribution/reference"
+	composetypes "github.com/docker/cli/cli/compose/types"
+	"github.com/docker/docker/api/types/swarm"
+	dockerClient "github.com/docker/docker/client"
+)
+
+// MergeAbraShEnv merges abra.sh env vars into the app env vars.
+func MergeAbraShEnv(recipe recipe.Recipe, env envfile.AppEnv) error {
+	abraShEnv, err := envfile.ReadAbraShEnvVars(recipe.AbraShPath)
+	if err != nil {
+		return err
+	}
+
+	for k, v := range abraShEnv {
+		log.Debugf(i18n.G("read v:%s k: %s", v, k))
+		env[k] = v
+	}
+
+	return nil
+}
+
+// GetEntityNameAndVersion parses a full name like `app_example_com_someconf_v1` to extract name and version, ("someconf", "v1")
+func GetEntityNameAndVersion(fullName string, stackName string) (string, string, error) {
+	name := strings.TrimPrefix(fullName, stackName+"_")
+	if lastUnderscore := strings.LastIndex(name, "_"); lastUnderscore != -1 {
+		return name[0:lastUnderscore], name[lastUnderscore+1:], nil
+	}
+	return "", "", errors.New(i18n.G("can't parse version from '%s'", fullName))
+}
+
+func GetSecretsForStack(cl *dockerClient.Client, app appPkg.App) (map[string]string, error) {
+	filters, err := app.Filters(false, false)
+	if err != nil {
+		return nil, err
+	}
+
+	// List all services in the stack
+	// NOTE: we could do cl.SecretList, but we want to know which secrets are actually attached
+	services, err := cl.ServiceList(context.Background(), swarm.ServiceListOptions{
+		Filters: filters,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	secrets := make(map[string]string)
+
+	for _, service := range services {
+		if service.Spec.TaskTemplate.ContainerSpec.Secrets != nil {
+			for _, secretRef := range service.Spec.TaskTemplate.ContainerSpec.Secrets {
+				secretName := secretRef.SecretName
+				if secretName == "" {
+					continue
+				}
+				secretBaseName, secretVersion, err := GetEntityNameAndVersion(secretName, app.StackName())
+				if err != nil {
+					log.Warn(err)
+					continue
+				}
+
+				existingSecretVersion, exists := secrets[secretBaseName]
+				if !exists {
+					// First time seeing this, add to map
+					secrets[secretBaseName] = secretVersion
+				} else {
+					// Just make sure the versions are the same..
+					if existingSecretVersion != secretVersion {
+						log.Warnf(i18n.G("different versions for secret '%s', '%s' and %s'", secretBaseName, existingSecretVersion, secretVersion))
+					}
+				}
+			}
+		}
+	}
+	return secrets, nil
+}
+
+// GetConfigsForStack retrieves all Docker configs attached to services in a given stack.
+func GetConfigsForStack(cl *dockerClient.Client, app appPkg.App) (map[string]string, error) {
+	filters, err := app.Filters(false, false)
+	if err != nil {
+		return nil, err
+	}
+
+	// List all services in the stack
+	services, err := cl.ServiceList(context.Background(), swarm.ServiceListOptions{
+		Filters: filters,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Collect unique config names with versions
+	configs := make(map[string]string)
+	for _, service := range services {
+		if service.Spec.TaskTemplate.ContainerSpec != nil {
+			for _, configRef := range service.Spec.TaskTemplate.ContainerSpec.Configs {
+				configName := configRef.ConfigName
+				if configName == "" {
+					continue
+				}
+				configBaseName, configVersion, err := GetEntityNameAndVersion(configName, app.StackName())
+				if err != nil {
+					log.Warn(err)
+					continue
+				}
+
+				existingConfigVersion, ok := configs[configBaseName]
+				if !ok {
+					// First time seeing this, add to map
+					configs[configBaseName] = configVersion
+				} else {
+					// Just make sure the versions are the same..
+					if existingConfigVersion != configVersion {
+						log.Warnf(i18n.G("different versions for config '%s', '%s' and %s'", configBaseName, existingConfigVersion, configVersion))
+					}
+				}
+			}
+		}
+	}
+
+	return configs, nil
+}
+
+// GetImagesForStack retrieves all Docker images for services in a given stack.
+func GetImagesForStack(cl *dockerClient.Client, app appPkg.App) (map[string]string, error) {
+	filters, err := app.Filters(false, false)
+	if err != nil {
+		return nil, err
+	}
+
+	// List all services in the stack
+	services, err := cl.ServiceList(context.Background(), swarm.ServiceListOptions{
+		Filters: filters,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Collect unique image names with versions
+	images := make(map[string]string)
+	for _, service := range services {
+		if service.Spec.TaskTemplate.ContainerSpec != nil {
+			imageName := service.Spec.TaskTemplate.ContainerSpec.Image
+
+			imageParsed, err := reference.ParseNormalizedNamed(imageName)
+			if err != nil {
+				log.Warn(err)
+				continue
+			}
+
+			imageBaseName := reference.Path(imageParsed)
+			imageTag := imageParsed.(reference.NamedTagged).Tag()
+
+			existingImageVersion, ok := images[imageBaseName]
+			if !ok {
+				// First time seeing this, add to map
+				images[imageBaseName] = imageTag
+			} else {
+				// Just make sure the versions are the same..
+				if existingImageVersion != imageTag {
+					log.Warnf(i18n.G("different versions for image '%s', '%s' and %s'", imageBaseName, existingImageVersion, imageTag))
+				}
+			}
+		}
+	}
+
+	return images, nil
+}
+
+func GatherSecretsForDeploy(cl *dockerClient.Client, app appPkg.App, showUnchanged bool) ([]string, error) {
+	// Get current secrets from existing deployment
+	currentSecrets, err := GetSecretsForStack(cl, app)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Debugf(i18n.G("current secrets: %v", currentSecrets))
+
+	newSecrets, err := secret.PollSecretsStatus(cl, app)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Debugf(i18n.G("new secrets: %v", newSecrets))
+
+	// Sort secrets to ensure reproducible output
+	sort.Slice(newSecrets, func(i, j int) bool {
+		return newSecrets[i].LocalName < newSecrets[j].LocalName
+	})
+
+	var secretInfo []string
+
+	for _, newSecret := range newSecrets {
+		if currentVersion, exists := currentSecrets[newSecret.LocalName]; exists {
+			if currentVersion == newSecret.Version {
+				if showUnchanged {
+					secretInfo = append(secretInfo, i18n.G("%s: %s (unchanged)", newSecret.LocalName, newSecret.Version))
+				}
+			} else {
+				secretInfo = append(secretInfo, i18n.G("%s: %s → %s", newSecret.LocalName, currentVersion, newSecret.Version))
+			}
+		} else {
+			secretInfo = append(secretInfo, i18n.G("%s: %s (new)", newSecret.LocalName, newSecret.Version))
+		}
+	}
+
+	return secretInfo, nil
+}
+
+func GatherConfigsForDeploy(cl *dockerClient.Client, app appPkg.App, compose *composetypes.Config, abraShEnv map[string]string, showUnchanged bool) ([]string, error) {
+	// Get current configs from existing deployment
+	currentConfigs, err := GetConfigsForStack(cl, app)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Debugf(i18n.G("deployed config names: %v", currentConfigs))
+
+	// Get new configs from the compose specification
+	newConfigs := compose.Configs
+
+	var configInfo []string
+	for configName := range newConfigs {
+		log.Debugf(i18n.G("searching abra.sh for version for %s", configName))
+		versionKey := strings.ToUpper(configName) + "_VERSION"
+		newVersion, exists := abraShEnv[versionKey]
+		if !exists {
+			log.Warnf(i18n.G("no version found for config %s", configName))
+			configInfo = append(configInfo, i18n.G("%s: ? (missing version)", configName))
+			continue
+		}
+
+		if currentVersion, exists := currentConfigs[configName]; exists {
+			if currentVersion == newVersion {
+				if showUnchanged {
+					configInfo = append(configInfo, i18n.G("%s: %s (unchanged)", configName, newVersion))
+				}
+			} else {
+				configInfo = append(configInfo, i18n.G("%s: %s → %s", configName, currentVersion, newVersion))
+			}
+		} else {
+			configInfo = append(configInfo, i18n.G("%s: %s (new)", configName, newVersion))
+		}
+	}
+
+	return configInfo, nil
+}
+
+func GatherImagesForDeploy(cl *dockerClient.Client, app appPkg.App, compose *composetypes.Config, showUnchanged bool) ([]string, error) {
+	// Get current images from existing deployment
+	currentImages, err := GetImagesForStack(cl, app)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Debugf(i18n.G("deployed images: %v", currentImages))
+
+	// Proposed new images from the compose files
+	newImages := make(map[string]string)
+
+	for _, service := range compose.Services {
+		imageParsed, err := reference.ParseNormalizedNamed(service.Image)
+		if err != nil {
+			log.Warn(err)
+			continue
+		}
+
+		imageBaseName := reference.Path(imageParsed)
+		namedTag, ok := imageParsed.(reference.NamedTagged)
+		if !ok {
+			continue
+		}
+		imageTag := namedTag.Tag()
+
+		existingImageVersion, ok := newImages[imageBaseName]
+		if !ok {
+			// First time seeing this, add to map
+			newImages[imageBaseName] = imageTag
+		} else {
+			// Just make sure the versions are the same..
+			if existingImageVersion != imageTag {
+				log.Warnf(i18n.G("different versions for image '%s', '%s' and %s'", imageBaseName, existingImageVersion, imageTag))
+			}
+		}
+	}
+	log.Debugf(i18n.G("proposed images: %v", newImages))
+
+	var imageInfo []string
+	for newImageName, newImageVersion := range newImages {
+		if currentVersion, exists := currentImages[newImageName]; exists {
+			if currentVersion == newImageVersion {
+				if showUnchanged {
+					imageInfo = append(imageInfo, i18n.G("%s: %s (unchanged)", formatter.StripTagMeta(newImageName), newImageVersion))
+				}
+			} else {
+				imageInfo = append(imageInfo, i18n.G("%s: %s → %s", formatter.StripTagMeta(newImageName), currentVersion, newImageVersion))
+			}
+		} else {
+			imageInfo = append(imageInfo, i18n.G("%s: %s (new)", formatter.StripTagMeta(newImageName), newImageVersion))
+		}
+	}
+
+	return imageInfo, nil
+}