fix(config): Removes config file name from abra dir

.drone.yml

@@ -3,14 +3,14 @@ kind: pipeline
 name: coopcloud.tech/abra
 steps:
   - name: make check
-    image: golang:1.22
+    image: golang:1.21
     commands:
       - make check
 
   - name: make test
-    image: golang:1.22
+    image: golang:1.21
     environment:
-      CATL_URL: https://git.coopcloud.tech/toolshed/recipes-catalogue-json.git
+      CATL_URL: https://git.coopcloud.tech/coop-cloud/recipes-catalogue-json.git
     commands:
       - mkdir -p $HOME/.abra
       - git clone $CATL_URL $HOME/.abra/catalogue
@@ -29,7 +29,7 @@ steps:
       event: tag
 
   - name: release
-    image: goreleaser/goreleaser:v2.5.1
+    image: goreleaser/goreleaser:v1.24.0
     environment:
       GITEA_TOKEN:
         from_secret: goreleaser_gitea_token
@@ -47,10 +47,10 @@ steps:
     image: plugins/docker
     settings:
       auto_tag: true
-      username: abra-bot
+      username: 3wordchant
       password:
-        from_secret: git_coopcloud_tech_token_abra_bot
-      repo: git.coopcloud.tech/toolshed/abra
+        from_secret: git_coopcloud_tech_token_3wc
+      repo: git.coopcloud.tech/coop-cloud/abra
       tags: dev
       registry: git.coopcloud.tech
     when:
@@ -71,10 +71,11 @@ steps:
       port: 22
       command_timeout: 60m
       script_stop: true
+      envs: [ DRONE_SOURCE_BRANCH ]
       request_pty: true
       script:
         - |
-          wget https://git.coopcloud.tech/toolshed/abra/raw/branch/main/scripts/tests/run-ci-int -O run-ci-int
+          wget https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/tests/run-ci-int -O run-ci-int
           chmod +x run-ci-int
           sh run-ci-int
     when:

.envrc.sample

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

.gitea/ISSUE_TEMPLATE.md

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

.gitignore

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

.goreleaser.yml

@@ -49,8 +49,6 @@ builds:
       - 5
       - 6
       - 7
-    gcflags:
-      - "all=-l -B"
     ldflags:
       - "-X 'main.Commit={{ .Commit }}'"
       - "-X 'main.Version={{ .Version }}'"

AUTHORS.md

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

Dockerfile

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

Makefile

@@ -2,10 +2,9 @@ ABRA         := ./cmd/abra
 KADABRA      := ./cmd/kadabra
 COMMIT       := $(shell git rev-list -1 HEAD)
 GOPATH       := $(shell go env GOPATH)
-GOVERSION    := 1.22
+GOVERSION    := 1.21
 LDFLAGS      := "-X 'main.Commit=$(COMMIT)'"
 DIST_LDFLAGS := $(LDFLAGS)" -s -w"
-GCFLAGS      := "all=-l -B"
 
 export GOPRIVATE=coopcloud.tech
 
@@ -13,24 +12,22 @@ export GOPRIVATE=coopcloud.tech
 all: format check build-abra test
 
 run-abra:
-	@go run -gcflags=$(GCFLAGS) -ldflags=$(LDFLAGS) $(ABRA)
+	@go run -ldflags=$(LDFLAGS) $(ABRA)
 
 run-kadabra:
-	@go run -gcflags=$(GCFLAGS) -ldflags=$(LDFLAGS) $(KADABRA)
+	@go run -ldflags=$(LDFLAGS) $(KADABRA)
 
 install-abra:
-	@go install -gcflags=$(GCFLAGS) -ldflags=$(LDFLAGS) $(ABRA)
+	@go install -ldflags=$(LDFLAGS) $(ABRA)
 
 install-kadabra:
-	@go install -gcflags=$(GCFLAGS) -ldflags=$(LDFLAGS) $(KADABRA)
-
-install: install-abra install-kadabra
+	@go install -ldflags=$(LDFLAGS) $(KADABRA)
 
 build-abra:
-	@go build -v -gcflags=$(GCFLAGS) -ldflags=$(DIST_LDFLAGS) $(ABRA)
+	@go build -v -ldflags=$(DIST_LDFLAGS) $(ABRA)
 
 build-kadabra:
-	@go build -v -gcflags=$(GCFLAGS) -ldflags=$(DIST_LDFLAGS) $(KADABRA)
+	@go build -v -ldflags=$(DIST_LDFLAGS) $(KADABRA)
 
 build: build-abra build-kadabra
 
@@ -45,10 +42,10 @@ clean:
 	@rm '$(GOPATH)/bin/kadabra'
 
 format:
-	@gofmt -s -w $$(find . -type f -name '*.go' | grep -v "/vendor/")
+	@gofmt -s -w .
 
 check:
-	@test -z $$(gofmt -l $$(find . -type f -name '*.go' | grep -v "/vendor/")) || \
+	@test -z $$(gofmt -l .) || \
 	(echo "gofmt: formatting issue - run 'make format' to resolve" && exit 1)
 
 test:

README.md

@@ -1,7 +1,7 @@
 # `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)
+[![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)
 [![Go Reference](https://pkg.go.dev/badge/coopcloud.tech/abra.svg)](https://pkg.go.dev/coopcloud.tech/abra)
 
 The Co-op Cloud utility belt 🎩🐇

cli/app/app.go

@@ -1,11 +1,34 @@
 package app
 
 import (
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppCommand = &cobra.Command{
-	Use:     "app [cmd] [args] [flags]",
+var AppCommand = cli.Command{
+	Name:      "app",
 	Aliases:   []string{"a"},
-	Short:   "Manage apps",
+	Usage:     "Manage apps",
+	ArgsUsage: "<domain>",
+	Subcommands: []cli.Command{
+		appBackupCommand,
+		appCheckCommand,
+		appCmdCommand,
+		appConfigCommand,
+		appCpCommand,
+		appDeployCommand,
+		appListCommand,
+		appLogsCommand,
+		appNewCommand,
+		appPsCommand,
+		appRemoveCommand,
+		appRestartCommand,
+		appRestoreCommand,
+		appRollbackCommand,
+		appRunCommand,
+		appSecretCommand,
+		appServicesCommand,
+		appUndeployCommand,
+		appUpgradeCommand,
+		appVolumeCommand,
+	},
 }

cli/app/backup.go

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

cli/app/check.go

@@ -1,22 +1,21 @@
 package app
 
 import (
-	"fmt"
-
 	"coopcloud.tech/abra/cli/internal"
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/charmbracelet/lipgloss"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppCheckCommand = &cobra.Command{
-	Use:     "check <domain> [flags]",
+var appCheckCommand = cli.Command{
+	Name:    "check",
 	Aliases: []string{"chk"},
-	Short:   "Ensure an app is well configured",
-	Long: `Compare env vars in both the app ".env" and recipe ".env.sample" file.
+	Usage:   "Ensure an app is well configured",
+	Description: `
+This command compares 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
@@ -26,38 +25,23 @@ 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.`,
-	Args: cobra.ExactArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.AppNameComplete()
+	ArgsUsage: "<domain>",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.ChaosFlag,
+		internal.OfflineFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
 
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
-		table, err := formatter.CreateTable()
-		if err != nil {
-			log.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)
-				}
-			})
+		tableCol := []string{"recipe env sample", "app env"}
+		table := formatter.CreateTable(tableCol)
 
 		envVars, err := appPkg.CheckEnv(app)
 		if err != nil {
@@ -66,26 +50,14 @@ ${FOO:<default>} syntax). "check" does not confirm or deny this for you.`,
 
 		for _, envVar := range envVars {
 			if envVar.Present {
-				val := []string{envVar.Name, "✅"}
-				table.Row(val...)
+				table.Append([]string{envVar.Name, "✅"})
 			} else {
-				val := []string{envVar.Name, "❌"}
-				table.Row(val...)
+				table.Append([]string{envVar.Name, "❌"})
 			}
 		}
 
-		if err := formatter.PrintTable(table); err != nil {
-			log.Fatal(err)
-		}
+		table.Render()
+
+		return nil
 	},
 }
-
-func init() {
-	AppCheckCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-}

cli/app/cmd.go

@@ -5,102 +5,68 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"slices"
 	"sort"
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/app"
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppCmdCommand = &cobra.Command{
-	Use:     "command <domain> [service | --local] <cmd> [[args] [flags] | [flags] -- [args]]",
+var appCmdCommand = cli.Command{
+	Name:    "command",
 	Aliases: []string{"cmd"},
-	Short:   "Run app commands",
-	Long: `Run an app specific command.
+	Usage:   "Run app commands",
+	Description: `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/-l".
+work station by passing "--local". Arguments can be passed into these functions
+using the "-- <args>" syntax.
 
-N.B. If using the "--" style to pass arguments, flags (e.g. "--local/-l") must
-be passed *before* the "--". It is possible to pass arguments without the "--"
-as long as no dashes are present (i.e. "foo" works without "--", "-foo"
-does not).`,
-	Example: `  # pass <cmd> args/flags without "--"
-  abra app cmd 1312.net app my_cmd_arg foo --user bar
+**WARNING**: options must be passed directly after the sub-command "cmd".
 
-  # pass <cmd> args/flags with "--"
-  abra app cmd 1312.net app my_cmd_args --user bar -- foo -vvv
+EXAMPLE:
 
-  # drop the [service] arg if using "--local/-l"
-  abra app cmd 1312.net my_cmd --local`,
-	Args: func(cmd *cobra.Command, args []string) error {
-		if local {
-			if !(len(args) >= 2) {
-				return errors.New("requires at least 2 arguments with --local/-l")
-			}
-
-			if slices.Contains(os.Args, "--") {
-				if cmd.ArgsLenAtDash() > 2 {
-					return errors.New("accepts at most 2 args with --local/-l")
-				}
-			}
-
-			// NOTE(d1): it is unclear how to correctly validate this case
-			//
-			// abra app cmd 1312.net app test_cmd_args foo --local
-			// FATAL <recipe> doesn't have a app function
-			//
-			// "app" should not be there, but there is no reliable way to detect arg
-			// count when the user can pass an arbitrary amount of recipe command
-			// arguments
-			return nil
-		}
-
-		if !(len(args) >= 3) {
-			return errors.New("requires at least 3 arguments")
-		}
-
-		return nil
+  abra app cmd --local 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,
 	},
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		switch l := len(args); l {
+	Before:      internal.SubCommandBefore,
+	Subcommands: []cli.Command{appCmdListCommand},
+	BashComplete: func(ctx *cli.Context) {
+		args := ctx.Args()
+		switch len(args) {
 		case 0:
-			return autocomplete.AppNameComplete()
+			autocomplete.AppNameComplete(ctx)
 		case 1:
-			if !local {
-				return autocomplete.ServiceNameComplete(args[0])
-			}
-			return autocomplete.CommandNameComplete(args[0])
+			autocomplete.ServiceNameComplete(args.Get(0))
 		case 2:
-			if !local {
-				return autocomplete.CommandNameComplete(args[0])
-			}
-			return nil, cobra.ShellCompDirectiveDefault
-		default:
-			return nil, cobra.ShellCompDirectiveError
+			cmdNameComplete(args.Get(0))
 		}
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
 
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
-		if local && remoteUser != "" {
-			log.Fatal("cannot use --local & --user together")
+		if internal.LocalCmd && internal.RemoteUser != "" {
+			internal.ShowSubcommandHelpAndError(c, errors.New("cannot use --local & --user together"))
 		}
 
-		hasCmdArgs, parsedCmdArgs := parseCmdArgs(args, local)
+		hasCmdArgs, parsedCmdArgs := parseCmdArgs(c.Args(), internal.LocalCmd)
 
 		if _, err := os.Stat(app.Recipe.AbraShPath); err != nil {
 			if os.IsNotExist(err) {
@@ -109,8 +75,12 @@ does not).`,
 			log.Fatal(err)
 		}
 
-		if local {
-			cmdName := args[1]
+		if internal.LocalCmd {
+			if !(len(c.Args()) >= 2) {
+				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
+			}
+
+			cmdName := c.Args().Get(1)
 			if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
 				log.Fatal(err)
 			}
@@ -141,11 +111,14 @@ does not).`,
 			if err := internal.RunCmd(cmd); err != nil {
 				log.Fatal(err)
 			}
-
-			return
+		} else {
+			if !(len(c.Args()) >= 3) {
+				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
 			}
 
-		cmdName := args[2]
+			targetServiceName := c.Args().Get(1)
+
+			cmdName := c.Args().Get(2)
 			if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
 				log.Fatal(err)
 			}
@@ -156,7 +129,6 @@ does not).`,
 			}
 
 			matchingServiceName := false
-		targetServiceName := args[1]
 			for _, serviceName := range serviceNames {
 				if serviceName == targetServiceName {
 					matchingServiceName = true
@@ -180,39 +152,12 @@ does not).`,
 				log.Fatal(err)
 			}
 
-		if err := internal.RunCmdRemote(
-			cl,
-			app,
-			requestTTY,
-			app.Recipe.AbraShPath,
-			targetServiceName, cmdName, parsedCmdArgs, remoteUser); err != nil {
+			if err := internal.RunCmdRemote(cl, app, app.Recipe.AbraShPath, targetServiceName, cmdName, parsedCmdArgs); err != nil {
 				log.Fatal(err)
 			}
-	},
 		}
 
-var AppCmdListCommand = &cobra.Command{
-	Use:     "list <domain> [flags]",
-	Aliases: []string{"ls"},
-	Short:   "List all available commands",
-	Args:    cobra.MinimumNArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
-
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
-			log.Fatal(err)
-		}
-
-		cmdNames, err := appPkg.ReadAbraShCmdNames(app.Recipe.AbraShPath)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		sort.Strings(cmdNames)
-
-		for _, cmdName := range cmdNames {
-			fmt.Println(cmdName)
-		}
+		return nil
 	},
 }
 
@@ -235,42 +180,74 @@ func parseCmdArgs(args []string, isLocal bool) (bool, string) {
 	return hasCmdArgs, parsedCmdArgs
 }
 
-var (
-	local      bool
-	remoteUser string
-	requestTTY bool
-)
-
-func init() {
-	AppCmdCommand.Flags().BoolVarP(
-		&local,
-		"local",
-		"l",
-		false,
-		"run command locally",
-	)
-
-	AppCmdCommand.Flags().StringVarP(
-		&remoteUser,
-		"user",
-		"u",
-		"",
-		"request remote user",
-	)
-
-	AppCmdCommand.Flags().BoolVarP(
-		&requestTTY,
-		"tty",
-		"t",
-		false,
-		"request remote TTY",
-	)
-
-	AppCmdCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
+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)
+
+		if err := app.Recipe.EnsureExists(); err != nil {
+			log.Fatal(err)
+		}
+
+		if !internal.Chaos {
+			if err := app.Recipe.EnsureIsClean(); err != nil {
+				log.Fatal(err)
+			}
+
+			if !internal.Offline {
+				if err := app.Recipe.EnsureUpToDate(); err != nil {
+					log.Fatal(err)
+				}
+			}
+
+			if err := app.Recipe.EnsureLatest(); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		cmdNames, err := getShCmdNames(app)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, cmdName := range cmdNames {
+			fmt.Println(cmdName)
+		}
+
+		return nil
+	},
+}
+
+func getShCmdNames(app appPkg.App) ([]string, error) {
+	cmdNames, err := appPkg.ReadAbraShCmdNames(app.Recipe.AbraShPath)
+	if err != nil {
+		return nil, err
+	}
+
+	sort.Strings(cmdNames)
+	return cmdNames, nil
 }

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/toolshed/organising/issues/336 for more
+		// see https://git.coopcloud.tech/coop-cloud/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,35 +1,40 @@
 package app
 
 import (
+	"errors"
 	"os"
 	"os/exec"
 
+	"coopcloud.tech/abra/cli/internal"
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppConfigCommand = &cobra.Command{
-	Use:     "config <domain> [flags]",
+var appConfigCommand = cli.Command{
+	Name:      "config",
 	Aliases:   []string{"cfg"},
-	Short:   "Edit app config",
-	Example: "  abra config 1312.net",
-	Args:    cobra.ExactArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.AppNameComplete()
+	Usage:     "Edit app config",
+	ArgsUsage: "<domain>",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
+	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 := appPkg.LoadAppFiles("")
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		appName := args[0]
 		appFile, exists := files[appName]
 		if !exists {
 			log.Fatalf("cannot find app with name %s", appName)
@@ -46,12 +51,14 @@ var AppConfigCommand = &cobra.Command{
 			}
 		}
 
-		c := exec.Command(ed, appFile.Path)
-		c.Stdin = os.Stdin
-		c.Stdout = os.Stdout
-		c.Stderr = os.Stderr
-		if err := c.Run(); err != nil {
+		cmd := exec.Command(ed, appFile.Path)
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
 			log.Fatal(err)
 		}
+
+		return nil
 	},
 }

cli/app/cp.go

@@ -22,39 +22,47 @@ import (
 	dockerClient "github.com/docker/docker/client"
 	"github.com/docker/docker/errdefs"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppCpCommand = &cobra.Command{
-	Use:     "cp <domain> <src> <dst> [flags]",
+var appCpCommand = cli.Command{
+	Name:      "cp",
 	Aliases:   []string{"c"},
-	Short:   "Copy files to/from a deployed app service",
-	Example: `  # copy myfile.txt to the root of the app service
-  abra app cp 1312.net myfile.txt app:/
-
-  # 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
-		}
+	ArgsUsage: "<domain> <src> <dst>",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+	Before: internal.SubCommandBefore,
+	Usage:  "Copy files to/from a deployed app service",
+	Description: `
+Copy files to and from any app service file system.
 
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+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)
+
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
-		src := args[1]
-		dst := args[2]
+		src := c.Args().Get(1)
+		dst := c.Args().Get(2)
+		if src == "" {
+			log.Fatal("missing <src> argument")
+		}
+		if dst == "" {
+			log.Fatal("missing <dest> argument")
+		}
+
 		srcPath, dstPath, service, toContainer, err := parseSrcAndDst(src, dst)
 		if err != nil {
 			log.Fatal(err)
@@ -79,6 +87,8 @@ var AppCpCommand = &cobra.Command{
 		if err != nil {
 			log.Fatal(err)
 		}
+
+		return nil
 	},
 }
 
@@ -371,13 +381,3 @@ func moveFile(sourcePath, destPath string) error {
 	}
 	return nil
 }
-
-func init() {
-	AppCpCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-}

cli/app/deploy.go

@@ -2,12 +2,9 @@ package app
 
 import (
 	"context"
-	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/envfile"
 	"coopcloud.tech/abra/pkg/secret"
 
@@ -15,68 +12,54 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/dns"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/stack"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppDeployCommand = &cobra.Command{
-	Use:     "deploy <domain> [version] [flags]",
+var appDeployCommand = cli.Command{
+	Name:      "deploy",
 	Aliases:   []string{"d"},
-	Short:   "Deploy an app",
-	Long: `Deploy an app.
-
-This command supports chaos operations. Use "--chaos/-C" to deploy your recipe
-checkout as-is. Recipe commit hashes are also supported as values for
-"[version]". Please note, "upgrade"/"rollback" do not support chaos operations.`,
-	Example: `  # standard deployment
-  abra app deploy 1312.net
-
-  # chaos deployment
-  abra app deploy 1312.net --chaos
-  
-  # deploy specific version
-  abra app deploy 1312.net 2.0.0+1.2.3
-
-  # deploy a specific git hash
-  abra app deploy 1312.net 886db76d`,
-	Args: cobra.RangeArgs(1, 2),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string,
-	) ([]string, cobra.ShellCompDirective) {
-		switch l := len(args); l {
-		case 0:
-			return autocomplete.AppNameComplete()
-		case 1:
-			app, err := appPkg.Get(args[0])
-			if err != nil {
-				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
-				return []string{errMsg}, cobra.ShellCompDirectiveError
-			}
-			return autocomplete.RecipeVersionComplete(app.Recipe.Name)
-		default:
-			return nil, cobra.ShellCompDirectiveDefault
-		}
+	Usage:     "Deploy an app",
+	ArgsUsage: "<domain> [<version>]",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		internal.ForceFlag,
+		internal.ChaosFlag,
+		internal.NoDomainChecksFlag,
+		internal.DontWaitConvergeFlag,
+		internal.OfflineFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		var (
-			deployWarnMessages   []string
-			toDeployVersion      string
-			isChaosCommit        bool
-			toDeployChaosVersion = config.CHAOS_DEFAULT
-		)
+	Before: internal.SubCommandBefore,
+	Description: `Deploy an app.
 
-		app := internal.ValidateApp(args)
+This command supports chaos operations. Use "--chaos" to deploy your recipe
+checkout as-is. Recipe commit hashes are also supported values for
+"[<version>]". Please note, "upgrade"/"rollback" do not support chaos
+operations.
 
-		if err := validateArgsAndFlags(args); err != nil {
-			log.Fatal(err)
+EXAMPLE:
+
+    abra app deploy foo.example.com
+    abra app deploy foo.example.com 1.2.3+3.2.1
+    abra app deploy foo.example.com 1e83340e`,
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+		stackName := app.StackName()
+
+		specificVersion := c.Args().Get(1)
+		if specificVersion == "" {
+			specificVersion = app.Recipe.Version
+		}
+		if specificVersion != "" && internal.Chaos {
+			log.Fatal("cannot use <version> and --chaos together")
 		}
 
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
@@ -84,50 +67,103 @@ checkout as-is. Recipe commit hashes are also supported as values for
 			log.Fatal(err)
 		}
 
+		log.Debugf("checking whether %s is already deployed", stackName)
+
 		cl, err := client.New(app.Server)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		log.Debugf("checking whether %s is already deployed", app.StackName())
-
-		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		if deployMeta.IsDeployed && !(internal.Force || internal.Chaos) {
-			log.Fatalf("%s is already deployed", app.Name)
-		}
+		// NOTE(d1): handles "<version> as git hash" use case
+		var isChaosCommit bool
 
-		toDeployVersion, toDeployChaosVersion, err = getDeployVersion(args, deployMeta, app)
-		if err != nil {
-			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 := deployMeta.Version
+		if specificVersion != "" {
+			version = specificVersion
+			log.Debugf("choosing %s as version to deploy", version)
 
-		if !internal.Chaos {
-			isChaosCommit, err = app.Recipe.EnsureVersion(toDeployVersion)
+			var err error
+			isChaosCommit, err = app.Recipe.EnsureVersion(version)
 			if err != nil {
 				log.Fatal(err)
 			}
 
 			if isChaosCommit {
-				log.Debugf("assuming chaos commit: %s", toDeployVersion)
-
+				log.Debugf("assuming '%s' is a chaos commit", version)
 				internal.Chaos = true
-				toDeployChaosVersion = toDeployVersion
+			}
+		}
 
-				toDeployVersion, err = app.Recipe.GetVersionLabelLocal()
+		secStats, err := secret.PollSecretsStatus(cl, app)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, secStat := range secStats {
+			if !secStat.CreatedOnRemote {
+				log.Fatalf("unable to deploy, secrets not generated (%s)?", secStat.LocalName)
+			}
+		}
+
+		if deployMeta.IsDeployed {
+			if internal.Force || internal.Chaos {
+				log.Warnf("%s is already deployed but continuing (--force/--chaos)", app.Name)
+			} else {
+				log.Fatalf("%s is already deployed", app.Name)
+			}
+		}
+
+		if !internal.Chaos && specificVersion == "" {
+			versions, err := app.Recipe.Tags()
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			if len(versions) > 0 && !internal.Chaos {
+				version = versions[len(versions)-1]
+				log.Debugf("choosing %s as version to deploy", version)
+				if _, err := app.Recipe.EnsureVersion(version); err != nil {
+					log.Fatal(err)
+				}
+			} else {
+				head, err := git.GetRecipeHead(app.Recipe.Name)
+				if err != nil {
+					log.Fatal(err)
+				}
+				version = formatter.SmallSHA(head.String())
+				log.Warn("no versions detected, using latest commit")
+			}
+		}
+
+		chaosVersion := "false"
+		if internal.Chaos {
+			log.Warnf("chaos mode engaged")
+
+			if isChaosCommit {
+				chaosVersion = specificVersion
+				versionLabelLocal, err := app.Recipe.GetVersionLabelLocal()
+				if err != nil {
+					log.Fatal(err)
+				}
+				version = versionLabelLocal
+			} else {
+				var err error
+				chaosVersion, err = app.Recipe.ChaosVersion()
 				if err != nil {
 					log.Fatal(err)
 				}
 			}
 		}
 
-		if err := validateSecrets(cl, app); err != nil {
-			log.Fatal(err)
-		}
-
 		abraShEnv, err := envfile.ReadAbraShEnvVars(app.Recipe.AbraShPath)
 		if err != nil {
 			log.Fatal(err)
@@ -141,7 +177,6 @@ checkout as-is. Recipe commit hashes are also supported as values for
 			log.Fatal(err)
 		}
 
-		stackName := app.StackName()
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
@@ -154,17 +189,10 @@ checkout as-is. Recipe commit hashes are also supported as values for
 			log.Fatal(err)
 		}
 
-		toDeployChaosVersionLabel := toDeployChaosVersion
-		if app.Recipe.Dirty {
-			toDeployChaosVersionLabel = formatter.AddDirtyMarker(toDeployChaosVersionLabel)
-		}
-
 		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, toDeployChaosVersionLabel)
-		}
+		appPkg.SetChaosVersionLabel(compose, stackName, chaosVersion)
 		appPkg.SetUpdateLabel(compose, stackName, app.Env)
 
 		envVars, err := appPkg.CheckEnv(app)
@@ -174,52 +202,32 @@ checkout as-is. Recipe commit hashes are also supported as values for
 
 		for _, envVar := range envVars {
 			if !envVar.Present {
-				deployWarnMessages = append(deployWarnMessages,
-					fmt.Sprintf("%s missing from %s.env", envVar.Name, app.Domain),
-				)
+				log.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain)
 			}
 		}
 
+		if err := internal.DeployOverview(app, version, chaosVersion, "continue with deployment?"); err != nil {
+			log.Fatal(err)
+		}
+
 		if !internal.NoDomainChecks {
-			if domainName, ok := app.Env["DOMAIN"]; ok {
+			domainName, ok := app.Env["DOMAIN"]
+			if ok {
 				if _, err = dns.EnsureDomainsResolveSameIPv4(domainName, app.Server); err != nil {
 					log.Fatal(err)
 				}
 			} else {
-				log.Debug("skipping domain checks, no DOMAIN=... configured")
+				log.Warn("skipping domain checks as no DOMAIN=... configured for app")
 			}
 		} else {
-			log.Debug("skipping domain checks")
-		}
-
-		deployedVersion := config.NO_VERSION_DEFAULT
-		if deployMeta.IsDeployed {
-			deployedVersion = deployMeta.Version
-		}
-
-		toWriteVersion := toDeployVersion
-		if internal.Chaos || isChaosCommit {
-			toWriteVersion = toDeployChaosVersion
-		}
-
-		if err := internal.DeployOverview(
-			app,
-			deployWarnMessages,
-			deployedVersion,
-			deployMeta.ChaosVersion,
-			toDeployVersion,
-			toDeployChaosVersion,
-			toWriteVersion,
-		); err != nil {
-			log.Fatal(err)
+			log.Warn("skipping domain checks as requested")
 		}
 
 		stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
 		if err != nil {
 			log.Fatal(err)
 		}
-
-		log.Debugf("set waiting timeout to %d second(s)", stack.WaitTimeout)
+		log.Debugf("set waiting timeout to %d s", stack.WaitTimeout)
 
 		if err := stack.RunDeploy(cl, deployOpts, compose, app.Name, internal.DontWaitConverge); err != nil {
 			log.Fatal(err)
@@ -233,143 +241,12 @@ checkout as-is. Recipe commit hashes are also supported as values for
 			}
 		}
 
-		if err := app.WriteRecipeVersion(toWriteVersion, false); err != nil {
-			log.Fatalf("writing recipe version failed: %s", err)
+		if app.Recipe.Version != "" && specificVersion != "" && specificVersion != app.Recipe.Version {
+			err := app.WriteRecipeVersion(specificVersion)
+			if err != nil {
+				log.Fatalf("writing new recipe version in env file: %s", err)
 			}
+		}
+		return nil
 	},
 }
-
-func getChaosVersion(app app.App, toDeployVersion, toDeployChaosVersion *string) error {
-	var err error
-	*toDeployChaosVersion, err = app.Recipe.ChaosVersion()
-	if err != nil {
-		return err
-	}
-
-	*toDeployVersion, err = app.Recipe.GetVersionLabelLocal()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func getLatestVersionOrCommit(app app.App) (string, string, error) {
-	versions, err := app.Recipe.Tags()
-	if err != nil {
-		return "", "", err
-	}
-
-	if len(versions) > 0 && !internal.Chaos {
-		return versions[len(versions)-1], "", nil
-	}
-
-	head, err := app.Recipe.Head()
-	if err != nil {
-		return "", "", err
-	}
-
-	return "", formatter.SmallSHA(head.String()), nil
-}
-
-// validateArgsAndFlags ensures compatible args/flags.
-func validateArgsAndFlags(args []string) error {
-	if len(args) == 2 && args[1] != "" && internal.Chaos {
-		return fmt.Errorf("cannot use [version] and --chaos together")
-	}
-
-	return nil
-}
-
-func validateSecrets(cl *dockerClient.Client, app app.App) error {
-	secStats, err := secret.PollSecretsStatus(cl, app)
-	if err != nil {
-		return err
-	}
-
-	for _, secStat := range secStats {
-		if !secStat.CreatedOnRemote {
-			return fmt.Errorf("secret not generated: %s", secStat.LocalName)
-		}
-	}
-
-	return nil
-}
-
-func getDeployVersion(cliArgs []string, deployMeta stack.DeployMeta, app app.App) (string, string, error) {
-	// Chaos mode overrides everything
-	if internal.Chaos {
-		v, err := app.Recipe.ChaosVersion()
-		if err != nil {
-			return "", "", err
-		}
-		cv, err := app.Recipe.GetVersionLabelLocal()
-		if err != nil {
-			return "", "", err
-		}
-		log.Debugf("version: taking chaos version: %s, %s", v, cv)
-		return v, cv, nil
-	}
-
-	// Check if the deploy version is set with a cli argument
-	if len(cliArgs) == 2 && cliArgs[1] != "" {
-		log.Debugf("version: taking version from cli arg: %s", cliArgs[1])
-		return cliArgs[1], "", nil
-	}
-
-	// Check if the recipe has a version in the .env file
-	if app.Recipe.EnvVersion != "" && !internal.IgnoreEnvVersion {
-		log.Debugf("version: taking version from .env file: %s", app.Recipe.EnvVersion)
-		return app.Recipe.EnvVersion, "", nil
-	}
-
-	// Take deployed version
-	if deployMeta.IsDeployed {
-		log.Debugf("version: taking deployed version: %s", deployMeta.Version)
-		return deployMeta.Version, "", nil
-	}
-
-	v, vc, err := getLatestVersionOrCommit(app)
-	log.Debugf("version: taking new recipe versio: %s, %s", v, vc)
-	if err != nil {
-		log.Fatal(err)
-	}
-	if v == "" {
-		return vc, vc, nil
-	}
-	return v, vc, nil
-}
-
-func init() {
-	AppDeployCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-
-	AppDeployCommand.Flags().BoolVarP(
-		&internal.Force,
-		"force",
-		"f",
-		false,
-		"perform action without further prompt",
-	)
-
-	AppDeployCommand.Flags().BoolVarP(
-		&internal.NoDomainChecks,
-		"no-domain-checks",
-		"D",
-		false,
-		"disable public DNS checks",
-	)
-
-	AppDeployCommand.Flags().BoolVarP(
-		&internal.DontWaitConverge,
-		"no-converge-checks",
-		"c",
-		false,
-		"disable converge logic checks",
-	)
-}

cli/app/env.go

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

cli/app/labels.go

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

cli/app/list.go

@@ -9,11 +9,39 @@ import (
 
 	"coopcloud.tech/abra/cli/internal"
 	appPkg "coopcloud.tech/abra/pkg/app"
-	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/tagcmp"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
+)
+
+var (
+	status     bool
+	statusFlag = &cli.BoolFlag{
+		Name:        "status, S",
+		Usage:       "Show app deployment status",
+		Destination: &status,
+	}
+)
+
+var (
+	recipeFilter string
+	recipeFlag   = &cli.StringFlag{
+		Name:        "recipe, r",
+		Value:       "",
+		Usage:       "Show apps of a specific recipe",
+		Destination: &recipeFilter,
+	}
+)
+
+var (
+	listAppServer     string
+	listAppServerFlag = &cli.StringFlag{
+		Name:        "server, s",
+		Value:       "",
+		Usage:       "Show apps of a specific server",
+		Destination: &listAppServer,
+	}
 )
 
 type appStatus struct {
@@ -38,23 +66,27 @@ type serverStatus struct {
 	UpgradeCount     int         `json:"upgradeCount"`
 }
 
-var AppListCommand = &cobra.Command{
-	Use:     "list [flags]",
+var appListCommand = cli.Command{
+	Name:    "list",
 	Aliases: []string{"ls"},
-	Short:   "List all managed apps",
-	Long: `Generate a report of all managed apps.
+	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.
 
-Use "--status/-S" flag to query all servers for the live deployment status.`,
-	Example: `  # list apps of all servers without live status
-  abra app ls
-
-  # list apps of a specific server with live status
-  abra app ls -s 1312.net -S
-
-  # list apps of all servers which match a specific recipe
-  abra app ls -r gitea`,
-	Args: cobra.NoArgs,
-	Run: func(cmd *cobra.Command, args []string) {
+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 := appPkg.LoadAppFiles(listAppServer)
 		if err != nil {
 			log.Fatal(err)
@@ -173,7 +205,7 @@ Use "--status/-S" flag to query all servers for the live deployment status.`,
 							stats.LatestCount++
 						}
 					} else {
-						newUpdates = internal.SortVersionsDesc(newUpdates)
+						newUpdates = internal.ReverseStringList(newUpdates)
 						appStats.Upgrade = strings.Join(newUpdates, "\n")
 						stats.UpgradeCount++
 					}
@@ -196,8 +228,7 @@ Use "--status/-S" flag to query all servers for the live deployment status.`,
 			} else {
 				fmt.Println(string(jsonstring))
 			}
-
-			return
+			return nil
 		}
 
 		alreadySeen := make(map[string]bool)
@@ -208,27 +239,15 @@ Use "--status/-S" flag to query all servers for the live deployment status.`,
 
 			serverStat := allStats[app.Server]
 
-			headers := []string{"RECIPE", "DOMAIN", "SERVER"}
+			tableCol := []string{"recipe", "domain"}
 			if status {
-				headers = append(headers, []string{
-					"STATUS",
-					"CHAOS",
-					"VERSION",
-					"UPGRADE",
-					"AUTOUPDATE"}...,
-				)
+				tableCol = append(tableCol, []string{"status", "chaos", "version", "upgrade", "autoupdate"}...)
 			}
 
-			table, err := formatter.CreateTable()
-			if err != nil {
-				log.Fatal(err)
-			}
+			table := formatter.CreateTable(tableCol)
 
-			table.Headers(headers...)
-
-			var rows [][]string
 			for _, appStat := range serverStat.Apps {
-				row := []string{appStat.Recipe, appStat.Domain, appStat.Server}
+				tableRow := []string{appStat.Recipe, appStat.Domain}
 				if status {
 					chaosStatus := appStat.Chaos
 					if chaosStatus != "unknown" {
@@ -240,86 +259,40 @@ Use "--status/-S" flag to query all servers for the live deployment status.`,
 							chaosStatus = appStat.ChaosVersion
 						}
 					}
-
-					row = append(row, []string{
-						appStat.Status,
-						chaosStatus,
-						appStat.Version,
-						appStat.Upgrade,
-						appStat.AutoUpdate}...,
-					)
+					tableRow = append(tableRow, []string{appStat.Status, chaosStatus, appStat.Version, appStat.Upgrade, appStat.AutoUpdate}...)
+				}
+				table.Append(tableRow)
 			}
 
-				rows = append(rows, row)
+			if table.NumLines() > 0 {
+				table.Render()
+
+				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))
+				}
 			}
 
-			table.Rows(rows...)
-
-			if len(rows) > 0 {
-				if err := formatter.PrintTable(table); err != nil {
-					log.Fatal(err)
-				}
-
-				if len(allStats) > 1 && len(rows) > 0 {
+			if len(allStats) > 1 && table.NumLines() > 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))
 		}
 
-var (
-	status        bool
-	recipeFilter  string
-	listAppServer string
-)
-
-func init() {
-	AppListCommand.Flags().BoolVarP(
-		&status,
-		"status",
-		"S",
-		false,
-		"show app deployment status",
-	)
-
-	AppListCommand.Flags().StringVarP(
-		&recipeFilter,
-		"recipe",
-		"r",
-		"",
-		"show apps of a specific recipe",
-	)
-
-	AppListCommand.RegisterFlagCompletionFunc(
-		"recipe",
-		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-			return autocomplete.RecipeNameComplete()
+		return nil
 	},
-	)
-
-	AppListCommand.Flags().BoolVarP(
-		&internal.MachineReadable,
-		"machine",
-		"m",
-		false,
-		"print machine-readable output",
-	)
-
-	AppListCommand.Flags().StringVarP(
-		&listAppServer,
-		"server",
-		"s",
-		"",
-		"show apps of a specific server",
-	)
-
-	AppListCommand.RegisterFlagCompletionFunc(
-		"server",
-		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-			return autocomplete.ServerNameComplete()
-		},
-	)
 }

cli/app/logs.go

@@ -2,7 +2,6 @@ package app
 
 import (
 	"context"
-	"fmt"
 	"io"
 	"os"
 	"slices"
@@ -20,34 +19,23 @@ import (
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/swarm"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppLogsCommand = &cobra.Command{
-	Use:     "logs <domain> [service] [flags]",
+var appLogsCommand = cli.Command{
+	Name:      "logs",
 	Aliases:   []string{"l"},
-	Short:   "Tail app logs",
-	Args:    cobra.RangeArgs(1, 2),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		switch l := len(args); l {
-		case 0:
-			return autocomplete.AppNameComplete()
-		case 1:
-			app, err := appPkg.Get(args[0])
-			if err != nil {
-				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
-				return []string{errMsg}, cobra.ShellCompDirectiveError
-			}
-			return autocomplete.ServiceNameComplete(app.Name)
-		default:
-			return nil, cobra.ShellCompDirectiveDefault
-		}
+	ArgsUsage: "<domain> [<service>]",
+	Usage:     "Tail app logs",
+	Flags: []cli.Flag{
+		internal.StdErrOnlyFlag,
+		internal.SinceLogsFlag,
+		internal.DebugFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
 		stackName := app.StackName()
 
 		if err := app.Recipe.EnsureExists(); err != nil {
@@ -68,14 +56,17 @@ var AppLogsCommand = &cobra.Command{
 			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		var serviceNames []string
-		if len(args) == 2 {
-			serviceNames = []string{args[1]}
+		serviceName := c.Args().Get(1)
+		serviceNames := []string{}
+		if serviceName != "" {
+			serviceNames = []string{serviceName}
 		}
-
-		if err = tailLogs(cl, app, serviceNames); err != nil {
+		err = tailLogs(cl, app, serviceNames)
+		if err != nil {
 			log.Fatal(err)
 		}
+
+		return nil
 	},
 }
 
@@ -121,8 +112,8 @@ func tailLogs(cl *dockerClient.Client, app appPkg.App, serviceNames []string) er
 		go func(serviceID string) {
 			logs, err := cl.ServiceLogs(context.Background(), serviceID, containerTypes.LogsOptions{
 				ShowStderr: true,
-				ShowStdout: !stdErr,
-				Since:      sinceLogs,
+				ShowStdout: !internal.StdErrOnly,
+				Since:      internal.SinceLogs,
 				Until:      "",
 				Timestamps: true,
 				Follow:     true,
@@ -146,26 +137,3 @@ func tailLogs(cl *dockerClient.Client, app appPkg.App, serviceNames []string) er
 
 	return nil
 }
-
-var (
-	stdErr    bool
-	sinceLogs string
-)
-
-func init() {
-	AppLogsCommand.Flags().BoolVarP(
-		&stdErr,
-		"stderr",
-		"s",
-		false,
-		"only tail stderr",
-	)
-
-	AppLogsCommand.Flags().StringVarP(
-		&sinceLogs,
-		"since",
-		"S",
-		"",
-		"tail logs since YYYY-MM-DDTHH:MM:SSZ",
-	)
-}

cli/app/new.go

@@ -4,34 +4,30 @@ import (
 	"fmt"
 
 	"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/log"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/abra/pkg/secret"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/charmbracelet/lipgloss/table"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var appNewDescription = `Creates a new app from a default recipe.
-
-This new app configuration is stored in your $ABRA_DIR directory under the
-appropriate server.
+var appNewDescription = `
+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
@@ -41,95 +37,61 @@ You can use the "--pass/-P" to store these generated passwords locally in a
 pass store (see passwordstore.org for more). The pass command must be available
 on your $PATH.`
 
-var AppNewCommand = &cobra.Command{
-	Use:     "new [recipe] [version] [flags]",
+var appNewCommand = cli.Command{
+	Name:        "new",
 	Aliases:     []string{"n"},
-	Short:   "Create a new app",
-	Long:    appNewDescription,
-	Args:    cobra.RangeArgs(0, 2),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		switch l := len(args); l {
+	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) {
 		case 0:
-			return autocomplete.RecipeNameComplete()
+			autocomplete.RecipeNameComplete(ctx)
 		case 1:
-			recipe := internal.ValidateRecipe(args, cmd.Name())
-			return autocomplete.RecipeVersionComplete(recipe.Name)
-		default:
-			return nil, cobra.ShellCompDirectiveDefault
+			autocomplete.RecipeVersionComplete(ctx.Args().Get(0))
 		}
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		recipe := internal.ValidateRecipe(args, cmd.Name())
-
-		if len(args) == 2 && internal.Chaos {
-			log.Fatal("cannot use [version] and --chaos together")
-		}
-
-		var recipeVersion string
-		if len(args) == 2 {
-			recipeVersion = args[1]
-		}
-
-		chaosVersion := config.CHAOS_DEFAULT
-		if internal.Chaos {
-			var err error
-			chaosVersion, err = recipe.ChaosVersion()
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			// NOTE(d1): rely on tags as there is no recipe.EnvVersion yet because
-			// the app has not been fully created. we rely on the local git state of
-			// the repository
-			tags, err := recipe.Tags()
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			internal.SortVersionsDesc(tags)
-
-			if len(tags) == 0 {
-				// NOTE(d1): this is a new recipe with no released versions
-				recipeVersion = config.UNKNOWN_DEFAULT
-			} else {
-				recipeVersion = tags[len(tags)-1]
-			}
-
-			if err := recipe.IsDirty(); err != nil {
-				log.Fatal(err)
-			}
-
-			if !internal.Offline && !recipe.Dirty {
-				if err := recipe.EnsureUpToDate(); err != nil {
-					log.Fatal(err)
-				}
-			}
-		}
+	Action: func(c *cli.Context) error {
+		recipe := internal.ValidateRecipe(c)
 
 		if !internal.Chaos {
 			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 {
+			if !internal.Offline {
+				if err := recipe.EnsureUpToDate(); err != nil {
 					log.Fatal(err)
 				}
 			}
+			if c.Args().Get(1) == "" {
+				var version string
 
+				recipeVersions, err := recipe.GetRecipeVersions()
+				if err != nil {
+					log.Fatal(err)
+				}
+
+				// 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 {
-					recipeVersion = tag
+						version = tag
 					}
 
-				if _, err := recipe.EnsureVersion(recipeVersion); err != nil {
+					if _, err := recipe.EnsureVersion(version); err != nil {
 						log.Fatal(err)
 					}
 				} else {
@@ -137,31 +99,36 @@ var AppNewCommand = &cobra.Command{
 						log.Fatal(err)
 					}
 				}
+			} else {
+				if _, err := recipe.EnsureVersion(c.Args().Get(1)); err != nil {
+					log.Fatal(err)
+				}
+			}
 		}
 
 		if err := ensureServerFlag(); err != nil {
 			log.Fatal(err)
 		}
 
-		if err := ensureDomainFlag(recipe, newAppServer); err != nil {
+		if err := ensureDomainFlag(recipe, internal.NewAppServer); err != nil {
 			log.Fatal(err)
 		}
 
-		sanitisedAppName := appPkg.SanitiseAppName(appDomain)
-		log.Debugf("%s sanitised as %s for new app", appDomain, sanitisedAppName)
+		sanitisedAppName := appPkg.SanitiseAppName(internal.Domain)
+		log.Debugf("%s sanitised as %s for new app", internal.Domain, sanitisedAppName)
 
 		if err := appPkg.TemplateAppEnvSample(
 			recipe,
-			appDomain,
-			newAppServer,
-			appDomain,
+			internal.Domain,
+			internal.NewAppServer,
+			internal.Domain,
 		); err != nil {
 			log.Fatal(err)
 		}
 
-		var appSecrets AppSecrets
-		var secretsTable *table.Table
-		if generateSecrets {
+		var secrets AppSecrets
+		var secretTable *jsontable.JSONTable
+		if internal.Secrets {
 			sampleEnv, err := recipe.SampleEnv()
 			if err != nil {
 				log.Fatal(err)
@@ -172,82 +139,62 @@ var AppNewCommand = &cobra.Command{
 				log.Fatal(err)
 			}
 
-			secretsConfig, err := secret.ReadSecretsConfig(
-				recipe.SampleEnvPath,
-				composeFiles,
-				appPkg.StackName(appDomain),
-			)
+			secretsConfig, err := secret.ReadSecretsConfig(recipe.SampleEnvPath, composeFiles, appPkg.StackName(internal.Domain))
 			if err != nil {
-				log.Fatal(err)
+				return err
 			}
 
 			if err := promptForSecrets(recipe.Name, secretsConfig); err != nil {
 				log.Fatal(err)
 			}
 
-			cl, err := client.New(newAppServer)
+			cl, err := client.New(internal.NewAppServer)
 			if err != nil {
 				log.Fatal(err)
 			}
 
-			appSecrets, err = createSecrets(cl, secretsConfig, sanitisedAppName)
+			secrets, err = createSecrets(cl, secretsConfig, sanitisedAppName)
 			if err != nil {
 				log.Fatal(err)
 			}
 
-			secretsTable, err = formatter.CreateTable()
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			headers := []string{"NAME", "VALUE"}
-			secretsTable.Headers(headers...)
-
-			for name, val := range appSecrets {
-				secretsTable.Row(name, val)
+			secretCols := []string{"Name", "Value"}
+			secretTable = formatter.CreateTable(secretCols)
+			for name, val := range secrets {
+				secretTable.Append([]string{name, val})
 			}
 		}
 
-		if newAppServer == "default" {
-			newAppServer = "local"
+		if internal.NewAppServer == "default" {
+			internal.NewAppServer = "local"
 		}
 
-		log.Infof("%s created successfully (version: %s, chaos: %s)", appDomain, recipeVersion, chaosVersion)
+		tableCol := []string{"server", "recipe", "domain"}
+		table := formatter.CreateTable(tableCol)
+		table.Append([]string{internal.NewAppServer, recipe.Name, internal.Domain})
 
-		if len(appSecrets) > 0 {
-			rows := [][]string{}
-			for k, v := range appSecrets {
-				rows = append(rows, []string{k, v})
+		log.Infof("new app '%s' created 🌞", recipe.Name)
+
+		fmt.Println("")
+		table.Render()
+		fmt.Println("")
+
+		fmt.Println("Configure this app:")
+		fmt.Println(fmt.Sprintf("\n    abra app config %s", internal.Domain))
+
+		fmt.Println("")
+		fmt.Println("Deploy this app:")
+		fmt.Println(fmt.Sprintf("\n    abra app deploy %s", internal.Domain))
+
+		if len(secrets) > 0 {
+			fmt.Println("")
+			fmt.Println("Generated secrets:")
+			fmt.Println("")
+			secretTable.Render()
+			log.Warn("generated secrets are not shown again, please take note of them NOW")
 		}
 
-			overview := formatter.CreateOverview("SECRETS OVERVIEW", rows)
-
-			fmt.Println(overview)
-
-			log.Warnf(
-				"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.Recipe.IsDirty(); err != nil {
-			log.Fatal(err)
-		}
-
-		toWriteVersion := recipeVersion
-		if internal.Chaos || app.Recipe.Dirty {
-			toWriteVersion = chaosVersion
-		}
-
-		if err := app.WriteRecipeVersion(toWriteVersion, false); err != nil {
-			log.Fatalf("writing recipe version failed: %s", err)
-		}
+		return nil
 	},
 }
 
@@ -262,19 +209,19 @@ func createSecrets(cl *dockerClient.Client, secretsConfig map[string]secret.Secr
 		sanitisedAppName = sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH]
 	}
 
-	secrets, err := secret.GenerateSecrets(cl, secretsConfig, newAppServer)
+	secrets, err := secret.GenerateSecrets(cl, secretsConfig, internal.NewAppServer)
 	if err != nil {
 		return nil, err
 	}
 
-	if saveInPass {
+	if internal.Pass {
 		for secretName := range secrets {
 			secretValue := secrets[secretName]
 			if err := secret.PassInsertSecret(
 				secretValue,
 				secretName,
-				appDomain,
-				newAppServer,
+				internal.Domain,
+				internal.NewAppServer,
 			); err != nil {
 				return nil, err
 			}
@@ -286,17 +233,17 @@ func createSecrets(cl *dockerClient.Client, secretsConfig map[string]secret.Secr
 
 // ensureDomainFlag checks if the domain flag was used. if not, asks the user for it/
 func ensureDomainFlag(recipe recipePkg.Recipe, server string) error {
-	if appDomain == "" && !internal.NoInput {
+	if internal.Domain == "" && !internal.NoInput {
 		prompt := &survey.Input{
 			Message: "Specify app domain",
 			Default: fmt.Sprintf("%s.%s", recipe.Name, server),
 		}
-		if err := survey.AskOne(prompt, &appDomain); err != nil {
+		if err := survey.AskOne(prompt, &internal.Domain); err != nil {
 			return err
 		}
 	}
 
-	if appDomain == "" {
+	if internal.Domain == "" {
 		return fmt.Errorf("no domain provided")
 	}
 
@@ -310,11 +257,11 @@ func promptForSecrets(recipeName string, secretsConfig map[string]secret.Secret)
 		return nil
 	}
 
-	if !generateSecrets && !internal.NoInput {
+	if !internal.Secrets && !internal.NoInput {
 		prompt := &survey.Confirm{
 			Message: "Generate app secrets?",
 		}
-		if err := survey.AskOne(prompt, &generateSecrets); err != nil {
+		if err := survey.AskOne(prompt, &internal.Secrets); err != nil {
 			return err
 		}
 	}
@@ -329,76 +276,19 @@ func ensureServerFlag() error {
 		return err
 	}
 
-	if newAppServer == "" && !internal.NoInput {
+	if internal.NewAppServer == "" && !internal.NoInput {
 		prompt := &survey.Select{
 			Message: "Select app server:",
 			Options: servers,
 		}
-		if err := survey.AskOne(prompt, &newAppServer); err != nil {
+		if err := survey.AskOne(prompt, &internal.NewAppServer); err != nil {
 			return err
 		}
 	}
 
-	if newAppServer == "" {
+	if internal.NewAppServer == "" {
 		return fmt.Errorf("no server provided")
 	}
 
 	return nil
 }
-
-var (
-	newAppServer    string
-	appDomain       string
-	saveInPass      bool
-	generateSecrets bool
-)
-
-func init() {
-	AppNewCommand.Flags().StringVarP(
-		&newAppServer,
-		"server",
-		"s",
-		"",
-		"specify server for new app",
-	)
-
-	AppNewCommand.RegisterFlagCompletionFunc(
-		"server",
-		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-			return autocomplete.ServerNameComplete()
-		},
-	)
-
-	AppNewCommand.Flags().StringVarP(
-		&appDomain,
-		"domain",
-		"D",
-		"",
-		"domain name for app",
-	)
-
-	AppNewCommand.Flags().BoolVarP(
-		&saveInPass,
-		"pass",
-		"p",
-		false,
-		"store secrets in a local pass store",
-	)
-
-	AppNewCommand.Flags().BoolVarP(
-		&generateSecrets,
-		"secrets",
-		"S",
-		false,
-		"automatically generate secrets",
-	)
-
-	AppNewCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-
-}

cli/app/ps.go

@@ -4,13 +4,11 @@ import (
 	"context"
 	"encoding/json"
 	"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/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	abraService "coopcloud.tech/abra/pkg/service"
@@ -19,24 +17,24 @@ import (
 	containerTypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppPsCommand = &cobra.Command{
-	Use:     "ps <domain> [flags]",
+var appPsCommand = cli.Command{
+	Name:        "ps",
 	Aliases:     []string{"p"},
-	Short:   "Check app deployment status",
-	Args:    cobra.ExactArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.AppNameComplete()
+	Usage:       "Check app status",
+	ArgsUsage:   "<domain>",
+	Description: "Show status of a deployed app.",
+	Flags: []cli.Flag{
+		internal.MachineReadableFlag,
+		internal.DebugFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
-
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+		if err := app.Recipe.Ensure(false, false); err != nil {
 			log.Fatal(err)
 		}
 
@@ -54,20 +52,25 @@ var AppPsCommand = &cobra.Command{
 			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		chaosVersion := config.CHAOS_DEFAULT
+		chaosVersion := "false"
 		statuses, err := appPkg.GetAppStatuses([]appPkg.App{app}, true)
 		if statusMeta, ok := statuses[app.StackName()]; ok {
-			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)
+			isChaos, exists := statusMeta["chaos"]
+			if exists && isChaos == "false" {
+				if _, err := app.Recipe.EnsureVersion(deployMeta.Version); err != nil {
+					log.Fatal(err)
 				}
+			} else {
+				chaosVersion, err = app.Recipe.ChaosVersion()
+				if err != nil {
+					log.Fatal(err)
 				}
 			}
 		}
 
 		showPSOutput(app, cl, deployMeta.Version, chaosVersion)
+
+		return nil
 	},
 }
 
@@ -91,7 +94,7 @@ func showPSOutput(app appPkg.App, cl *dockerClient.Client, deployedVersion, chao
 		return
 	}
 
-	var rows [][]string
+	var tablerows [][]string
 	allContainerStats := make(map[string]map[string]string)
 	for _, service := range compose.Services {
 		filters := filters.NewArgs()
@@ -131,74 +134,36 @@ func showPSOutput(app appPkg.App, cl *dockerClient.Client, deployedVersion, chao
 
 		allContainerStats[containerStats["service"]] = containerStats
 
-		// NOTE(d1): don't clobber these variables for --machine output
-		dVersion := deployedVersion
-		cVersion := chaosVersion
-
-		if containerStats["service"] != "app" {
-			// NOTE(d1): don't repeat info which only relevant for the "app" service
-			dVersion = ""
-			cVersion = ""
-		}
-
-		row := []string{
+		tablerow := []string{
+			deployedVersion,
+			chaosVersion,
 			containerStats["service"],
 			containerStats["image"],
-			dVersion,
-			cVersion,
+			containerStats["created"],
 			containerStats["status"],
+			containerStats["state"],
+			containerStats["ports"],
 		}
 
-		rows = append(rows, row)
+		tablerows = append(tablerows, tablerow)
 	}
 
 	if internal.MachineReadable {
-		rendered, err := json.Marshal(allContainerStats)
+		jsonstring, err := json.Marshal(allContainerStats)
 		if err != nil {
-			log.Fatal("unable to convert to JSON: %s", err)
+			log.Fatal(err)
 		}
 
-		fmt.Println(string(rendered))
+		fmt.Println(string(jsonstring))
 
 		return
 	}
 
-	table, err := formatter.CreateTable()
-	if err != nil {
-		log.Fatal(err)
+	tableCol := []string{"version", "chaos", "service", "image", "created", "status", "state", "ports"}
+	table := formatter.CreateTable(tableCol)
+	for _, row := range tablerows {
+		table.Append(row)
 	}
-
-	headers := []string{
-		"SERVICE",
-		"IMAGE",
-		"VERSION",
-		"CHAOS",
-		"STATUS",
-	}
-
-	table.
-		Headers(headers...).
-		Rows(rows...)
-
-	if err := formatter.PrintTable(table); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func init() {
-	AppPsCommand.Flags().BoolVarP(
-		&internal.MachineReadable,
-		"machine",
-		"m",
-		false,
-		"print machine-readable output",
-	)
-
-	AppPsCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
+	table.SetAutoMergeCellsByColumnIndex([]int{0, 1})
+	table.Render()
 }

cli/app/remove.go

@@ -12,14 +12,16 @@ import (
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/docker/api/types"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppRemoveCommand = &cobra.Command{
-	Use:     "remove <domain> [flags]",
+var appRemoveCommand = cli.Command{
+	Name:      "remove",
 	Aliases:   []string{"rm"},
-	Short:   "Remove all app data, locally and remotely",
-	Long: `Remove everything related to an app which is already undeployed.
+	ArgsUsage: "<domain>",
+	Usage:     "Remove all app data, locally and remotely",
+	Description: `
+This command removes 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.
@@ -35,26 +37,24 @@ 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.`,
-	Example: "  abra app remove 1312.net",
-	Args:    cobra.ExactArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.AppNameComplete()
+	Flags: []cli.Flag{
+		internal.ForceFlag,
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		internal.OfflineFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+	BashComplete: autocomplete.AppNameComplete,
+	Before:       internal.SubCommandBefore,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
 
 		if !internal.Force && !internal.NoInput {
-			log.Warnf("ALERTA ALERTA: deleting %s data and config (local/remote)", app.Name)
-
 			response := false
-			prompt := &survey.Confirm{Message: "are you sure?"}
+			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)}
 			if err := survey.AskOne(prompt, &response); err != nil {
 				log.Fatal(err)
 			}
-
 			if !response {
 				log.Fatal("aborting as requested")
 			}
@@ -130,15 +130,7 @@ flag.`,
 		}
 
 		log.Info(fmt.Sprintf("file: %s removed", app.Path))
+
+		return nil
 	},
 }
-
-func init() {
-	AppRemoveCommand.Flags().BoolVarP(
-		&internal.Force,
-		"force",
-		"f",
-		false,
-		"perform action without further prompt",
-	)
-}

cli/app/restart.go

@@ -2,6 +2,7 @@ package app
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
@@ -11,62 +12,49 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	upstream "coopcloud.tech/abra/pkg/upstream/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppRestartCommand = &cobra.Command{
-	Use:     "restart <domain> [[service] | --all-services] [flags]",
+var appRestartCommand = cli.Command{
+	Name:      "restart",
 	Aliases:   []string{"re"},
-	Short:   "Restart an app",
-	Long: `This command restarts services within a deployed app.
+	Usage:     "Restart an app",
+	ArgsUsage: "<domain> [<service>]",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.OfflineFlag,
+		internal.AllServicesFlag,
+	},
+	Before: internal.SubCommandBefore,
+	Description: `
+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: `  # restart a single app service
-  abra app restart 1312.net app
+Pass "--all-services/-a" to restart all services.
 
-  # 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)
+EXAMPLE:
 
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+    abra app restart example.com app`,
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+		if err := app.Recipe.Ensure(false, false); err != nil {
 			log.Fatal(err)
 		}
 
-		var serviceName string
-		if len(args) == 2 {
-			serviceName = args[1]
+		serviceName := c.Args().Get(1)
+		if serviceName == "" && !internal.AllServices {
+			err := errors.New("missing <service>")
+			internal.ShowSubcommandHelpAndError(c, err)
 		}
 
-		if serviceName == "" && !allServices {
-			log.Fatal("missing [service]")
-		}
-
-		if serviceName != "" && allServices {
-			log.Fatal("cannot use [service] and --all-services/-a together")
+		if serviceName != "" && internal.AllServices {
+			log.Fatal("cannot use <service> and --all-services together")
 		}
 
 		var serviceNames []string
-		if allServices {
+		if internal.AllServices {
 			var err error
 			serviceNames, err = appPkg.GetAppServiceNames(app.Name)
 			if err != nil {
@@ -117,24 +105,7 @@ Pass "--all-services/-a" to restart all services.`,
 			log.Debugf("%s has been scaled to 1", stackServiceName)
 			log.Infof("%s service successfully restarted", serviceName)
 		}
+
+		return nil
 	},
 }
-
-var allServices bool
-
-func init() {
-	AppRestartCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-	AppRestartCommand.Flags().BoolVarP(
-		&allServices,
-		"all-services",
-		"a",
-		false,
-		"restart all services",
-	)
-}

cli/app/restore.go

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

cli/app/rollback.go

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

cli/app/run.go

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

cli/app/secret.go

@@ -2,6 +2,7 @@ package app
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strconv"
@@ -16,45 +17,56 @@ import (
 	"coopcloud.tech/abra/pkg/secret"
 	"github.com/docker/docker/api/types"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppSecretGenerateCommand = &cobra.Command{
-	Use:     "generate <domain> [[secret] [version] | --all] [flags]",
-	Aliases: []string{"g"},
-	Short:   "Generate secrets",
-	Args:    cobra.RangeArgs(1, 3),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		switch l := len(args); l {
-		case 0:
-			return autocomplete.AppNameComplete()
-		case 1:
-			app, err := appPkg.Get(args[0])
-			if err != nil {
-				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
-				return []string{errMsg}, cobra.ShellCompDirectiveError
+var (
+	allSecrets     bool
+	allSecretsFlag = &cli.BoolFlag{
+		Name:        "all, a",
+		Destination: &allSecrets,
+		Usage:       "Generate all secrets",
 	}
-			return autocomplete.SecretComplete(app.Recipe.Name)
-		default:
-			return nil, cobra.ShellCompDirectiveDefault
-		}
-	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+)
 
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+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,
+	},
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
-		if len(args) == 1 && !generateAllSecrets {
-			log.Fatal("missing arguments [secret]/[version] or '--all'")
+		if len(c.Args()) == 1 && !allSecrets {
+			err := errors.New("missing arguments <secret>/<version> or '--all'")
+			internal.ShowSubcommandHelpAndError(c, err)
 		}
 
-		if len(args) > 1 && generateAllSecrets {
-			log.Fatal("cannot use '[secret] [version]' and '--all' together")
+		if c.Args().Get(1) != "" && allSecrets {
+			err := errors.New("cannot use '<secret> <version>' and '--all' together")
+			internal.ShowSubcommandHelpAndError(c, err)
 		}
 
 		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
@@ -67,9 +79,9 @@ var AppSecretGenerateCommand = &cobra.Command{
 			log.Fatal(err)
 		}
 
-		if !generateAllSecrets {
-			secretName := args[1]
-			secretVersion := args[2]
+		if !allSecrets {
+			secretName := c.Args().Get(1)
+			secretVersion := c.Args().Get(2)
 			s, ok := secrets[secretName]
 			if !ok {
 				log.Fatalf("%s doesn't exist in the env config?", secretName)
@@ -90,7 +102,7 @@ var AppSecretGenerateCommand = &cobra.Command{
 			log.Fatal(err)
 		}
 
-		if storeInPass {
+		if internal.Pass {
 			for name, data := range secretVals {
 				if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil {
 					log.Fatal(err)
@@ -103,75 +115,53 @@ var AppSecretGenerateCommand = &cobra.Command{
 			os.Exit(1)
 		}
 
-		headers := []string{"NAME", "VALUE"}
-		table, err := formatter.CreateTable()
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		table.Headers(headers...)
-
-		var rows [][]string
+		tableCol := []string{"name", "value"}
+		table := formatter.CreateTable(tableCol)
 		for name, val := range secretVals {
-			row := []string{name, val}
-			rows = append(rows, row)
-			table.Row(row...)
+			table.Append([]string{name, val})
 		}
 
 		if internal.MachineReadable {
-			out, err := formatter.ToJSON(headers, rows)
-			if err != nil {
-				log.Fatal("unable to render to JSON: %s", err)
-			}
-			fmt.Println(out)
-			return
+			table.JSONRender()
+		} else {
+			table.Render()
 		}
+		log.Warn("generated secrets are not shown again, please take note of them NOW")
 
-		if err := formatter.PrintTable(table); err != nil {
-			log.Fatal(err)
-		}
-
-		log.Warnf(
-			"generated secrets %s shown again, please take note of them %s",
-			formatter.BoldStyle.Render("NOT"),
-			formatter.BoldStyle.Render("NOW"),
-		)
+		return nil
 	},
 }
 
-var AppSecretInsertCommand = &cobra.Command{
-	Use:     "insert <domain> <secret> <version> <data> [flags]",
+var appSecretInsertCommand = cli.Command{
+	Name:    "insert",
 	Aliases: []string{"i"},
-	Short:   "Insert secret",
-	Long: `This command inserts a secret into an app environment.
+	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.
 
 This can be useful when you want to manually generate secrets for an app
 environment. Typically, you can let Abra generate them for you on app creation
-(see "abra app new --secrets/-S" for more).`,
-	Args: cobra.MinimumNArgs(4),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		switch l := len(args); l {
-		case 0:
-			return autocomplete.AppNameComplete()
-		case 1:
-			app, err := appPkg.Get(args[0])
-			if err != nil {
-				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
-				return []string{errMsg}, cobra.ShellCompDirectiveError
-			}
-			return autocomplete.SecretComplete(app.Recipe.Name)
-		default:
-			return nil, cobra.ShellCompDirectiveDefault
-		}
-	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+(see "abra app new --secrets" for more).
 
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
-			log.Fatal(err)
+Example:
+
+    abra app secret insert myapp db_pass v1 mySecretPassword
+
+`,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+
+		if len(c.Args()) != 4 {
+			internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments?"))
 		}
 
 		cl, err := client.New(app.Server)
@@ -179,11 +169,11 @@ environment. Typically, you can let Abra generate them for you on app creation
 			log.Fatal(err)
 		}
 
-		name := args[1]
-		version := args[2]
-		data := args[3]
+		name := c.Args().Get(1)
+		version := c.Args().Get(2)
+		data := c.Args().Get(3)
 
-		if insertFromFile {
+		if internal.File {
 			raw, err := os.ReadFile(data)
 			if err != nil {
 				log.Fatalf("reading secret from file: %s", err)
@@ -191,7 +181,7 @@ environment. Typically, you can let Abra generate them for you on app creation
 			data = string(raw)
 		}
 
-		if trimInput {
+		if internal.Trim {
 			data = strings.TrimSpace(data)
 		}
 
@@ -202,11 +192,13 @@ environment. Typically, you can let Abra generate them for you on app creation
 
 		log.Infof("%s successfully stored on server", secretName)
 
-		if storeInPass {
+		if internal.Pass {
 			if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil {
 				log.Fatal(err)
 			}
 		}
+
+		return nil
 	},
 }
 
@@ -218,7 +210,7 @@ func secretRm(cl *dockerClient.Client, app appPkg.App, secretName, parsed string
 
 	log.Infof("deleted %s successfully from server", secretName)
 
-	if removeFromPass {
+	if internal.PassRemove {
 		if err := secret.PassRmSecret(parsed, app.StackName(), app.Server); err != nil {
 			return err
 		}
@@ -229,36 +221,31 @@ func secretRm(cl *dockerClient.Client, app appPkg.App, secretName, parsed string
 	return nil
 }
 
-var AppSecretRmCommand = &cobra.Command{
-	Use:     "remove <domain> [[secret] | --all] [flags]",
+var appSecretRmCommand = cli.Command{
+	Name:    "remove",
 	Aliases: []string{"rm"},
-	Short:   "Remove a secret",
-	Args:    cobra.RangeArgs(1, 2),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		switch l := len(args); l {
-		case 0:
-			return autocomplete.AppNameComplete()
-		case 1:
-			if !rmAllSecrets {
-				app, err := appPkg.Get(args[0])
-				if err != nil {
-					errMsg := fmt.Sprintf("autocomplete failed: %s", err)
-					return []string{errMsg}, cobra.ShellCompDirectiveError
-				}
-				return autocomplete.SecretComplete(app.Recipe.Name)
-			}
-			return nil, cobra.ShellCompDirectiveDefault
-		default:
-			return nil, cobra.ShellCompDirectiveError
-		}
+	Usage:   "Remove a secret",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		rmAllSecretsFlag,
+		internal.PassRemoveFlag,
+		internal.OfflineFlag,
+		internal.ChaosFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+	Before:       internal.SubCommandBefore,
+	ArgsUsage:    "<domain> [<secret-name>]",
+	BashComplete: autocomplete.AppNameComplete,
+	Description: `
+This command removes app secrets.
 
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+Example:
+
+    abra app secret remove myapp db_pass
+`,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
@@ -272,12 +259,12 @@ var AppSecretRmCommand = &cobra.Command{
 			log.Fatal(err)
 		}
 
-		if len(args) == 2 && rmAllSecrets {
-			log.Fatal("cannot use [secret] and --all/-a together")
+		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("no secret(s) specified?")
+		if c.Args().Get(1) == "" && !rmAllSecrets {
+			internal.ShowSubcommandHelpAndError(c, errors.New("no secret(s) specified?"))
 		}
 
 		cl, err := client.New(app.Server)
@@ -300,12 +287,8 @@ var AppSecretRmCommand = &cobra.Command{
 			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 {
@@ -315,7 +298,7 @@ var AppSecretRmCommand = &cobra.Command{
 							log.Fatal(err)
 						}
 
-						return
+						return nil
 					}
 				} else {
 					match = true
@@ -334,24 +317,26 @@ var AppSecretRmCommand = &cobra.Command{
 		if !match {
 			log.Fatal("no secrets to remove?")
 		}
+
+		return nil
 	},
 }
 
-var AppSecretLsCommand = &cobra.Command{
-	Use:     "list <domain>",
+var appSecretLsCommand = cli.Command{
+	Name:    "list",
 	Aliases: []string{"ls"},
-	Short:   "List all secrets",
-	Args:    cobra.MinimumNArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.AppNameComplete()
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.OfflineFlag,
+		internal.ChaosFlag,
+		internal.MachineReadableFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
-
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+	Before:       internal.SubCommandBefore,
+	Usage:        "List all secrets",
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
@@ -360,170 +345,47 @@ var AppSecretLsCommand = &cobra.Command{
 			log.Fatal(err)
 		}
 
-		headers := []string{"NAME", "VERSION", "GENERATED NAME", "CREATED ON SERVER"}
-		table, err := formatter.CreateTable()
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		table.Headers(headers...)
+		tableCol := []string{"Name", "Version", "Generated Name", "Created On Server"}
+		table := formatter.CreateTable(tableCol)
 
 		secStats, err := secret.PollSecretsStatus(cl, app)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		var rows [][]string
 		for _, secStat := range secStats {
-			row := []string{
+			tableRow := []string{
 				secStat.LocalName,
 				secStat.Version,
 				secStat.RemoteName,
 				strconv.FormatBool(secStat.CreatedOnRemote),
 			}
-
-			rows = append(rows, row)
-			table.Row(row...)
+			table.Append(tableRow)
 		}
 
-		if len(rows) > 0 {
+		if table.NumLines() > 0 {
 			if internal.MachineReadable {
-				out, err := formatter.ToJSON(headers, rows)
-				if err != nil {
-					log.Fatal("unable to render to JSON: %s", err)
+				table.JSONRender()
+			} else {
+				table.Render()
 			}
-				fmt.Println(out)
-				return
-			}
-
-			if err := formatter.PrintTable(table); err != nil {
-				log.Fatal(err)
-			}
-
-			return
-		}
-
+		} else {
 			log.Warnf("no secrets stored for %s", app.Name)
+		}
+
+		return nil
 	},
 }
 
-var AppSecretCommand = &cobra.Command{
-	Use:     "secret [cmd] [args] [flags]",
+var appSecretCommand = cli.Command{
+	Name:      "secret",
 	Aliases:   []string{"s"},
-	Short:   "Manage app secrets",
-}
-
-var (
-	storeInPass        bool
-	insertFromFile     bool
-	trimInput          bool
-	rmAllSecrets       bool
-	generateAllSecrets bool
-	removeFromPass     bool
-)
-
-func init() {
-	AppSecretGenerateCommand.Flags().BoolVarP(
-		&internal.MachineReadable,
-		"machine",
-		"m",
-		false,
-		"print machine-readable output",
-	)
-
-	AppSecretGenerateCommand.Flags().BoolVarP(
-		&storeInPass,
-		"pass",
-		"p",
-		false,
-		"store generated secrets in a local pass store",
-	)
-
-	AppSecretGenerateCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-
-	AppSecretGenerateCommand.Flags().BoolVarP(
-		&generateAllSecrets,
-		"all",
-		"a",
-		false,
-		"generate all secrets",
-	)
-
-	AppSecretInsertCommand.Flags().BoolVarP(
-		&storeInPass,
-		"pass",
-		"p",
-		false,
-		"store generated secrets in a local pass store",
-	)
-
-	AppSecretInsertCommand.Flags().BoolVarP(
-		&insertFromFile,
-		"file",
-		"f",
-		false,
-		"treat input as a file",
-	)
-
-	AppSecretInsertCommand.Flags().BoolVarP(
-		&trimInput,
-		"trim",
-		"t",
-		false,
-		"trim input",
-	)
-
-	AppSecretInsertCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-
-	AppSecretRmCommand.Flags().BoolVarP(
-		&rmAllSecrets,
-		"all",
-		"a",
-		false,
-		"remove all secrets",
-	)
-
-	AppSecretRmCommand.Flags().BoolVarP(
-		&removeFromPass,
-		"pass",
-		"p",
-		false,
-		"remove generated secrets from a local pass store",
-	)
-
-	AppSecretRmCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-
-	AppSecretLsCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-
-	AppSecretLsCommand.Flags().BoolVarP(
-		&internal.MachineReadable,
-		"machine",
-		"m",
-		false,
-		"print machine-readable output",
-	)
+	Usage:     "Manage app secrets",
+	ArgsUsage: "<domain>",
+	Subcommands: []cli.Command{
+		appSecretGenerateCommand,
+		appSecretInsertCommand,
+		appSecretRmCommand,
+		appSecretLsCommand,
+	},
 }

cli/app/services.go

@@ -13,24 +13,22 @@ import (
 	"coopcloud.tech/abra/pkg/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	containerTypes "github.com/docker/docker/api/types/container"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppServicesCommand = &cobra.Command{
-	Use:     "services <domain> [flags]",
+var appServicesCommand = cli.Command{
+	Name:      "services",
 	Aliases:   []string{"sr"},
-	Short:   "Display all services of an app",
-	Args:    cobra.ExactArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.AppNameComplete()
+	Usage:     "Display all services of an app",
+	ArgsUsage: "<domain>",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
-
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
@@ -58,15 +56,9 @@ var AppServicesCommand = &cobra.Command{
 			log.Fatal(err)
 		}
 
-		table, err := formatter.CreateTable()
-		if err != nil {
-			log.Fatal(err)
-		}
+		tableCol := []string{"service name", "image"}
+		table := formatter.CreateTable(tableCol)
 
-		headers := []string{"SERVICE (SHORT)", "SERVICE (LONG)"}
-		table.Headers(headers...)
-
-		var rows [][]string
 		for _, container := range containers {
 			var containerNames []string
 			for _, containerName := range container.Names {
@@ -77,20 +69,15 @@ var AppServicesCommand = &cobra.Command{
 			serviceShortName := service.ContainerToServiceName(container.Names, app.StackName())
 			serviceLongName := fmt.Sprintf("%s_%s", app.StackName(), serviceShortName)
 
-			row := []string{
-				serviceShortName,
+			tableRow := []string{
 				serviceLongName,
+				formatter.RemoveSha(container.Image),
+			}
+			table.Append(tableRow)
 		}
 
-			rows = append(rows, row)
-		}
+		table.Render()
 
-		table.Rows(rows...)
-
-		if len(rows) > 0 {
-			if err := formatter.PrintTable(table); err != nil {
-				log.Fatal(err)
-			}
-		}
+		return nil
 	},
 }

cli/app/undeploy.go

@@ -8,89 +8,20 @@ import (
 	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/log"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppUndeployCommand = &cobra.Command{
-	Use:     "undeploy <domain> [flags]",
-	Aliases: []string{"un"},
-	Short:   "Undeploy an app",
-	Long: `This does not destroy any 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 "--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()
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		log.Debugf("checking whether %s is already deployed", stackName)
-
-		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		if !deployMeta.IsDeployed {
-			log.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		chaosVersion := config.CHAOS_DEFAULT
-		if deployMeta.IsChaos {
-			chaosVersion = deployMeta.ChaosVersion
-		}
-
-		toWriteVersion := deployMeta.Version
-		if deployMeta.IsChaos {
-			toWriteVersion = chaosVersion
-		}
-
-		if err := internal.UndeployOverview(
-			app,
-			deployMeta.Version,
-			chaosVersion,
-			toWriteVersion,
-		); 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)
-			}
-		}
-
-		if err := app.WriteRecipeVersion(toWriteVersion, false); err != nil {
-			log.Fatalf("writing recipe version failed: %s", err)
-		}
-	},
+var pruneFlag = &cli.BoolFlag{
+	Name:        "prune, p",
+	Destination: &prune,
+	Usage:       "Prunes unused containers, networks, and dangling images for an app",
 }
 
 // pruneApp runs the equivalent of a "docker system prune" but only filtering
@@ -129,16 +60,71 @@ func pruneApp(cl *dockerClient.Client, app appPkg.App) error {
 	return nil
 }
 
-var (
-	prune bool
-)
+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.
 
-func init() {
-	AppUndeployCommand.Flags().BoolVarP(
-		&prune,
-		"prune",
-		"p",
-		false,
-		"prune unused containers, networks, and dangling images",
-	)
+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)
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
+			log.Fatal(err)
+		}
+		stackName := app.StackName()
+
+		cl, err := client.New(app.Server)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		log.Debugf("checking whether %s is already deployed", stackName)
+
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if !deployMeta.IsDeployed {
+			log.Fatalf("%s is not deployed?", app.Name)
+		}
+
+		chaosVersion := "false"
+		if deployMeta.IsChaos {
+			chaosVersion = deployMeta.ChaosVersion
+		}
+
+		if err := internal.DeployOverview(app, deployMeta.Version, chaosVersion, "continue with undeploy?"); err != nil {
+			log.Fatal(err)
+		}
+
+		rmOpts := stack.Remove{
+			Namespaces: []string{app.StackName()},
+			Detach:     false,
+		}
+		if err := stack.RunRemove(context.Background(), cl, rmOpts); err != nil {
+			log.Fatal(err)
+		}
+
+		if prune {
+			if err := pruneApp(cl, app); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		return nil
+	},
 }

cli/app/upgrade.go

@@ -5,80 +5,52 @@ import (
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/app"
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/envfile"
-	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/log"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppUpgradeCommand = &cobra.Command{
-	Use:     "upgrade <domain> [version] [flags]",
+var appUpgradeCommand = cli.Command{
+	Name:      "upgrade",
 	Aliases:   []string{"up"},
-	Short:   "Upgrade an app",
-	Long: `Upgrade an app.
+	Usage:     "Upgrade an app",
+	ArgsUsage: "<domain> [<version>]",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		internal.ForceFlag,
+		internal.NoDomainChecksFlag,
+		internal.DontWaitConvergeFlag,
+		internal.OfflineFlag,
+		internal.ReleaseNotesFlag,
+	},
+	Before: internal.SubCommandBefore,
+	Description: `
+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.
+Unlike "deploy", chaos operations are not supported here. Only recipe versions
+are supported values for "[<version>]".
 
 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 {
-				errMsg := fmt.Sprintf("autocomplete failed: %s", err)
-				return []string{errMsg}, cobra.ShellCompDirectiveError
-			}
-			return autocomplete.RecipeVersionComplete(app.Recipe.Name)
-		default:
-			return nil, cobra.ShellCompDirectiveError
-		}
-	},
-	Run: func(cmd *cobra.Command, args []string) {
-		var (
-			upgradeWarnMessages []string
-			chosenUpgrade       string
-			availableUpgrades   []string
-			upgradeReleaseNotes string
-		)
+beforehand.
 
-		app := internal.ValidateApp(args)
+EXAMPLE:
 
-		if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
-			log.Fatal(err)
-		}
+    abra app upgrade foo.example.com
+    abra app upgrade foo.example.com 1.2.3+3.2.1`,
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+		stackName := app.StackName()
 
-		cl, err := client.New(app.Server)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		deployMeta, err := ensureDeployed(cl, app)
-		if err != nil {
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
@@ -86,69 +58,135 @@ beforehand. See "abra app backup" for more.`,
 			log.Fatal(err)
 		}
 
+		log.Debugf("checking whether %s is already deployed", stackName)
+
+		cl, err := client.New(app.Server)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if !deployMeta.IsDeployed {
+			log.Fatalf("%s is not deployed?", app.Name)
+		}
+
 		versions, err := app.Recipe.Tags()
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		// 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 {
+		var availableUpgrades []string
+		if deployMeta.Version == "unknown" {
 			availableUpgrades = versions
+			log.Warnf("failed to determine deployed version of %s", app.Name)
 		}
 
-		if len(args) == 2 && args[1] != "" {
-			chosenUpgrade = args[1]
-
-			if err := validateUpgradeVersionArg(chosenUpgrade, app, deployMeta); err != nil {
-				log.Fatal(err)
+		specificVersion := c.Args().Get(1)
+		if specificVersion != "" {
+			parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
+			if err != nil {
+				log.Fatalf("'%s' is not a known version for %s", deployMeta.Version, app.Recipe.Name)
+			}
+			parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
+			if err != nil {
+				log.Fatalf("'%s' is not a known version for %s", specificVersion, app.Recipe.Name)
 			}
 
-			availableUpgrades = append(availableUpgrades, chosenUpgrade)
+			if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) && !parsedSpecificVersion.Equals(parsedDeployedVersion) {
+				log.Fatalf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
 			}
 
-		if deployMeta.Version != config.UNKNOWN_DEFAULT && chosenUpgrade == "" {
-			upgradeAvailable, err := ensureUpgradesAvailable(versions, &availableUpgrades, deployMeta)
+			if parsedSpecificVersion.Equals(parsedDeployedVersion) && !internal.Force {
+				log.Fatalf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
+			}
+
+			availableUpgrades = append(availableUpgrades, specificVersion)
+		}
+
+		parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-			if !upgradeAvailable {
-				log.Info("no available upgrades")
-				return
-			}
+		if deployMeta.Version != "unknown" && specificVersion == "" {
+			if deployMeta.IsChaos {
+				log.Warn("attempting to upgrade a chaos deployment")
 			}
 
-		if internal.Force || internal.NoInput || chosenUpgrade != "" {
-			if len(availableUpgrades) > 0 {
-				chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
-			}
-		} else {
-			if err := chooseUpgrade(availableUpgrades, deployMeta, &chosenUpgrade); err != nil {
+			for _, version := range versions {
+				parsedVersion, err := tagcmp.Parse(version)
+				if err != nil {
 					log.Fatal(err)
 				}
+				if parsedVersion.IsGreaterThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
+					availableUpgrades = append(availableUpgrades, version)
+				}
 			}
 
-		if internal.Force &&
-			chosenUpgrade == "" &&
-			deployMeta.Version != config.UNKNOWN_DEFAULT {
+			if len(availableUpgrades) == 0 && !internal.Force {
+				log.Info("no available upgrades")
+				return nil
+			}
+		}
+
+		var chosenUpgrade string
+		if len(availableUpgrades) > 0 {
+			if internal.Force || internal.NoInput || specificVersion != "" {
+				chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
+				log.Debugf("choosing %s as version to upgrade to", chosenUpgrade)
+			} else {
+				msg := fmt.Sprintf("please select an upgrade (version: %s):", deployMeta.Version)
+				if deployMeta.IsChaos {
+					msg = fmt.Sprintf("please select an upgrade (version: %s, chaosVersion: %s):", deployMeta.Version, deployMeta.ChaosVersion)
+				}
+
+				prompt := &survey.Select{
+					Message: msg,
+					Options: internal.ReverseStringList(availableUpgrades),
+				}
+
+				if err := survey.AskOne(prompt, &chosenUpgrade); err != nil {
+					return err
+				}
+			}
+		}
+
+		if internal.Force && chosenUpgrade == "" {
+			log.Warnf("%s is already upgraded to latest but continuing (--force)", app.Name)
 			chosenUpgrade = deployMeta.Version
 		}
 
-		if chosenUpgrade == "" {
-			log.Fatal("unknown deployed version, unable to upgrade")
+		// 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 {
+				log.Fatal(err)
+			}
+			for _, version := range versions {
+				parsedVersion, err := tagcmp.Parse(version)
+				if err != nil {
+					log.Fatal(err)
+				}
+				if parsedVersion.IsGreaterThan(parsedDeployedVersion) && parsedVersion.IsLessThan(parsedChosenUpgrade) {
+					note, err := app.Recipe.GetReleaseNotes(version)
+					if err != nil {
+						return err
+					}
+					if note != "" {
+						releaseNotes += fmt.Sprintf("%s\n", note)
+					}
+				}
+			}
 		}
 
 		log.Debugf("choosing %s as version to upgrade", chosenUpgrade)
-
-		// NOTE(d1): 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
-		if err := getReleaseNotes(app, versions, chosenUpgrade, deployMeta, &upgradeReleaseNotes); err != nil {
-			log.Fatal(err)
-		}
-
 		if _, err := app.Recipe.EnsureVersion(chosenUpgrade); err != nil {
 			log.Fatal(err)
 		}
@@ -166,7 +204,6 @@ beforehand. See "abra app backup" for more.`,
 			log.Fatal(err)
 		}
 
-		stackName := app.StackName()
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
@@ -183,9 +220,7 @@ beforehand. See "abra app backup" for more.`,
 		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)
-		}
 		appPkg.SetUpdateLabel(compose, stackName, app.Env)
 
 		envVars, err := appPkg.CheckEnv(app)
@@ -195,35 +230,22 @@ beforehand. See "abra app backup" for more.`,
 
 		for _, envVar := range envVars {
 			if !envVar.Present {
-				upgradeWarnMessages = append(upgradeWarnMessages,
-					fmt.Sprintf("%s missing from %s.env", envVar.Name, app.Domain),
-				)
+				log.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain)
 			}
 		}
 
-		if showReleaseNotes {
-			fmt.Print(upgradeReleaseNotes)
-			return
+		if internal.ReleaseNotes {
+			fmt.Println()
+			fmt.Print(releaseNotes)
+			return nil
 		}
 
-		chaosVersion := config.CHAOS_DEFAULT
+		chaosVersion := "false"
 		if deployMeta.IsChaos {
 			chaosVersion = deployMeta.ChaosVersion
-
-			if deployMeta.ChaosVersion == "" {
-				chaosVersion = config.UNKNOWN_DEFAULT
-			}
 		}
 
-		if err := internal.NewVersionOverview(
-			app,
-			upgradeWarnMessages,
-			"upgrade",
-			deployMeta.Version,
-			chaosVersion,
-			chosenUpgrade,
-			upgradeReleaseNotes,
-		); err != nil {
+		if err := internal.NewVersionOverview(app, deployMeta.Version, chaosVersion, chosenUpgrade, releaseNotes); err != nil {
 			log.Fatal(err)
 		}
 
@@ -231,8 +253,7 @@ beforehand. See "abra app backup" for more.`,
 		if err != nil {
 			log.Fatal(err)
 		}
-
-		log.Debugf("set waiting timeout to %d second(s)", stack.WaitTimeout)
+		log.Debugf("set waiting timeout to %d s", stack.WaitTimeout)
 
 		if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
 			log.Fatal(err)
@@ -241,195 +262,18 @@ beforehand. See "abra app backup" for more.`,
 		postDeployCmds, ok := app.Env["POST_UPGRADE_CMDS"]
 		if ok && !internal.DontWaitConverge {
 			log.Debugf("run the following post-deploy commands: %s", postDeployCmds)
-
 			if err := internal.PostCmds(cl, app, postDeployCmds); err != nil {
 				log.Fatalf("attempting to run post deploy commands, saw: %s", err)
 			}
 		}
 
-		if err := app.WriteRecipeVersion(chosenUpgrade, false); err != nil {
-			log.Fatalf("writing recipe version failed: %s", err)
+		if app.Recipe.Version != "" {
+			err := app.WriteRecipeVersion(chosenUpgrade)
+			if err != nil {
+				log.Fatalf("writing new recipe version in env file: %s", err)
 			}
+		}
+
+		return nil
 	},
 }
-
-// chooseUpgrade prompts the user to choose an upgrade interactively.
-func chooseUpgrade(
-	availableUpgrades []string,
-	deployMeta stack.DeployMeta,
-	chosenUpgrade *string,
-) error {
-	msg := fmt.Sprintf("please select an upgrade (version: %s):", deployMeta.Version)
-
-	if deployMeta.IsChaos {
-		chaosVersion := formatter.BoldDirtyDefault(deployMeta.ChaosVersion)
-
-		msg = fmt.Sprintf(
-			"please select an upgrade (version: %s, chaos: %s):",
-			deployMeta.Version,
-			chaosVersion,
-		)
-	}
-
-	prompt := &survey.Select{
-		Message: msg,
-		Options: internal.SortVersionsDesc(availableUpgrades),
-	}
-
-	if err := survey.AskOne(prompt, chosenUpgrade); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func getReleaseNotes(
-	app app.App,
-	versions []string,
-	chosenUpgrade string,
-	deployMeta stack.DeployMeta,
-	upgradeReleaseNotes *string,
-) error {
-	parsedChosenUpgrade, err := tagcmp.Parse(chosenUpgrade)
-	if err != nil {
-		return err
-	}
-
-	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
-	if err != nil {
-		return err
-	}
-
-	for _, version := range internal.SortVersionsDesc(versions) {
-		parsedVersion, err := tagcmp.Parse(version)
-		if err != nil {
-			return err
-		}
-
-		if parsedVersion.IsGreaterThan(parsedDeployedVersion) &&
-			parsedVersion.IsLessThan(parsedChosenUpgrade) {
-			note, err := app.Recipe.GetReleaseNotes(version)
-			if err != nil {
-				return err
-			}
-
-			if note != "" {
-				*upgradeReleaseNotes += fmt.Sprintf("%s\n", note)
-			}
-		}
-	}
-
-	return nil
-}
-
-// ensureUpgradesAvailable ensures that there are available upgrades.
-func ensureUpgradesAvailable(
-	versions []string,
-	availableUpgrades *[]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.IsGreaterThan(parsedDeployedVersion) &&
-			!(parsedVersion.Equals(parsedDeployedVersion)) {
-			*availableUpgrades = append(*availableUpgrades, version)
-		}
-	}
-
-	if len(*availableUpgrades) == 0 && !internal.Force {
-		return false, nil
-	}
-
-	return true, nil
-}
-
-// validateUpgradeVersionArg validates the specific version.
-func validateUpgradeVersionArg(
-	specificVersion string,
-	app app.App,
-	deployMeta stack.DeployMeta,
-) error {
-	parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
-	if err != nil {
-		return fmt.Errorf("'%s' is not a known version for %s", specificVersion, app.Recipe.Name)
-	}
-
-	parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
-	if err != nil {
-		return err
-	}
-
-	if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) &&
-		!parsedSpecificVersion.Equals(parsedDeployedVersion) {
-		return fmt.Errorf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
-	}
-
-	if parsedSpecificVersion.Equals(parsedDeployedVersion) && !internal.Force {
-		return fmt.Errorf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
-	}
-
-	return nil
-}
-
-// ensureDeployed ensures the app is deployed and if so, returns deployment
-// meta info.
-func ensureDeployed(cl *dockerClient.Client, app app.App) (stack.DeployMeta, error) {
-	log.Debugf("checking whether %s is already deployed", app.StackName())
-
-	deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
-	if err != nil {
-		return stack.DeployMeta{}, err
-	}
-
-	if !deployMeta.IsDeployed {
-		return stack.DeployMeta{}, fmt.Errorf("%s is not deployed?", app.Name)
-	}
-
-	return deployMeta, nil
-}
-
-var (
-	showReleaseNotes bool
-)
-
-func init() {
-	AppUpgradeCommand.Flags().BoolVarP(
-		&internal.Force,
-		"force",
-		"f",
-		false,
-		"perform action without further prompt",
-	)
-
-	AppUpgradeCommand.Flags().BoolVarP(
-		&internal.NoDomainChecks,
-		"no-domain-checks",
-		"D",
-		false,
-		"disable public DNS checks",
-	)
-
-	AppUpgradeCommand.Flags().BoolVarP(
-		&internal.DontWaitConverge, "no-converge-checks",
-		"c",
-		false,
-		"disable converge logic checks",
-	)
-
-	AppUpgradeCommand.Flags().BoolVarP(
-		&showReleaseNotes,
-		"releasenotes",
-		"r",
-		false,
-		"only show release notes",
-	)
-}

cli/app/volume.go

@@ -10,22 +10,22 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var AppVolumeListCommand = &cobra.Command{
-	Use:     "list <domain> [flags]",
+var appVolumeListCommand = cli.Command{
+	Name:      "list",
 	Aliases:   []string{"ls"},
-	Short:   "List volumes associated with an app",
-	Args:    cobra.ExactArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.AppNameComplete()
+	ArgsUsage: "<domain>",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+	Before:       internal.SubCommandBefore,
+	Usage:        "List volumes associated with an app",
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
@@ -37,62 +37,54 @@ var AppVolumeListCommand = &cobra.Command{
 			log.Fatal(err)
 		}
 
-		volumes, err := client.GetVolumes(cl, context.Background(), app.Server, filters)
+		volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, filters)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		headers := []string{"NAME", "ON SERVER"}
-
-		table, err := formatter.CreateTable()
-		if err != nil {
-			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)
 		}
 
-		table.Headers(headers...)
-
-		var rows [][]string
-		for _, volume := range volumes {
-			row := []string{volume.Name, volume.Mountpoint}
-			rows = append(rows, row)
-		}
-
-		table.Rows(rows...)
-
-		if len(rows) > 0 {
-			if err := formatter.PrintTable(table); err != nil {
-				log.Fatal(err)
-			}
-			return
-		}
+		table.AppendBulk(volTable)
 
+		if table.NumLines() > 0 {
+			table.Render()
+		} else {
 			log.Warnf("no volumes created for %s", app.Name)
+		}
+
+		return nil
 	},
 }
 
-var AppVolumeRemoveCommand = &cobra.Command{
-	Use:   "remove <domain> [flags]",
-	Short: "Remove volume(s) associated with an app",
-	Long: `Remove volumes associated with an app.
-
-The app in question must be undeployed before you try to remove volumes. See
-"abra app undeploy <domain>" for more.
+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.
 
 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"},
-	Args:    cobra.MinimumNArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.AppNameComplete()
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		internal.ForceFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		app := internal.ValidateApp(args)
+	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 {
@@ -147,21 +139,18 @@ Passing "--force/-f" will select all volumes for removal. Be careful.`,
 		} else {
 			log.Info("no volumes removed")
 		}
+
+		return nil
 	},
 }
 
-var AppVolumeCommand = &cobra.Command{
-	Use:     "volume [cmd] [args] [flags]",
+var appVolumeCommand = cli.Command{
+	Name:      "volume",
 	Aliases:   []string{"vl"},
-	Short:   "Manage app volumes",
-}
-
-func init() {
-	AppVolumeRemoveCommand.Flags().BoolVarP(
-		&internal.Force,
-		"force",
-		"f",
-		false,
-		"perform action without further prompt",
-	)
+	Usage:     "Manage app volumes",
+	ArgsUsage: "<domain>",
+	Subcommands: []cli.Command{
+		appVolumeListCommand,
+		appVolumeRemoveCommand,
+	},
 }

cli/catalogue/catalogue.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io/ioutil"
 	"path"
-	"slices"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
@@ -16,49 +15,44 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/go-git/go-git/v5"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var CatalogueGenerateCommand = &cobra.Command{
-	Use:     "generate [recipe] [flags]",
+var catalogueGenerateCommand = cli.Command{
+	Name:    "generate",
 	Aliases: []string{"g"},
-	Short:   "Generate the recipe catalogue",
-	Long: `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.
+	Usage:   "Generate the recipe catalogue",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		internal.PublishFlag,
+		internal.DryFlag,
+		internal.SkipUpdatesFlag,
+		internal.ChaosFlag,
+		internal.OfflineFlag,
+	},
+	Before: internal.SubCommandBefore,
+	Description: `
+Generate a new copy of the recipe catalogue.
 
 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 "docker login" and Abra will automatically
-use those details.
+If you have a Hub account you can have Abra log you in to avoid this. Pass
+"--user" and "--pass".
 
-Push your new release to git.coopcloud.tech with "--publish/-p". This requires
+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.`,
-	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]
-		}
+	ArgsUsage:    "[<recipe>]",
+	BashComplete: autocomplete.RecipeNameComplete,
+	Action: func(c *cli.Context) error {
+		recipeName := c.Args().First()
+		r := recipe.Get(recipeName)
 
 		if recipeName != "" {
-			internal.ValidateRecipe(args, cmd.Name())
-		}
-
-		if err := catalogue.EnsureCatalogue(); err != nil {
-			log.Fatal(err)
+			internal.ValidateRecipe(c)
 		}
 
 		if !internal.Chaos {
@@ -67,48 +61,44 @@ keys configured on your account.`,
 			}
 		}
 
-		repos, err := recipe.ReadReposMetadata(internal.Debug)
+		repos, err := recipe.ReadReposMetadata()
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		barLength := len(repos)
+		var barLength int
+		var logMsg string
 		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 !skipUpdates {
-			if err := recipe.UpdateRepositories(repos, recipeName, internal.Debug); err != nil {
+		if !internal.SkipUpdates {
+			log.Warn(logMsg)
+			if err := recipe.UpdateRepositories(repos, recipeName); err != nil {
 				log.Fatal(err)
 			}
 		}
 
-		var warnings []string
 		catl := make(recipe.RecipeCatalogue)
-		catlBar := formatter.CreateProgressbar(barLength, "collecting catalogue metadata")
+		catlBar := formatter.CreateProgressbar(barLength, "generating catalogue metadata...")
 		for _, recipeMeta := range repos {
 			if recipeName != "" && recipeName != recipeMeta.Name {
-				if !internal.Debug {
 				catlBar.Add(1)
-				}
 				continue
 			}
 
-			r := recipe.Get(recipeMeta.Name)
-			versions, warnMsgs, err := r.GetRecipeVersions()
+			versions, err := r.GetRecipeVersions()
 			if err != nil {
-				warnings = append(warnings, err.Error())
-			}
-			if len(warnMsgs) > 0 {
-				warnings = append(warnings, warnMsgs...)
+				log.Warn(err)
 			}
 
-			features, category, warnMsgs, err := recipe.GetRecipeFeaturesAndCategory(r)
+			features, category, err := recipe.GetRecipeFeaturesAndCategory(r)
 			if err != nil {
-				warnings = append(warnings, err.Error())
-			}
-			if len(warnMsgs) > 0 {
-				warnings = append(warnings, warnMsgs...)
+				log.Warn(err)
 			}
 
 			catl[recipeMeta.Name] = recipe.RecipeMeta{
@@ -124,25 +114,8 @@ keys configured on your account.`,
 				Features:      features,
 			}
 
-			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 {
@@ -171,10 +144,10 @@ keys configured on your account.`,
 			}
 		}
 
-		log.Infof("generated recipe catalogue: %s", config.RECIPES_JSON)
+		log.Infof("generated new recipe catalogue in %s", config.RECIPES_JSON)
 
 		cataloguePath := path.Join(config.ABRA_DIR, "catalogue")
-		if publishChanges {
+		if internal.Publish {
 
 			isClean, err := gitPkg.IsClean(cataloguePath)
 			if err != nil {
@@ -197,7 +170,7 @@ keys configured on your account.`,
 				log.Fatal(err)
 			}
 
-			sshURL := fmt.Sprintf(config.TOOLSHED_SSH_URL_TEMPLATE, config.CATALOGUE_JSON_REPO_NAME)
+			sshURL := fmt.Sprintf(config.SSH_URL_TEMPLATE, config.CATALOGUE_JSON_REPO_NAME)
 			if err := gitPkg.CreateRemote(repo, "origin-ssh", sshURL, internal.Dry); err != nil {
 				log.Fatal(err)
 			}
@@ -217,7 +190,7 @@ keys configured on your account.`,
 			log.Fatal(err)
 		}
 
-		if !internal.Dry && publishChanges {
+		if !internal.Dry && internal.Publish {
 			url := fmt.Sprintf("%s/%s/commit/%s", config.REPOS_BASE_URL, config.CATALOGUE_JSON_REPO_NAME, head.Hash())
 			log.Infof("new changes published: %s", url)
 		}
@@ -225,51 +198,18 @@ keys configured on your account.`,
 		if internal.Dry {
 			log.Info("dry run: no changes published")
 		}
+
+		return nil
 	},
 }
 
 // CatalogueCommand defines the `abra catalogue` command and sub-commands.
-var CatalogueCommand = &cobra.Command{
-	Use:     "catalogue [cmd] [args] [flags]",
-	Short:   "Manage the recipe catalogue",
+var CatalogueCommand = cli.Command{
+	Name:      "catalogue",
+	Usage:     "Manage the recipe catalogue",
 	Aliases:   []string{"c"},
-}
-
-var (
-	publishChanges bool
-	skipUpdates    bool
-)
-
-func init() {
-	CatalogueGenerateCommand.Flags().BoolVarP(
-		&publishChanges,
-		"publish",
-		"p",
-		false,
-		"publish changes to git.coopcloud.tech",
-	)
-
-	CatalogueGenerateCommand.Flags().BoolVarP(
-		&internal.Dry,
-		"dry-run",
-		"r",
-		false,
-		"report changes that would be made",
-	)
-
-	CatalogueGenerateCommand.Flags().BoolVarP(
-		&skipUpdates,
-		"skip-updates",
-		"s",
-		false,
-		"skip updating recipe repositories",
-	)
-
-	CatalogueGenerateCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
+	ArgsUsage: "<recipe>",
+	Subcommands: []cli.Command{
+		catalogueGenerateCommand,
+	},
 }

cli/cli.go

@@ -0,0 +1,206 @@
+// 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"
+	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/web"
+	charmLog "github.com/charmbracelet/log"
+	"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",
+	Description: `
+Set up shell auto-completion.
+
+Supported shells are: 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 {
+			log.Fatalf("%s is not a supported shell right now, sorry", shellType)
+		}
+
+		if shellType == "fizsh" {
+			shellType = "zsh" // handled the same on the autocompletion side
+		}
+
+		autocompletionDir := path.Join(config.ABRA_DIR, "autocompletion")
+		if err := os.Mkdir(autocompletionDir, 0764); err != nil {
+			if !os.IsExist(err) {
+				log.Fatal(err)
+			}
+			log.Debugf("%s already created", autocompletionDir)
+		}
+
+		autocompletionFile := path.Join(config.ABRA_DIR, "autocompletion", shellType)
+		if _, err := os.Stat(autocompletionFile); err != nil && os.IsNotExist(err) {
+			url := fmt.Sprintf("https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/autocomplete/%s", shellType)
+			log.Infof("fetching %s", url)
+			if err := web.GetFile(autocompletionFile, url); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		switch shellType {
+		case "bash":
+			fmt.Println(fmt.Sprintf(`
+# run the following commands 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",
+	Description: `
+Upgrade abra in-place with the latest stable or release candidate.
+
+Use "-r/--rc" 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:
+
+    abra upgrade
+		abra upgrade --rc`,
+	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))
+		}
+
+		log.Debugf("attempting to run %s", cmd)
+
+		if err := internal.RunCmd(cmd); err != nil {
+			log.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) {
+					log.Fatal(err)
+				}
+				continue
+			}
+		}
+
+		charmLog.SetDefault(log.Logger)
+		log.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 {
+		log.Fatal(err)
+	}
+}

cli/complete.go

@@ -1,62 +0,0 @@
-package cli
-
-import (
-	"os"
-
-	"github.com/spf13/cobra"
-)
-
-var AutocompleteCommand = &cobra.Command{
-	Use:   "autocomplete [bash|zsh|fish|powershell]",
-	Short: "Generate autocompletion script",
-	Long: `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,8 +2,6 @@ package internal
 
 import (
 	"context"
-	"fmt"
-	"io"
 
 	"coopcloud.tech/abra/pkg/config"
 	containerPkg "coopcloud.tech/abra/pkg/container"
@@ -21,7 +19,7 @@ func RetrieveBackupBotContainer(cl *dockerClient.Client) (types.Container, error
 	ctx := context.Background()
 	chosenService, err := service.GetServiceByLabel(ctx, cl, config.BackupbotLabel, NoInput)
 	if err != nil {
-		return types.Container{}, fmt.Errorf("no backupbot discovered, is it deployed?")
+		return types.Container{}, err
 	}
 
 	log.Debugf("retrieved %s as backup enabled service", chosenService.Spec.Name)
@@ -42,11 +40,7 @@ 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) (io.Writer, error) {
+func RunBackupCmdRemote(cl *dockerClient.Client, backupCmd string, containerID string, execEnv []string) error {
 	execBackupListOpts := types.ExecConfig{
 		AttachStderr: true,
 		AttachStdin:  true,
@@ -62,13 +56,12 @@ func RunBackupCmdRemote(
 	// FIXME: avoid instantiating a new CLI
 	dcli, err := command.NewDockerCli()
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	out, err := container.RunExec(dcli, cl, containerID, &execBackupListOpts)
-	if err != nil {
-		return nil, err
+	if _, err := container.RunExec(dcli, cl, containerID, &execBackupListOpts); err != nil {
+		return err
 	}
 
-	return out, nil
+	return nil
 }

cli/internal/cli.go

@@ -1,20 +1,296 @@
 package internal
 
-var (
-	// NOTE(d1): global
-	Debug            bool
-	NoInput          bool
-	Offline          bool
-	IgnoreEnvVersion bool
+import (
+	"os"
 
-	// NOTE(d1): sub-command specific
-	Chaos            bool
-	DontWaitConverge bool
-	Dry              bool
-	Force            bool
-	MachineReadable  bool
-	Major            bool
-	Minor            bool
-	NoDomainChecks   bool
-	Patch            bool
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/urfave/cli"
 )
+
+// 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 public DNS 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,
+}
+
+var AllServices bool
+var AllServicesFlag = &cli.BoolFlag{
+	Name:        "all-services, a",
+	Usage:       "Restart all services",
+	Destination: &AllServices,
+}
+
+// SubCommandBefore wires up pre-action machinery (e.g. --debug handling).
+func SubCommandBefore(c *cli.Context) error {
+	if Debug {
+		log.SetLevel(log.DebugLevel)
+		log.SetOutput(os.Stderr)
+		log.SetReportCaller(true)
+	}
+
+	return nil
+}

cli/internal/command.go

@@ -21,11 +21,7 @@ import (
 )
 
 // RunCmdRemote executes an abra.sh command in the target service
-func RunCmdRemote(
-	cl *dockerClient.Client,
-	app appPkg.App,
-	requestTTY bool,
-	abraSh, serviceName, cmdName, cmdArgs, remoteUser string) error {
+func RunCmdRemote(cl *dockerClient.Client, app appPkg.App, abraSh, serviceName, cmdName, cmdArgs string) error {
 	filters := filters.NewArgs()
 	filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), serviceName))
 
@@ -78,15 +74,15 @@ func RunCmdRemote(
 
 	log.Debugf("running command: %s", strings.Join(cmd, " "))
 
-	if remoteUser != "" {
-		log.Debugf("running command with user %s", remoteUser)
-		execCreateOpts.User = remoteUser
+	if RemoteUser != "" {
+		log.Debugf("running command with user %s", RemoteUser)
+		execCreateOpts.User = RemoteUser
 	}
 
 	execCreateOpts.Cmd = cmd
-	execCreateOpts.Tty = requestTTY
-	if !requestTTY {
-		log.Debugf("not requesting a remote TTY")
+	execCreateOpts.Tty = true
+	if Tty {
+		execCreateOpts.Tty = false
 	}
 
 	if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {

cli/internal/deploy.go

@@ -3,53 +3,23 @@ package internal
 import (
 	"fmt"
 	"os"
-	"sort"
 	"strings"
 
 	appPkg "coopcloud.tech/abra/pkg/app"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
-	"coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/charmbracelet/lipgloss"
 	dockerClient "github.com/docker/docker/client"
 )
 
-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)
-}
-
 // NewVersionOverview shows an upgrade or downgrade overview
-func NewVersionOverview(
-	app appPkg.App,
-	warnMessages []string,
-	kind,
-	deployedVersion,
-	deployedChaosVersion,
-	toDeployVersion,
-	releaseNotes string) error {
+func NewVersionOverview(app appPkg.App, currentVersion, chaosVersion, newVersion, releaseNotes string) error {
+	tableCol := []string{"server", "recipe", "config", "domain", "version", "chaos", "to deploy"}
+	table := formatter.CreateTable(tableCol)
+
 	deployConfig := "compose.yml"
 	if composeFiles, ok := app.Env["COMPOSE_FILE"]; ok {
-		deployConfig = composeFiles
+		deployConfig = strings.Join(strings.Split(composeFiles, ":"), "\n")
 	}
 
 	server := app.Server
@@ -57,58 +27,22 @@ func NewVersionOverview(
 		server = "local"
 	}
 
-	domain := app.Domain
-	if domain == "" {
-		domain = config.NO_DOMAIN_DEFAULT
-	}
+	table.Append([]string{
+		server,
+		app.Recipe.Name,
+		deployConfig,
+		app.Domain,
+		currentVersion,
+		chaosVersion,
+		newVersion,
+	})
+	table.Render()
 
-	upperKind := strings.ToUpper(kind)
-
-	envVersion, err := recipe.GetEnvVersionRaw(app.Recipe.Name)
-	if err != nil {
-		return err
-	}
-
-	if envVersion == "" {
-		envVersion = config.NO_VERSION_DEFAULT
-	}
-
-	rows := [][]string{
-		{"DOMAIN", domain},
-		{"RECIPE", app.Recipe.Name},
-		{"SERVER", server},
-		{"CONFIG", deployConfig},
-
-		{"CURRENT DEPLOYMENT", "---"},
-		{"VERSION", formatter.BoldDirtyDefault(deployedVersion)},
-		{"CHAOS ", formatter.BoldDirtyDefault(deployedChaosVersion)},
-
-		{upperKind, "---"},
-		{"VERSION", formatter.BoldDirtyDefault(toDeployVersion)},
-
-		{fmt.Sprintf("%s.ENV", strings.ToUpper(app.Domain)), "---"},
-		{"CURRENT VERSION", formatter.BoldDirtyDefault(envVersion)},
-		{"NEW VERSION", formatter.BoldDirtyDefault(toDeployVersion)},
-	}
-
-	overview := formatter.CreateOverview(
-		fmt.Sprintf("%s OVERVIEW", upperKind),
-		rows,
-	)
-
-	fmt.Println(overview)
-
-	if releaseNotes != "" && toDeployVersion != "" {
+	if releaseNotes != "" && newVersion != "" {
+		fmt.Println()
 		fmt.Print(releaseNotes)
 	} else {
-		warnMessages = append(
-			warnMessages,
-			fmt.Sprintf("no release notes available for %s", toDeployVersion),
-		)
-	}
-
-	for _, msg := range warnMessages {
-		log.Warn(msg)
+		log.Warnf("no release notes available for %s", newVersion)
 	}
 
 	if NoInput {
@@ -116,173 +50,16 @@ func NewVersionOverview(
 	}
 
 	response := false
-	prompt := &survey.Confirm{Message: "proceed?"}
+	prompt := &survey.Confirm{
+		Message: "continue with deployment?",
+	}
+
 	if err := survey.AskOne(prompt, &response); err != nil {
 		return err
 	}
 
 	if !response {
-		log.Fatal("deployment cancelled")
-	}
-
-	return nil
-}
-
-// DeployOverview shows a deployment overview
-func DeployOverview(
-	app appPkg.App,
-	warnMessages []string,
-	deployedVersion string,
-	deployedChaosVersion string,
-	toDeployVersion,
-	toDeployChaosVersion string,
-	toWriteVersion string,
-) error {
-	deployConfig := "compose.yml"
-	if composeFiles, ok := app.Env["COMPOSE_FILE"]; ok {
-		deployConfig = composeFiles
-	}
-
-	server := app.Server
-	if app.Server == "default" {
-		server = "local"
-	}
-
-	domain := app.Domain
-	if domain == "" {
-		domain = config.NO_DOMAIN_DEFAULT
-	}
-
-	if app.Recipe.Dirty {
-		toWriteVersion = formatter.AddDirtyMarker(toWriteVersion)
-		toDeployChaosVersion = formatter.AddDirtyMarker(toDeployChaosVersion)
-	}
-
-	recipeName, exists := app.Env["RECIPE"]
-	if !exists {
-		recipeName = app.Env["TYPE"]
-	}
-
-	envVersion, err := recipe.GetEnvVersionRaw(recipeName)
-	if err != nil {
-		return err
-	}
-
-	if envVersion == "" {
-		envVersion = config.NO_VERSION_DEFAULT
-	}
-
-	rows := [][]string{
-		{"DOMAIN", domain},
-		{"RECIPE", app.Recipe.Name},
-		{"SERVER", server},
-		{"CONFIG", deployConfig},
-
-		{"CURRENT DEPLOYMENT", "---"},
-		{"VERSION", formatter.BoldDirtyDefault(deployedVersion)},
-		{"CHAOS", formatter.BoldDirtyDefault(deployedChaosVersion)},
-
-		{"NEW DEPLOYMENT", "---"},
-		{"VERSION", formatter.BoldDirtyDefault(toDeployVersion)},
-		{"CHAOS", formatter.BoldDirtyDefault(toDeployChaosVersion)},
-
-		{fmt.Sprintf("%s.ENV", strings.ToUpper(app.Name)), "---"},
-		{"CURRENT VERSION", formatter.BoldDirtyDefault(envVersion)},
-		{"NEW VERSION", formatter.BoldDirtyDefault(toWriteVersion)},
-	}
-
-	overview := formatter.CreateOverview("DEPLOY OVERVIEW", rows)
-
-	fmt.Println(overview)
-
-	for _, msg := range warnMessages {
-		log.Warn(msg)
-	}
-
-	if NoInput {
-		return nil
-	}
-
-	response := false
-	prompt := &survey.Confirm{Message: "proceed?"}
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
-	}
-
-	if !response {
-		log.Fatal("deployment cancelled")
-	}
-
-	return nil
-}
-
-// UndeployOverview shows an undeployment overview
-func UndeployOverview(
-	app appPkg.App,
-	deployedVersion,
-	deployedChaosVersion,
-	toWriteVersion string,
-) error {
-	deployConfig := "compose.yml"
-	if composeFiles, ok := app.Env["COMPOSE_FILE"]; ok {
-		deployConfig = composeFiles
-	}
-
-	server := app.Server
-	if app.Server == "default" {
-		server = "local"
-	}
-
-	domain := app.Domain
-	if domain == "" {
-		domain = config.NO_DOMAIN_DEFAULT
-	}
-
-	recipeName, exists := app.Env["RECIPE"]
-	if !exists {
-		recipeName = app.Env["TYPE"]
-	}
-
-	envVersion, err := recipe.GetEnvVersionRaw(recipeName)
-	if err != nil {
-		return err
-	}
-
-	if envVersion == "" {
-		envVersion = config.NO_VERSION_DEFAULT
-	}
-
-	rows := [][]string{
-		{"DOMAIN", domain},
-		{"RECIPE", app.Recipe.Name},
-		{"SERVER", server},
-		{"CONFIG", deployConfig},
-
-		{"CURRENT DEPLOYMENT", "---"},
-		{"VERSION", formatter.BoldDirtyDefault(deployedVersion)},
-		{"CHAOS", formatter.BoldDirtyDefault(deployedChaosVersion)},
-
-		{fmt.Sprintf("%s.ENV", strings.ToUpper(app.Name)), "---"},
-		{"CURRENT VERSION", formatter.BoldDirtyDefault(envVersion)},
-		{"NEW VERSION", formatter.BoldDirtyDefault(toWriteVersion)},
-	}
-
-	overview := formatter.CreateOverview("UNDEPLOY OVERVIEW", rows)
-
-	fmt.Println(overview)
-
-	if NoInput {
-		return nil
-	}
-
-	response := false
-	prompt := &survey.Confirm{Message: "proceed?"}
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
-	}
-
-	if !response {
-		log.Fatal("undeploy cancelled")
+		log.Fatal("exiting as requested")
 	}
 
 	return nil
@@ -334,33 +111,55 @@ func PostCmds(cl *dockerClient.Client, app appPkg.App, commands string) error {
 
 		log.Debugf("running command %s %s within the context of %s_%s", cmdName, parsedCmdArgs, app.StackName(), targetServiceName)
 
-		requestTTY := true
-		if err := RunCmdRemote(
-			cl,
-			app,
-			requestTTY,
-			app.Recipe.AbraShPath, targetServiceName, cmdName, parsedCmdArgs, ""); err != nil {
+		Tty = true
+		if err := RunCmdRemote(cl, app, app.Recipe.AbraShPath, targetServiceName, cmdName, parsedCmdArgs); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-// SortVersionsDesc sorts versions in descending order.
-func SortVersionsDesc(versions []string) []string {
-	var tags []tagcmp.Tag
+// DeployOverview shows a deployment overview
+func DeployOverview(app appPkg.App, version, chaosVersion, message string) error {
+	tableCol := []string{"server", "recipe", "config", "domain", "version", "chaos"}
+	table := formatter.CreateTable(tableCol)
 
-	for _, v := range versions {
-		parsed, _ := tagcmp.Parse(v) // skips unsupported tags
-		tags = append(tags, parsed)
+	deployConfig := "compose.yml"
+	if composeFiles, ok := app.Env["COMPOSE_FILE"]; ok {
+		deployConfig = strings.Join(strings.Split(composeFiles, ":"), "\n")
 	}
 
-	sort.Sort(tagcmp.ByTagDesc(tags))
-
-	var desc []string
-	for _, t := range tags {
-		desc = append(desc, t.String())
+	server := app.Server
+	if app.Server == "default" {
+		server = "local"
 	}
 
-	return desc
+	table.Append([]string{
+		server,
+		app.Recipe.Name,
+		deployConfig,
+		app.Domain,
+		version,
+		chaosVersion,
+	})
+	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 {
+		log.Fatal("exiting as requested")
+	}
+
+	return nil
 }

cli/internal/deploy_test.go

@@ -1,17 +0,0 @@
-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

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

cli/internal/errors.go

@@ -0,0 +1,18 @@
+package internal
+
+import (
+	"os"
+
+	"coopcloud.tech/abra/pkg/log"
+	"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 {
+		log.Error(err2)
+	}
+	log.Error(err)
+	os.Exit(1)
+}

cli/internal/list.go

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

cli/internal/validate.go

@@ -1,6 +1,7 @@
 package internal
 
 import (
+	"errors"
 	"strings"
 
 	"coopcloud.tech/abra/pkg/app"
@@ -8,14 +9,12 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/AlecAivazis/survey/v2"
+	"github.com/urfave/cli"
 )
 
 // ValidateRecipe ensures the recipe arg is valid.
-func ValidateRecipe(args []string, cmdName string) recipe.Recipe {
-	var recipeName string
-	if len(args) > 0 {
-		recipeName = args[0]
-	}
+func ValidateRecipe(c *cli.Context) recipe.Recipe {
+	recipeName := c.Args().First()
 
 	if recipeName == "" && !NoInput {
 		var recipes []string
@@ -55,7 +54,7 @@ func ValidateRecipe(args []string, cmdName string) recipe.Recipe {
 	}
 
 	if recipeName == "" {
-		log.Fatal("no recipe name provided")
+		ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
 	}
 
 	chosenRecipe := recipe.Get(recipeName)
@@ -65,7 +64,7 @@ func ValidateRecipe(args []string, cmdName string) recipe.Recipe {
 	}
 	_, err = chosenRecipe.GetComposeConfig(nil)
 	if err != nil {
-		if cmdName == "generate" {
+		if c.Command.Name == "generate" {
 			if strings.Contains(err.Error(), "missing a compose") {
 				log.Fatal(err)
 			}
@@ -84,12 +83,12 @@ func ValidateRecipe(args []string, cmdName string) recipe.Recipe {
 }
 
 // ValidateApp ensures the app name arg is valid.
-func ValidateApp(args []string) app.App {
-	if len(args) == 0 {
-		log.Fatal("no app provided")
-	}
+func ValidateApp(c *cli.Context) app.App {
+	appName := c.Args().First()
 
-	appName := args[0]
+	if appName == "" {
+		ShowSubcommandHelpAndError(c, errors.New("no app provided"))
+	}
 
 	app, err := app.Get(appName)
 	if err != nil {
@@ -102,11 +101,8 @@ func ValidateApp(args []string) app.App {
 }
 
 // ValidateDomain ensures the domain name arg is valid.
-func ValidateDomain(args []string) string {
-	var domainName string
-	if len(args) > 0 {
-		domainName = args[0]
-	}
+func ValidateDomain(c *cli.Context) string {
+	domainName := c.Args().First()
 
 	if domainName == "" && !NoInput {
 		prompt := &survey.Input{
@@ -119,7 +115,7 @@ func ValidateDomain(args []string) string {
 	}
 
 	if domainName == "" {
-		log.Fatal("no domain provided")
+		ShowSubcommandHelpAndError(c, errors.New("no domain provided"))
 	}
 
 	log.Debugf("validated %s as domain argument", domainName)
@@ -127,12 +123,23 @@ func ValidateDomain(args []string) string {
 	return domainName
 }
 
-// ValidateServer ensures the server name arg is valid.
-func ValidateServer(args []string) string {
-	var serverName string
-	if len(args) > 0 {
-		serverName = args[0]
+// 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()
 
 	serverNames, err := config.ReadServerNames()
 	if err != nil {
@@ -157,11 +164,11 @@ func ValidateServer(args []string) string {
 	}
 
 	if serverName == "" {
-		log.Fatal("no server provided")
+		ShowSubcommandHelpAndError(c, errors.New("no server provided"))
 	}
 
 	if !matched {
-		log.Fatal("server doesn't exist?")
+		ShowSubcommandHelpAndError(c, errors.New("server doesn't exist?"))
 	}
 
 	log.Debugf("validated %s as server argument", serverName)

cli/recipe/diff.go

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

cli/recipe/fetch.go

@@ -6,41 +6,31 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var RecipeFetchCommand = &cobra.Command{
-	Use:     "fetch [recipe | --all] [flags]",
+var recipeFetchCommand = cli.Command{
+	Name:        "fetch",
+	Usage:       "Fetch recipe(s)",
 	Aliases:     []string{"f"},
-	Short:   "Clone recipe(s) locally",
-	Args:    cobra.RangeArgs(0, 1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.RecipeNameComplete()
+	ArgsUsage:   "[<recipe>]",
+	Description: "Retrieves all recipes if no <recipe> argument is passed",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		internal.OfflineFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		var recipeName string
-		if len(args) > 0 {
-			recipeName = args[0]
-		}
-
-		if recipeName == "" && !fetchAllRecipes {
-			log.Fatal("missing [recipe] or --all/-a")
-		}
-
-		if recipeName != "" && fetchAllRecipes {
-			log.Fatal("cannot use [recipe] and --all/-a together")
-		}
-
-		ensureCtx := internal.GetEnsureContext()
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.RecipeNameComplete,
+	Action: func(c *cli.Context) error {
+		recipeName := c.Args().First()
+		r := recipe.Get(recipeName)
 		if recipeName != "" {
-			r := internal.ValidateRecipe(args, cmd.Name())
-			if err := r.Ensure(ensureCtx); err != nil {
+			internal.ValidateRecipe(c)
+			if err := r.Ensure(false, false); err != nil {
 				log.Fatal(err)
 			}
-			return
+			return nil
 		}
 
 		catalogue, err := recipe.ReadRecipeCatalogue(internal.Offline)
@@ -51,24 +41,12 @@ var RecipeFetchCommand = &cobra.Command{
 		catlBar := formatter.CreateProgressbar(len(catalogue), "fetching latest recipes...")
 		for recipeName := range catalogue {
 			r := recipe.Get(recipeName)
-			if err := r.Ensure(ensureCtx); err != nil {
+			if err := r.Ensure(false, false); err != nil {
 				log.Error(err)
 			}
 			catlBar.Add(1)
 		}
+
+		return nil
 	},
 }
-
-var (
-	fetchAllRecipes bool
-)
-
-func init() {
-	RecipeFetchCommand.Flags().BoolVarP(
-		&fetchAllRecipes,
-		"all",
-		"a",
-		false,
-		"fetch all recipes",
-	)
-}

cli/recipe/lint.go

@@ -1,54 +1,45 @@
 package recipe
 
 import (
+	"fmt"
+
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var RecipeLintCommand = &cobra.Command{
-	Use:     "lint <recipe> [flags]",
-	Short:   "Lint a recipe",
+var recipeLintCommand = cli.Command{
+	Name:      "lint",
+	Usage:     "Lint a recipe",
 	Aliases:   []string{"l"},
-	Args:    cobra.MinimumNArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.RecipeNameComplete()
+	ArgsUsage: "<recipe>",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.OnlyErrorFlag,
+		internal.OfflineFlag,
+		internal.NoInputFlag,
+		internal.ChaosFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		recipe := internal.ValidateRecipe(args, cmd.Name())
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.RecipeNameComplete,
+	Action: func(c *cli.Context) error {
+		recipe := internal.ValidateRecipe(c)
 
-		if err := recipe.Ensure(internal.GetEnsureContext()); err != nil {
+		if err := recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
-		headers := []string{
-			"ref",
-			"rule",
-			"severity",
-			"satisfied",
-			"skipped",
-			"resolve",
-		}
-
-		table, err := formatter.CreateTable()
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		table.Headers(headers...)
+		tableCol := []string{"ref", "rule", "severity", "satisfied", "skipped", "resolve"}
+		table := formatter.CreateTable(tableCol)
 
 		hasError := false
-		var rows [][]string
-		var warnMessages []string
+		bar := formatter.CreateProgressbar(-1, "running recipe lint rules...")
 		for level := range lint.LintRules {
 			for _, rule := range lint.LintRules[level] {
-				if onlyError && rule.Level != "error" {
+				if internal.OnlyErrors && rule.Level != "error" {
 					log.Debugf("skipping %s, does not have level \"error\"", rule.Ref)
 					continue
 				}
@@ -67,7 +58,7 @@ var RecipeLintCommand = &cobra.Command{
 				if !skipped {
 					ok, err := rule.Function(recipe)
 					if err != nil {
-						warnMessages = append(warnMessages, err.Error())
+						log.Warn(err)
 					}
 
 					if !ok && rule.Level == "error" {
@@ -87,54 +78,28 @@ var RecipeLintCommand = &cobra.Command{
 					}
 				}
 
-				row := []string{
+				table.Append([]string{
 					rule.Ref,
 					rule.Description,
 					rule.Level,
 					satisfiedOutput,
 					skippedOutput,
 					rule.HowToResolve,
-				}
+				})
 
-				rows = append(rows, row)
-				table.Row(row...)
+				bar.Add(1)
 			}
 		}
 
-		if len(rows) > 0 {
-			if err := formatter.PrintTable(table); err != nil {
-				log.Fatal(err)
-			}
-
-			for _, warnMsg := range warnMessages {
-				log.Warn(warnMsg)
+		if table.NumLines() > 0 {
+			fmt.Println()
+			table.Render()
 		}
 
 		if hasError {
-				log.Warnf("critical errors present in %s config", recipe.Name)
-			}
+			log.Warn("watch out, some critical errors are present in your recipe config")
 		}
+
+		return nil
 	},
 }
-
-var (
-	onlyError bool
-)
-
-func init() {
-	RecipeLintCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-
-	RecipeLintCommand.Flags().BoolVarP(
-		&onlyError,
-		"error",
-		"e",
-		false,
-		"only show errors",
-	)
-}

cli/recipe/list.go

@@ -10,44 +10,43 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var RecipeListCommand = &cobra.Command{
-	Use:     "list",
-	Short:   "List recipes",
+var pattern string
+var patternFlag = &cli.StringFlag{
+	Name:        "pattern, p",
+	Value:       "",
+	Usage:       "Simple string to filter recipes",
+	Destination: &pattern,
+}
+
+var recipeListCommand = cli.Command{
+	Name:    "list",
+	Usage:   "List available recipes",
 	Aliases: []string{"ls"},
-	Args:    cobra.NoArgs,
-	Run: func(cmd *cobra.Command, args []string) {
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.MachineReadableFlag,
+		patternFlag,
+		internal.OfflineFlag,
+	},
+	Before: internal.SubCommandBefore,
+	Action: func(c *cli.Context) error {
 		catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
-			log.Fatal(err)
+			log.Fatal(err.Error())
 		}
 
 		recipes := catl.Flatten()
 		sort.Sort(recipe.ByRecipeName(recipes))
 
-		table, err := formatter.CreateTable()
-		if err != nil {
-			log.Fatal(err)
-		}
+		tableCol := []string{"name", "category", "status", "healthcheck", "backups", "email", "tests", "SSO"}
+		table := formatter.CreateTable(tableCol)
 
-		headers := []string{
-			"name",
-			"category",
-			"status",
-			"healthcheck",
-			"backups",
-			"email",
-			"tests",
-			"SSO",
-		}
-
-		table.Headers(headers...)
-
-		var rows [][]string
+		len := 0
 		for _, recipe := range recipes {
-			row := []string{
+			tableRow := []string{
 				recipe.Name,
 				recipe.Category,
 				strconv.Itoa(recipe.Features.Status),
@@ -60,50 +59,25 @@ var RecipeListCommand = &cobra.Command{
 
 			if pattern != "" {
 				if strings.Contains(recipe.Name, pattern) {
-					table.Row(row...)
-					rows = append(rows, row)
+					table.Append(tableRow)
+					len++
 				}
 			} else {
-				table.Row(row...)
-				rows = append(rows, row)
+				table.Append(tableRow)
+				len++
 			}
 		}
 
-		if len(rows) > 0 {
+		if table.NumLines() > 0 {
 			if internal.MachineReadable {
-				out, err := formatter.ToJSON(headers, rows)
-				if err != nil {
-					log.Fatal("unable to render to JSON: %s", err)
+				table.SetCaption(false, "")
+				table.JSONRender()
+			} else {
+				table.SetCaption(true, fmt.Sprintf("total recipes: %v", len))
+				table.Render()
 			}
-				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,
-		"machine",
-		"m",
-		false,
-		"print machine-readable output",
-	)
-
-	RecipeListCommand.Flags().StringVarP(
-		&pattern,
-		"pattern",
-		"p",
-		"",
-		"filter by recipe",
-	)
-}

cli/recipe/new.go

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

cli/recipe/recipe.go

@@ -1,19 +1,34 @@
 package recipe
 
-import "github.com/spf13/cobra"
+import (
+	"github.com/urfave/cli"
+)
 
 // RecipeCommand defines all recipe related sub-commands.
-var RecipeCommand = &cobra.Command{
-	Use:     "recipe [cmd] [args] [flags]",
+var RecipeCommand = cli.Command{
+	Name:      "recipe",
 	Aliases:   []string{"r"},
-	Short:   "Manage recipes",
-	Long: `A recipe is a blueprint for an app.
-
-It is a bunch of config files which describe how to deploy and maintain an app.
-Recipes are maintained by the Co-op Cloud community and you can use Abra to
-read them, deploy them and create apps for you.
+	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.
 
 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.`,
+	Subcommands: []cli.Command{
+		recipeFetchCommand,
+		recipeLintCommand,
+		recipeListCommand,
+		recipeNewCommand,
+		recipeReleaseCommand,
+		recipeSyncCommand,
+		recipeUpgradeCommand,
+		recipeVersionCommand,
+		recipeResetCommand,
+		recipeDiffCommand,
+	},
 }

cli/recipe/release.go

@@ -18,17 +18,17 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
 	"github.com/go-git/go-git/v5"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var RecipeReleaseCommand = &cobra.Command{
-	Use:     "release <recipe> [version] [flags]",
+var recipeReleaseCommand = cli.Command{
+	Name:      "release",
 	Aliases:   []string{"rl"},
-	Short:   "Release a new recipe version",
-	Long: `Create a new version of a recipe.
-
-These versions are then published on the Co-op Cloud recipe catalogue. These
-versions take the following form:
+	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:
 
     a.b.c+x.y.z
 
@@ -42,25 +42,23 @@ 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 "--publish/-p". This
+Publish 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.`,
-	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
-		}
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		internal.DryFlag,
+		internal.MajorFlag,
+		internal.MinorFlag,
+		internal.PatchFlag,
+		internal.PublishFlag,
+		internal.OfflineFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		recipe := internal.ValidateRecipe(args, cmd.Name())
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.RecipeNameComplete,
+	Action: func(c *cli.Context) error {
+		recipe := internal.ValidateRecipe(c)
 
 		imagesTmp, err := getImageVersions(recipe)
 		if err != nil {
@@ -77,11 +75,7 @@ your SSH keys configured on your account.`,
 			log.Fatalf("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 {
 				log.Fatalf("cannot parse %s, invalid tag specified?", tagString)
@@ -139,7 +133,7 @@ your SSH keys configured on your account.`,
 			}
 		}
 
-		return
+		return nil
 	},
 }
 
@@ -252,14 +246,7 @@ func getTagCreateOptions(tag string) (git.CreateTagOptions, error) {
 // addReleaseNotes checks if the release/next release note exists and moves the
 // file to release/<tag>.
 func addReleaseNotes(recipe recipe.Recipe, tag string) error {
-	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)
+	tagReleaseNotePath := path.Join(recipe.Dir, "release", tag)
 	if _, err := os.Stat(tagReleaseNotePath); err == nil {
 		// Release note for current tag already exist exists.
 		return nil
@@ -267,55 +254,49 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 		return err
 	}
 
-	var addNextAsReleaseNotes bool
-
-	nextReleaseNotePath := path.Join(releaseDir, "next")
+	nextReleaseNotePath := path.Join(recipe.Dir, "release", "next")
 	if _, err := os.Stat(nextReleaseNotePath); err == nil {
 		// release/next note exists. Move it to release/<tag>
 		if internal.Dry {
 			log.Debugf("dry run: move release note from 'next' to %s", tag)
 			return nil
 		}
-
 		if !internal.NoInput {
-			prompt := &survey.Confirm{
+			prompt := &survey.Input{
 				Message: "Use release note in release/next?",
 			}
-
-			if err := survey.AskOne(prompt, &addNextAsReleaseNotes); err != nil {
+			var addReleaseNote bool
+			if err := survey.AskOne(prompt, &addReleaseNote); err != nil {
 				return err
 			}
-
-			if !addNextAsReleaseNotes {
+			if !addReleaseNote {
 				return nil
 			}
 		}
-
-		if err := os.Rename(nextReleaseNotePath, tagReleaseNotePath); err != nil {
+		err := os.Rename(nextReleaseNotePath, tagReleaseNotePath)
+		if err != nil {
 			return err
 		}
-
-		if err := gitPkg.Add(recipe.Dir, path.Join("release", "next"), internal.Dry); err != nil {
+		err = gitPkg.Add(recipe.Dir, path.Join("release", "next"), internal.Dry)
+		if err != nil {
 			return err
 		}
-
-		if err := gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry); err != nil {
+		err = gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry)
+		if err != nil {
 			return err
 		}
 	} else if !errors.Is(err, os.ErrNotExist) {
 		return err
 	}
 
-	// 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 {
+	// No release note exists for the current release.
+	if internal.NoInput {
 		return nil
 	}
 
 	prompt := &survey.Input{
 		Message: "Release Note (leave empty for no release note)",
 	}
-
 	var releaseNote string
 	if err := survey.AskOne(prompt, &releaseNote); err != nil {
 		return err
@@ -325,11 +306,12 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 		return nil
 	}
 
-	if err := os.WriteFile(tagReleaseNotePath, []byte(releaseNote), 0o644); err != nil {
+	err := os.WriteFile(tagReleaseNotePath, []byte(releaseNote), 0o644)
+	if err != nil {
 		return err
 	}
-
-	if err := gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry); err != nil {
+	err = gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry)
+	if err != nil {
 		return err
 	}
 
@@ -394,17 +376,17 @@ func pushRelease(recipe recipe.Recipe, tagString string) error {
 		return nil
 	}
 
-	if !publish && !internal.NoInput {
+	if !internal.Publish && !internal.NoInput {
 		prompt := &survey.Confirm{
 			Message: "publish new release?",
 		}
 
-		if err := survey.AskOne(prompt, &publish); err != nil {
+		if err := survey.AskOne(prompt, &internal.Publish); err != nil {
 			return err
 		}
 	}
 
-	if publish {
+	if internal.Publish {
 		if err := recipe.Push(internal.Dry); err != nil {
 			return err
 		}
@@ -564,50 +546,3 @@ func getLabelVersion(recipe recipe.Recipe, prompt bool) (string, error) {
 
 	return initTag, nil
 }
-
-var (
-	publish bool
-)
-
-func init() {
-	RecipeReleaseCommand.Flags().BoolVarP(
-		&internal.Dry,
-		"dry-run",
-		"r",
-		false,
-		"report changes that would be made",
-	)
-
-	RecipeReleaseCommand.Flags().BoolVarP(
-		&internal.Major,
-		"major",
-		"x",
-		false,
-		"increase the major part of the version",
-	)
-
-	RecipeReleaseCommand.Flags().BoolVarP(
-		&internal.Minor,
-		"minor",
-		"y",
-		false,
-		"increase the minor part of the version",
-	)
-
-	RecipeReleaseCommand.Flags().BoolVarP(
-		&internal.Patch,
-		"patch",
-		"z",
-		false,
-		"increase the patch part of the version",
-	)
-
-	RecipeReleaseCommand.Flags().BoolVarP(
-		&publish,
-		"publish",
-		"p",
-		false,
-		"publish changes to git.coopcloud.tech",
-	)
-
-}

cli/recipe/reset.go

@@ -4,24 +4,30 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/go-git/go-git/v5"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var RecipeResetCommand = &cobra.Command{
-	Use:     "reset <recipe> [flags]",
+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"},
-	Short:   "Remove all unstaged changes from recipe config",
-	Long:    "WARNING: this will delete your changes. Be Careful.",
-	Args:    cobra.ExactArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.RecipeNameComplete()
+	ArgsUsage:   "<recipe>",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		r := internal.ValidateRecipe(args, cmd.Name())
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.RecipeNameComplete,
+	Action: func(c *cli.Context) error {
+		recipeName := c.Args().First()
+		r := recipe.Get(recipeName)
+
+		if recipeName != "" {
+			internal.ValidateRecipe(c)
+		}
 
 		repo, err := git.PlainOpen(r.Dir)
 		if err != nil {
@@ -42,5 +48,7 @@ var RecipeResetCommand = &cobra.Command{
 		if err := worktree.Reset(opts); err != nil {
 			log.Fatal(err)
 		}
+
+		return nil
 	},
 }

cli/recipe/sync.go

@@ -12,38 +12,35 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var RecipeSyncCommand = &cobra.Command{
-	Use:     "sync <recipe> [version] [flags]",
+var recipeSyncCommand = cli.Command{
+	Name:      "sync",
 	Aliases:   []string{"s"},
-	Short:   "Sync recipe version label",
-	Long: `Generate labels for the main recipe service.
-
-By convention, the service named "app" using the following format:
+	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:
 
     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.`,
-	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())
+	BashComplete: autocomplete.RecipeNameComplete,
+	Action: func(c *cli.Context) error {
+		recipe := internal.ValidateRecipe(c)
 
 		mainApp, err := internal.GetMainAppImage(recipe)
 		if err != nil {
@@ -62,11 +59,7 @@ local file system.`,
 			log.Fatal(err)
 		}
 
-		var nextTag string
-		if len(args) == 2 {
-			nextTag = args[1]
-		}
-
+		nextTag := c.Args().Get(1)
 		if len(tags) == 0 && nextTag == "" {
 			log.Warnf("no git tags found for %s", recipe.Name)
 			if internal.NoInput {
@@ -212,39 +205,7 @@ likely to change.
 				log.Fatal(err)
 			}
 		}
+
+		return nil
 	},
 }
-
-func init() {
-	RecipeSyncCommand.Flags().BoolVarP(
-		&internal.Dry,
-		"dry-run",
-		"r",
-		false,
-		"report changes that would be made",
-	)
-
-	RecipeSyncCommand.Flags().BoolVarP(
-		&internal.Major,
-		"major",
-		"x",
-		false,
-		"increase the major part of the version",
-	)
-
-	RecipeSyncCommand.Flags().BoolVarP(
-		&internal.Minor,
-		"minor",
-		"y",
-		false,
-		"increase the minor part of the version",
-	)
-
-	RecipeSyncCommand.Flags().BoolVarP(
-		&internal.Patch,
-		"patch",
-		"z",
-		false,
-		"increase the patch part of the version",
-	)
-}

cli/recipe/upgrade.go

@@ -19,7 +19,7 @@ import (
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
 type imgPin struct {
@@ -27,8 +27,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"`
@@ -36,13 +36,14 @@ type anUpgrade struct {
 	UpgradeTags []string `json:"upgrades"`
 }
 
-var RecipeUpgradeCommand = &cobra.Command{
-	Use:     "upgrade <recipe> [flags]",
+var recipeUpgradeCommand = cli.Command{
+	Name:    "upgrade",
 	Aliases: []string{"u"},
-	Short:   "Upgrade recipe image tags",
-	Long: `Upgrade a given <recipe> configuration.
-
-It will update the relevant compose file tags on the local file system.
+	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.
 
 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
@@ -52,18 +53,27 @@ 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.`,
-	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) {
-		recipe := internal.ValidateRecipe(args, cmd.Name())
+You may invoke this command in "wizard" mode and be prompted for input.
 
-		if err := recipe.Ensure(internal.GetEnsureContext()); err != nil {
+EXAMPLE:
+
+    abra recipe upgrade`,
+	ArgsUsage: "<recipe>",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		internal.PatchFlag,
+		internal.MinorFlag,
+		internal.MajorFlag,
+		internal.MachineReadableFlag,
+		internal.AllTagsFlag,
+	},
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.RecipeNameComplete,
+	Action: func(c *cli.Context) error {
+		recipe := internal.ValidateRecipe(c)
+
+		if err := recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
@@ -172,7 +182,7 @@ You may invoke this command in "wizard" mode and be prompted for input.`,
 
 			sort.Sort(tagcmp.ByTagDesc(compatible))
 
-			if len(compatible) == 0 && !allTags {
+			if len(compatible) == 0 && !internal.AllTags {
 				log.Info(fmt.Sprintf("no new versions available for %s, assuming %s is the latest (use -a/--all-tags to see all anyway)", image, tag))
 				continue // skip on to the next tag and don't update any compose files
 			}
@@ -226,7 +236,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
+							return err
 						}
 						delta := upElement.UpgradeType()
 						if delta <= bumpType {
@@ -240,9 +250,9 @@ You may invoke this command in "wizard" mode and be prompted for input.`,
 					}
 				} else {
 					msg := fmt.Sprintf("upgrade to which tag? (service: %s, image: %s, tag: %s)", service.Name, image, tag)
-					if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) || allTags {
+					if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) || internal.AllTags {
 						tag := img.(reference.NamedTagged).Tag()
-						if !allTags {
+						if !internal.AllTags {
 							log.Warn(fmt.Sprintf("unable to determine versioning semantics of %s, listing all tags", tag))
 						}
 						msg = fmt.Sprintf("upgrade to which tag? (service: %s, tag: %s)", service.Name, tag)
@@ -310,7 +320,7 @@ You may invoke this command in "wizard" mode and be prompted for input.`,
 
 				fmt.Println(string(jsonstring))
 
-				return
+				return nil
 			}
 
 			for _, upgrade := range upgradeList {
@@ -331,51 +341,7 @@ You may invoke this command in "wizard" mode and be prompted for input.`,
 				log.Fatal(err)
 			}
 		}
+
+		return nil
 	},
 }
-
-var (
-	allTags bool
-)
-
-func init() {
-	RecipeUpgradeCommand.Flags().BoolVarP(
-		&internal.Major,
-		"major",
-		"x",
-		false,
-		"increase the major part of the version",
-	)
-
-	RecipeUpgradeCommand.Flags().BoolVarP(
-		&internal.Minor,
-		"minor",
-		"y",
-		false,
-		"increase the minor part of the version",
-	)
-
-	RecipeUpgradeCommand.Flags().BoolVarP(
-		&internal.Patch,
-		"patch",
-		"z",
-		false,
-		"increase the patch part of the version",
-	)
-
-	RecipeUpgradeCommand.Flags().BoolVarP(
-		&internal.MachineReadable,
-		"machine",
-		"m",
-		false,
-		"print machine-readable output",
-	)
-
-	RecipeUpgradeCommand.Flags().BoolVarP(
-		&allTags,
-		"all-tags",
-		"a",
-		false,
-		"list all tags, not just upgrades",
-	)
-}

cli/recipe/version.go

@@ -9,24 +9,35 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"github.com/spf13/cobra"
+	"github.com/olekukonko/tablewriter"
+	"github.com/urfave/cli"
 )
 
-var RecipeVersionCommand = &cobra.Command{
-	Use:     "versions <recipe> [flags]",
-	Aliases: []string{"v"},
-	Short:   "List recipe versions",
-	Args:    cobra.ExactArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.RecipeNameComplete()
-	},
-	Run: func(cmd *cobra.Command, args []string) {
-		var warnMessages []string
+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]
+	}
+}
 
-		recipe := internal.ValidateRecipe(args, cmd.Name())
+var recipeVersionCommand = cli.Command{
+	Name:      "versions",
+	Aliases:   []string{"v"},
+	Usage:     "List recipe versions",
+	ArgsUsage: "<recipe>",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.OfflineFlag,
+		internal.NoInputFlag,
+		internal.MachineReadableFlag,
+	},
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.RecipeNameComplete,
+	Action: func(c *cli.Context) error {
+		recipe := internal.ValidateRecipe(c)
 
 		catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
@@ -35,101 +46,49 @@ var RecipeVersionCommand = &cobra.Command{
 
 		recipeMeta, ok := catl[recipe.Name]
 		if !ok {
-			warnMessages = append(warnMessages, "retrieved versions from local recipe repository")
+			log.Warn("no published versions in catalogue, trying local recipe repository")
 
-			recipeVersions, warnMsg, err := recipe.GetRecipeVersions()
+			recipeVersions, err := recipe.GetRecipeVersions()
 			if err != nil {
-				warnMessages = append(warnMessages, err.Error())
-			}
-			if len(warnMsg) > 0 {
-				warnMessages = append(warnMessages, warnMsg...)
+				log.Warn(err)
 			}
 
 			recipeMeta = recipePkg.RecipeMeta{Versions: recipeVersions}
 		}
 
 		if len(recipeMeta.Versions) == 0 {
-			log.Fatalf("%s has no published versions?", recipe.Name)
+			log.Fatalf("%s has no catalogue 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, err := formatter.CreateTable()
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			table.Headers("SERVICE", "IMAGE", "TAG", "VERSION")
-
+			table := formatter.CreateTable(tableCols)
 			for version, meta := range recipeMeta.Versions[i] {
-				var allRows [][]string
-				var rows [][]string
-
+				var versions [][]string
 				for service, serviceMeta := range meta {
-					recipeVersion := version
-					if service != "app" {
-						recipeVersion = ""
+					versions = append(versions, []string{version, service, serviceMeta.Image, serviceMeta.Tag})
 				}
 
-					rows = append(rows, []string{
-						service,
-						serviceMeta.Image,
-						serviceMeta.Tag,
-						recipeVersion,
-					})
+				sort.Slice(versions, sortServiceByName(versions))
 
-					allRows = append(allRows, []string{
-						version,
-						service,
-						serviceMeta.Image,
-						serviceMeta.Tag,
-						recipeVersion,
-					})
+				for _, version := range versions {
+					table.Append(version)
+					aggregated_table.Append(version)
 				}
 
-				sort.Slice(rows, sortServiceByName(rows))
-
-				table.Rows(rows...)
-
 				if !internal.MachineReadable {
-					if err := formatter.PrintTable(table); err != nil {
-						log.Fatal(err)
+					table.SetAutoMergeCellsByColumnIndex([]int{0})
+					table.SetAlignment(tablewriter.ALIGN_LEFT)
+					table.Render()
+					fmt.Println()
+				}
 			}
-					continue
 		}
-
 		if internal.MachineReadable {
-					sort.Slice(allRows, sortServiceByName(allRows))
-					headers := []string{"VERSION", "SERVICE", "NAME", "TAG"}
-					out, err := formatter.ToJSON(headers, allRows)
-					if err != nil {
-						log.Fatal("unable to render to JSON: %s", err)
-					}
-					fmt.Println(out)
-					continue
-				}
-			}
+			aggregated_table.JSONRender()
 		}
 
-		if !internal.MachineReadable {
-			for _, warnMsg := range warnMessages {
-				log.Warn(warnMsg)
-			}
-		}
+		return nil
 	},
 }
-
-func sortServiceByName(versions [][]string) func(i, j int) bool {
-	return func(i, j int) bool {
-		return versions[i][0] < versions[j][0]
-	}
-}
-
-func init() {
-	RecipeVersionCommand.Flags().BoolVarP(
-		&internal.MachineReadable,
-		"machine",
-		"m",
-		false,
-		"print machine-readable output",
-	)
-}

cli/run.go

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

cli/server/add.go

@@ -1,11 +1,11 @@
 package server
 
 import (
+	"errors"
 	"os"
 	"path/filepath"
 
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	contextPkg "coopcloud.tech/abra/pkg/context"
@@ -13,112 +13,14 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/server"
 	sshPkg "coopcloud.tech/abra/pkg/ssh"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var ServerAddCommand = &cobra.Command{
-	Use:     "add [[server] | --local] [flags]",
-	Aliases: []string{"a"},
-	Short:   "Add a new server",
-	Long: `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: "  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("cannot use [server] and --local together")
-		}
-
-		if len(args) == 0 && !local {
-			log.Fatal("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.Debugf("attempting to create client for %s", name)
-
-			if _, err := client.New(name, timeout); err != nil {
-				cleanUp(name)
-				log.Fatal(err)
-			}
-
-			if created {
-				log.Info("local server successfully added")
-			} else {
-				log.Warn("local server already exists")
-			}
-
-			return
-		}
-
-		_, err := createServerDir(name)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		created, err := newContext(name)
-		if err != nil {
-			cleanUp(name)
-			log.Fatalf("unable to create local context: %s", err)
-		}
-
-		log.Debugf("attempting to create client for %s", name)
-
-		if _, err := client.New(name, timeout); err != nil {
-			cleanUp(name)
-			log.Debugf("ssh %s error: %s", name, sshPkg.Fatal(name, err))
-			log.Fatalf("can't ssh to %s, make sure \"ssh %s\" works", name, name)
-		}
-
-		if created {
-			log.Infof("%s successfully added", name)
-
-			if _, err := dns.EnsureIPv4(name); err != nil {
-				log.Warnf("unable to resolve IPv4 for %s", name)
-			}
-
-			return
-		}
-
-		log.Warnf("%s already exists", name)
-	},
+var local bool
+var localFlag = &cli.BoolFlag{
+	Name:        "local, l",
+	Usage:       "Use local server",
+	Destination: &local,
 }
 
 // cleanUp cleans up the partially created context/client details for a failed
@@ -189,16 +91,114 @@ func createServerDir(name string) (bool, error) {
 	return true, nil
 }
 
-var (
-	local bool
-)
+var serverAddCommand = cli.Command{
+	Name:    "add",
+	Aliases: []string{"a"},
+	Usage:   "Add a new server to your configuration",
+	Description: `
+Add a new server to your configuration so that it can be managed by Abra.
 
-func init() {
-	ServerAddCommand.Flags().BoolVarP(
-		&local,
-		"local",
-		"l",
-		false,
-		"use local server",
-	)
+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. For example:
+
+  Host example.com example
+    Hostname example.com
+    User exampleUser
+    Port 12345
+    IdentityFile ~/.ssh/example@somewhere
+
+You can then add a server like so:
+
+  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. The domain is then set to "default".
+
+You can also pass "--no-domain-checks/-D" flag to use any arbitrary name
+instead of a real domain. The host will be resolved with the "Hostname" entry
+of your ~/.ssh/config. Checks for a valid online domain will be skipped:
+
+  abra server add -D example`,
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.NoInputFlag,
+		internal.NoDomainChecksFlag,
+		localFlag,
+	},
+	Before:    internal.SubCommandBefore,
+	ArgsUsage: "<name>",
+	Action: func(c *cli.Context) error {
+		if len(c.Args()) > 0 && local || !internal.ValidateSubCmdFlags(c) {
+			err := errors.New("cannot use <name> and --local together")
+			internal.ShowSubcommandHelpAndError(c, err)
+		}
+
+		var name string
+		if local {
+			name = "default"
+		} else {
+			name = internal.ValidateDomain(c)
+		}
+
+		// NOTE(d1): reasonable 5 second timeout for connections which can't
+		// succeed. The connection is attempted twice, so this results in 10
+		// seconds.
+		timeout := client.WithTimeout(5)
+
+		if local {
+			created, err := createServerDir(name)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			log.Debugf("attempting to create client for %s", name)
+
+			if _, err := client.New(name, timeout); err != nil {
+				cleanUp(name)
+				log.Fatal(err)
+			}
+
+			if created {
+				log.Info("local server successfully added")
+			} else {
+				log.Warn("local server already exists")
+			}
+
+			return nil
+		}
+
+		if !internal.NoDomainChecks {
+			if _, err := dns.EnsureIPv4(name); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		_, err := createServerDir(name)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		created, err := newContext(name)
+		if err != nil {
+			cleanUp(name)
+			log.Fatal(err)
+		}
+
+		log.Debugf("attempting to create client for %s", name)
+		if _, err := client.New(name, timeout); err != nil {
+			cleanUp(name)
+			log.Fatal(sshPkg.Fatal(name, err))
+		}
+
+		if created {
+			log.Infof("%s successfully added", name)
+		} else {
+			log.Warnf("%s already exists", name)
+		}
+
+		return nil
+	},
 }

cli/server/list.go

@@ -1,54 +1,52 @@
 package server
 
 import (
-	"fmt"
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/config"
-	contextPkg "coopcloud.tech/abra/pkg/context"
+	"coopcloud.tech/abra/pkg/context"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/cli/cli/connhelper/ssh"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var ServerListCommand = &cobra.Command{
-	Use:     "list [flags]",
+var serverListCommand = cli.Command{
+	Name:    "list",
 	Aliases: []string{"ls"},
-	Short:   "List managed servers",
-	Args:    cobra.NoArgs,
-	Run: func(cmd *cobra.Command, args []string) {
-		dockerContextStore := contextPkg.NewDefaultDockerContextStore()
+	Usage:   "List managed servers",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.MachineReadableFlag,
+		internal.OfflineFlag,
+	},
+	Before: internal.SubCommandBefore,
+	Action: func(c *cli.Context) error {
+		dockerContextStore := context.NewDefaultDockerContextStore()
 		contexts, err := dockerContextStore.Store.List()
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		table, err := formatter.CreateTable()
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		headers := []string{"NAME", "HOST"}
-		table.Headers(headers...)
+		tableColumns := []string{"name", "host"}
+		table := formatter.CreateTable(tableColumns)
 
 		serverNames, err := config.ReadServerNames()
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		var rows [][]string
 		for _, serverName := range serverNames {
 			var row []string
-			for _, dockerCtx := range contexts {
-				endpoint, err := contextPkg.GetContextEndpoint(dockerCtx)
+			for _, ctx := range contexts {
+				endpoint, err := context.GetContextEndpoint(ctx)
 				if err != nil && strings.Contains(err.Error(), "does not exist") {
 					// No local context found, we can continue safely
 					continue
 				}
 
-				if dockerCtx.Name == serverName {
+				if ctx.Name == serverName {
 					sp, err := ssh.ParseURL(endpoint)
 					if err != nil {
 						log.Fatal(err)
@@ -59,7 +57,6 @@ var ServerListCommand = &cobra.Command{
 					}
 
 					row = []string{serverName, sp.Host}
-					rows = append(rows, row)
 				}
 			}
 
@@ -69,35 +66,18 @@ var ServerListCommand = &cobra.Command{
 				} else {
 					row = []string{serverName, "unknown"}
 				}
-				rows = append(rows, row)
 			}
 
-			table.Row(row...)
+			table.Append(row)
 		}
 
 		if internal.MachineReadable {
-			out, err := formatter.ToJSON(headers, rows)
-			if err != nil {
-				log.Fatal("unable to render to JSON: %s", err)
+			table.JSONRender()
+			return nil
 		}
 
-			fmt.Println(out)
+		table.Render()
 
-			return
-		}
-
-		if err := formatter.PrintTable(table); err != nil {
-			log.Fatal(err)
-		}
+		return nil
 	},
 }
-
-func init() {
-	ServerListCommand.Flags().BoolVarP(
-		&internal.MachineReadable,
-		"machine",
-		"m",
-		false,
-		"print machine-readable output",
-	)
-}

cli/server/prune.go

@@ -1,41 +1,64 @@
 package server
 
 import (
+	"context"
+
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var ServerPruneCommand = &cobra.Command{
-	Use:     "prune <server> [flags]",
-	Aliases: []string{"p"},
-	Short:   "Prune resources on a server",
-	Long: `Prunes unused containers, networks, and dangling images.
+var allFilter bool
 
-Use "--volumes/-v" to remove volumes that are not associated with a deployed
+var allFilterFlag = &cli.BoolFlag{
+	Name:        "all, a",
+	Usage:       "Remove all unused images not just dangling ones",
+	Destination: &allFilter,
+}
+
+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 resources on a server",
+	Description: `
+Prunes unused containers, networks, and dangling images.
+
+Use "-v/--volumes" to remove volumes that are not associated with a deployed
 app. This can result in unwanted data loss if not used carefully.`,
-	Args: cobra.ExactArgs(1),
-	ValidArgsFunction: func(
-		cmd *cobra.Command,
-		args []string,
-		toComplete string) ([]string, cobra.ShellCompDirective) {
-		return autocomplete.ServerNameComplete()
+	ArgsUsage: "[<server>]",
+	Flags: []cli.Flag{
+		allFilterFlag,
+		volumesFilterFlag,
+		internal.DebugFlag,
+		internal.OfflineFlag,
+		internal.NoInputFlag,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		serverName := internal.ValidateServer(args)
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.ServerNameComplete,
+	Action: func(c *cli.Context) error {
+		serverName := internal.ValidateServer(c)
 
 		cl, err := client.New(serverName)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		var filterArgs filters.Args
+		var args filters.Args
 
-		cr, err := cl.ContainersPrune(cmd.Context(), filterArgs)
+		ctx := context.Background()
+		cr, err := cl.ContainersPrune(ctx, args)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -43,7 +66,7 @@ app. This can result in unwanted data loss if not used carefully.`,
 		cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
 		log.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
 
-		nr, err := cl.NetworksPrune(cmd.Context(), filterArgs)
+		nr, err := cl.NetworksPrune(ctx, args)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -56,7 +79,7 @@ app. This can result in unwanted data loss if not used carefully.`,
 			pruneFilters.Add("dangling", "false")
 		}
 
-		ir, err := cl.ImagesPrune(cmd.Context(), pruneFilters)
+		ir, err := cl.ImagesPrune(ctx, pruneFilters)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -65,7 +88,7 @@ app. This can result in unwanted data loss if not used carefully.`,
 		log.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
 
 		if volumesFilter {
-			vr, err := cl.VolumesPrune(cmd.Context(), filterArgs)
+			vr, err := cl.VolumesPrune(ctx, args)
 			if err != nil {
 				log.Fatal(err)
 			}
@@ -74,29 +97,6 @@ app. This can result in unwanted data loss if not used carefully.`,
 			log.Infof("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed)
 		}
 
-		return
+		return nil
 	},
 }
-
-var (
-	allFilter     bool
-	volumesFilter bool
-)
-
-func init() {
-	ServerPruneCommand.Flags().BoolVarP(
-		&allFilter,
-		"all",
-		"a",
-		false,
-		"remove all unused images",
-	)
-
-	ServerPruneCommand.Flags().BoolVarP(
-		&volumesFilter,
-		"volumes",
-		"v",
-		false,
-		"remove volumes",
-	)
-}

cli/server/remove.go

@@ -9,27 +9,29 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
-var ServerRemoveCommand = &cobra.Command{
-	Use:     "remove <server> [flags]",
+var serverRemoveCommand = cli.Command{
+	Name:      "remove",
 	Aliases:   []string{"rm"},
-	Short:   "Remove a managed server",
-	Long: `Remove a managed server.
+	ArgsUsage: "<server>",
+	Usage:     "Remove a managed server",
+	Description: `
+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()
+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,
 	},
-	Run: func(cmd *cobra.Command, args []string) {
-		serverName := internal.ValidateServer(args)
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.ServerNameComplete,
+	Action: func(c *cli.Context) error {
+		serverName := internal.ValidateServer(c)
 
 		if err := client.DeleteContext(serverName); err != nil {
 			log.Fatal(err)
@@ -41,6 +43,6 @@ like tears in rain.`,
 
 		log.Infof("%s is now lost in time, like tears in rain", serverName)
 
-		return
+		return nil
 	},
 }

cli/server/server.go

@@ -1,10 +1,18 @@
 package server
 
-import "github.com/spf13/cobra"
+import (
+	"github.com/urfave/cli"
+)
 
 // ServerCommand defines the `abra server` command and its subcommands
-var ServerCommand = &cobra.Command{
-	Use:     "server [cmd] [args] [flags]",
+var ServerCommand = cli.Command{
+	Name:    "server",
 	Aliases: []string{"s"},
-	Short:   "Manage servers",
+	Usage:   "Manage servers",
+	Subcommands: []cli.Command{
+		serverAddCommand,
+		serverListCommand,
+		serverRemoveCommand,
+		serverPruneCommand,
+	},
 }

cli/updater/updater.go

@@ -21,25 +21,46 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	dockerclient "github.com/docker/docker/client"
-	"github.com/spf13/cobra"
 
 	"coopcloud.tech/abra/pkg/log"
+	"github.com/urfave/cli"
 )
 
 const SERVER = "localhost"
 
-// NotifyCommand checks for available upgrades.
-var NotifyCommand = &cobra.Command{
-	Use:     "notify [flags]",
+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"},
-	Short:   "Check for available upgrades",
-	Long: `Notify on new versions for deployed apps.
+	Usage:   "Check for available upgrades",
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		majorFlag,
+		internal.OfflineFlag,
+	},
+	Before: internal.SubCommandBefore,
+	Description: `
+Read the deployed app versions and look for new versions in the recipe
+catalogue.
 
 If a new patch/minor version is available, a notification is printed.
 
-Use "--major/-m" to include new major versions.`,
-	Args: cobra.NoArgs,
-	Run: func(cmd *cobra.Command, args []string) {
+Use "--major" to include new major versions.`,
+	Action: func(c *cli.Context) error {
 		cl, err := client.New("default")
 		if err != nil {
 			log.Fatal(err)
@@ -64,15 +85,27 @@ Use "--major/-m" to include new major versions.`,
 				}
 			}
 		}
+
+		return nil
 	},
 }
 
-// UpgradeCommand upgrades apps.
-var UpgradeCommand = &cobra.Command{
-	Use:     "upgrade [[stack] [recipe] | --all] [flags]",
+// UpgradeApp upgrades apps.
+var UpgradeApp = cli.Command{
+	Name:      "upgrade",
 	Aliases:   []string{"u"},
-	Short:   "Upgrade apps",
-	Long: `Upgrade an app by specifying stack name and recipe. 
+	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 stack name and recipe. 
 
 Use "--all" to upgrade every deployed app.
 
@@ -80,37 +113,24 @@ For each app with auto updates enabled, the deployed version is compared with
 the current recipe catalogue version. If a new patch/minor version is
 available, the app is upgraded.
 
-To include major versions use the "--major/-m" flag. You probably don't want
-that as it will break things. Only apps that are not deployed with "--chaos/-C"
-are upgraded, to update chaos deployments use the "--chaos/-C" flag. Use it
-with care.`,
-	Args: cobra.RangeArgs(0, 2),
-	// TODO(d1): complete stack/recipe
-	// ValidArgsFunction: func(
-	// 	cmd *cobra.Command,
-	// 	args []string,
-	// 	toComplete string) ([]string, cobra.ShellCompDirective) {
-	// },
-	Run: func(cmd *cobra.Command, args []string) {
+To include major versions use the "--major" flag. You probably don't want that
+as it will break things. Only apps that are not deployed with "--chaos" are
+upgraded, to update chaos deployments use the "--chaos" flag. Use it with care.`,
+	Action: func(c *cli.Context) error {
 		cl, err := client.New("default")
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		if !updateAll && len(args) != 2 {
-			log.Fatal("missing arguments or --all/-a flag")
-		}
-
 		if !updateAll {
-			stackName := args[0]
-			recipeName := args[1]
-
+			stackName := c.Args().Get(0)
+			recipeName := c.Args().Get(1)
 			err = tryUpgrade(cl, stackName, recipeName)
 			if err != nil {
 				log.Fatal(err)
 			}
 
-			return
+			return nil
 		}
 
 		stacks, err := stack.GetStacks(cl)
@@ -130,6 +150,8 @@ with care.`,
 				log.Fatal(err)
 			}
 		}
+
+		return nil
 	},
 }
 
@@ -289,7 +311,7 @@ func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName
 			return nil, err
 		}
 
-		if 0 < versionDelta.UpgradeType() && (versionDelta.UpgradeType() < 4 || includeMajorUpdates) {
+		if 0 < versionDelta.UpgradeType() && (versionDelta.UpgradeType() < 4 || majorUpdate) {
 			availableUpgrades = append(availableUpgrades, version)
 		}
 	}
@@ -446,87 +468,38 @@ func upgrade(cl *dockerclient.Client, stackName, recipeName, upgradeVersion stri
 	return err
 }
 
-func newKadabraApp(version, commit string) *cobra.Command {
-	rootCmd := &cobra.Command{
-		Use:     "kadabra [cmd] [flags]",
+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]),
-		Short:   "The Co-op Cloud auto-updater 🤖 🚀",
-		PersistentPreRun: func(cmd *cobra.Command, args []string) {
-			log.Logger.SetStyles(charmLog.DefaultStyles())
-			charmLog.SetDefault(log.Logger)
-
-			if internal.Debug {
-				log.SetLevel(log.DebugLevel)
-				log.SetOutput(os.Stderr)
-				log.SetReportCaller(true)
-			}
-
-			log.Debugf("kadabra version %s, commit %s", version, commit)
+		Commands: []cli.Command{
+			Notify,
+			UpgradeApp,
 		},
 	}
 
-	rootCmd.PersistentFlags().BoolVarP(
-		&internal.Debug, "debug", "d", false,
-		"show debug messages",
-	)
+	app.Before = func(c *cli.Context) error {
+		charmLog.SetDefault(log.Logger)
+		log.Debugf("kadabra version %s, commit %s", version, commit)
+		return nil
+	}
 
-	rootCmd.PersistentFlags().BoolVarP(
-		&internal.NoInput, "no-input", "n", false,
-		"toggle non-interactive mode",
-	)
-
-	rootCmd.AddCommand(
-		NotifyCommand,
-		UpgradeCommand,
-	)
-
-	return rootCmd
+	return app
 }
 
 // RunApp runs CLI abra app.
 func RunApp(version, commit string) {
-	app := newKadabraApp(version, commit)
+	app := newAbraApp(version, commit)
 
-	if err := app.Execute(); err != nil {
+	if err := app.Run(os.Args); err != nil {
 		log.Fatal(err)
 	}
 }
-
-var (
-	includeMajorUpdates bool
-	updateAll           bool
-)
-
-func init() {
-	NotifyCommand.Flags().BoolVarP(
-		&includeMajorUpdates,
-		"major",
-		"m",
-		false,
-		"check for major updates",
-	)
-
-	UpgradeCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		"chaos",
-		"C",
-		false,
-		"ignore uncommitted recipes changes",
-	)
-
-	UpgradeCommand.Flags().BoolVarP(
-		&includeMajorUpdates,
-		"major",
-		"m",
-		false,
-		"check for major updates",
-	)
-
-	UpgradeCommand.Flags().BoolVarP(
-		&updateAll,
-		"all",
-		"a",
-		false,
-		"update all deployed apps",
-	)
-}

cli/upgrade.go

@@ -1,56 +0,0 @@
-// Package cli provides the interface for the command-line.
-package cli
-
-import (
-	"fmt"
-	"os/exec"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/log"
-	"github.com/spf13/cobra"
-)
-
-// UpgradeCommand upgrades abra in-place.
-var UpgradeCommand = &cobra.Command{
-	Use:     "upgrade [flags]",
-	Aliases: []string{"u"},
-	Short:   "Upgrade abra",
-	Long: `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: "  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("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,
-		"install release candidate (may contain bugs)",
-	)
-}

cmd/abra/main.go

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

go.mod

@@ -1,46 +1,43 @@
 module coopcloud.tech/abra
 
-go 1.22.7
-
-toolchain go1.23.1
+go 1.21
 
 require (
 	coopcloud.tech/tagcmp v0.0.0-20230809071031-eb3e7758d4eb
-	git.coopcloud.tech/toolshed/godotenv v1.5.2-0.20250103171850-4d0ca41daa5c
+	git.coopcloud.tech/coop-cloud/godotenv v1.5.2-0.20231130100509-01bff8284355
 	github.com/AlecAivazis/survey/v2 v2.3.7
-	github.com/charmbracelet/lipgloss v1.0.0
 	github.com/charmbracelet/log v0.4.0
 	github.com/distribution/reference v0.6.0
-	github.com/docker/cli v27.4.1+incompatible
-	github.com/docker/docker v27.4.1+incompatible
+	github.com/docker/cli v27.0.3+incompatible
+	github.com/docker/docker v27.0.3+incompatible
 	github.com/docker/go-units v0.5.0
-	github.com/go-git/go-git/v5 v5.13.1
+	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.1
-	github.com/moby/term v0.5.2
+	github.com/moby/sys/signal v0.7.0
+	github.com/moby/term v0.5.0
+	github.com/olekukonko/tablewriter v0.0.5
 	github.com/pkg/errors v0.9.1
-	github.com/schollz/progressbar/v3 v3.17.1
-	golang.org/x/term v0.28.0
+	github.com/schollz/progressbar/v3 v3.14.4
 	gopkg.in/yaml.v3 v3.0.1
 	gotest.tools/v3 v3.5.1
 )
 
 require (
-	dario.cat/mergo v1.0.1 // indirect
-	github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 // indirect
-	github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect
+	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
 	github.com/Microsoft/go-winio v0.6.2 // indirect
-	github.com/ProtonMail/go-crypto v1.1.3 // indirect
+	github.com/ProtonMail/go-crypto v1.0.0 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/charmbracelet/x/ansi v0.6.0 // indirect
-	github.com/cloudflare/circl v1.5.0 // indirect
+	github.com/charmbracelet/lipgloss v0.11.0 // indirect
+	github.com/charmbracelet/x/ansi v0.1.2 // indirect
+	github.com/cloudflare/circl v1.3.9 // indirect
 	github.com/containerd/log v0.1.0 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect
-	github.com/cyphar/filepath-securejoin v0.3.6 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
+	github.com/cyphar/filepath-securejoin v0.2.5 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/docker/distribution v2.8.3+incompatible // indirect
 	github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c // indirect
@@ -49,86 +46,78 @@ require (
 	github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
-	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/ghodss/yaml v1.0.0 // indirect
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
-	github.com/go-git/go-billy/v5 v5.6.1 // indirect
+	github.com/go-git/go-billy/v5 v5.5.0 // indirect
 	github.com/go-logfmt/logfmt v0.6.0 // indirect
 	github.com/go-logr/logr v1.4.2 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
+	github.com/go-viper/mapstructure/v2 v2.0.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
+	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.25.1 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // 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.11 // indirect
+	github.com/klauspost/compress v1.17.9 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // 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/mmcloughlin/avo v0.6.0 // indirect
 	github.com/moby/docker-image-spec v1.3.1 // indirect
-	github.com/moby/sys/mountinfo v0.6.2 // indirect
-	github.com/moby/sys/user v0.3.0 // indirect
-	github.com/moby/sys/userns v0.1.0 // indirect
+	github.com/moby/sys/user v0.1.0 // indirect
 	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/muesli/termenv v0.15.2 // 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/opencontainers/runtime-spec v1.1.0 // indirect
-	github.com/pelletier/go-toml v1.9.5 // indirect
-	github.com/pjbgf/sha1cd v0.3.1 // indirect
+	github.com/pjbgf/sha1cd v0.3.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.61.0 // indirect
+	github.com/prometheus/common v0.55.0 // indirect
 	github.com/prometheus/procfs v0.15.1 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
-	github.com/skeema/knownhosts v1.3.0 // indirect
+	github.com/skeema/knownhosts v1.2.2 // indirect
 	github.com/spf13/pflag v1.0.5 // 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/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 // indirect
-	go.opentelemetry.io/otel v1.33.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.33.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.33.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.33.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0 // indirect
-	go.opentelemetry.io/otel/metric v1.33.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.33.0 // indirect
-	go.opentelemetry.io/otel/sdk/metric v1.33.0 // indirect
-	go.opentelemetry.io/otel/trace v1.33.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.5.0 // indirect
-	golang.org/x/crypto v0.32.0 // indirect
-	golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 // indirect
-	golang.org/x/mod v0.22.0 // indirect
-	golang.org/x/net v0.34.0 // indirect
-	golang.org/x/sync v0.10.0 // indirect
-	golang.org/x/text v0.21.0 // indirect
-	golang.org/x/time v0.9.0 // indirect
-	golang.org/x/tools v0.29.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250106144421-5f5ef82da422 // indirect
-	google.golang.org/grpc v1.69.2 // indirect
-	google.golang.org/protobuf v1.36.2 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 // indirect
+	go.opentelemetry.io/otel v1.28.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 // indirect
+	go.opentelemetry.io/otel/metric v1.28.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.28.0 // indirect
+	go.opentelemetry.io/otel/sdk/metric v1.28.0 // indirect
+	go.opentelemetry.io/otel/trace v1.28.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
+	golang.org/x/crypto v0.25.0 // indirect
+	golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 // indirect
+	golang.org/x/net v0.27.0 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/term v0.22.0 // indirect
+	golang.org/x/text v0.16.0 // indirect
+	golang.org/x/time v0.5.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect
+	google.golang.org/grpc v1.65.0 // indirect
+	google.golang.org/protobuf v1.34.2 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 
 require (
+	github.com/containerd/containerd v1.7.19 // indirect
 	github.com/containers/image v3.0.2+incompatible
 	github.com/containers/storage v1.38.2 // indirect
 	github.com/decentral1se/passgen v1.0.1
@@ -138,13 +127,14 @@ require (
 	github.com/gorilla/mux v1.8.1 // indirect
 	github.com/hashicorp/go-retryablehttp v0.7.7
 	github.com/moby/patternmatcher v0.6.0 // indirect
-	github.com/moby/sys/sequential 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.20.5 // 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
-	github.com/stretchr/testify v1.10.0
+	github.com/spf13/cobra v1.8.1 // indirect
+	github.com/stretchr/testify v1.9.0
 	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.29.0
+	golang.org/x/sys v0.22.0
 )

go.sum

@@ -24,19 +24,19 @@ cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0Zeo
 cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
 coopcloud.tech/tagcmp v0.0.0-20230809071031-eb3e7758d4eb h1:Ws6WEwKXeaYEkfdkX6AqX1XLPuaCeyStEtxbmEJPllk=
 coopcloud.tech/tagcmp v0.0.0-20230809071031-eb3e7758d4eb/go.mod h1:ESVm0wQKcbcFi06jItF3rI7enf4Jt2PvbkWpDDHk1DQ=
-dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s=
-dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
+dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
+dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-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=
+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=
 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-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg=
-github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+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-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,6 +49,7 @@ 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/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
@@ -79,8 +80,8 @@ github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb0
 github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63nhn5WAunQHLTznkw5W8b1Xc0dNjp83s=
 github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/ProtonMail/go-crypto v1.1.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk=
-github.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
+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/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
 github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
 github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
@@ -103,8 +104,6 @@ github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:l
 github.com/aws/aws-sdk-go v1.15.11/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
-github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
-github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
 github.com/beorn7/perks v0.0.0-20150223135152-b965b613227f/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v0.0.0-20160804104726-4c0e84591b9a/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
@@ -127,28 +126,24 @@ github.com/bugsnag/osext v0.0.0-20130617224835-0dd3f918b21b h1:otBG+dV+YK+Soembj
 github.com/bugsnag/osext v0.0.0-20130617224835-0dd3f918b21b/go.mod h1:obH5gd0BsqsP2LwDJ9aOkm/6J86V6lyAXCoQWGw3K50=
 github.com/bugsnag/panicwrap v0.0.0-20151223152923-e2c28503fcd0 h1:nvj0OLI3YqYXer/kZD8Ri1aaunCxIEsOst1BVJswV0o=
 github.com/bugsnag/panicwrap v0.0.0-20151223152923-e2c28503fcd0/go.mod h1:D/8v3kj0zr8ZAKg1AQ6crr+5VwKN5eIywRkfhyM/+dE=
+github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
 github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw=
 github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
 github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/charmbracelet/lipgloss v1.0.0 h1:O7VkGDvqEdGi93X+DeqsQ7PKHDgtQfF8j8/O2qFMQNg=
-github.com/charmbracelet/lipgloss v1.0.0/go.mod h1:U5fy9Z+C38obMs+T+tJqst9VGzlOYGj4ri9reL3qUlo=
+github.com/charmbracelet/lipgloss v0.11.0 h1:UoAcbQ6Qml8hDwSWs0Y1cB5TEQuZkDPH/ZqwWWYTG4g=
+github.com/charmbracelet/lipgloss v0.11.0/go.mod h1:1UdRTH9gYgpcdNN5oBtjbu/IzNKtzVtb7sqN1t9LNn8=
 github.com/charmbracelet/log v0.4.0 h1:G9bQAcx8rWA2T3pWvx7YtPTPwgqpk7D68BX21IRW8ZM=
 github.com/charmbracelet/log v0.4.0/go.mod h1:63bXt/djrizTec0l11H20t8FDSvA4CRZJ1KH22MdptM=
-github.com/charmbracelet/x/ansi v0.6.0 h1:qOznutrb93gx9oMiGf7caF7bqqubh6YIM0SWKyA08pA=
-github.com/charmbracelet/x/ansi v0.6.0/go.mod h1:KBUFw1la39nl0dLl10l5ORDAqGXaeurTQmwyyVKse/Q=
-github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a h1:G99klV19u0QnhiizODirwVksQB91TJKV/UaTnACcG30=
-github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
+github.com/charmbracelet/x/ansi v0.1.2 h1:6+LR39uG8DE6zAmbu023YlqjJHkYXDF1z36ZwzO4xZY=
+github.com/charmbracelet/x/ansi v0.1.2/go.mod h1:dk73KoMTT5AX5BsX0KrqhsTqAnhZZoCBjs7dGWp4Ktw=
 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=
@@ -161,8 +156,9 @@ github.com/cilium/ebpf v0.7.0/go.mod h1:/oI2+1shJiTGAMgl6/RgJr36Eo1jzrRcAWbcXO2u
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cloudflare/cfssl v0.0.0-20180223231731-4e2dcbde5004 h1:lkAMpLVBDaj17e85keuznYcH5rqI438v41pKcBl4ZxQ=
 github.com/cloudflare/cfssl v0.0.0-20180223231731-4e2dcbde5004/go.mod h1:yMWuSON2oQp+43nFtAV/uvKQIFpSPerB57DCt9t8sSA=
-github.com/cloudflare/circl v1.5.0 h1:hxIWksrX6XN5a1L2TI/h53AGPhNHoUBo+TD1ms9+pys=
-github.com/cloudflare/circl v1.5.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
+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/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=
@@ -201,6 +197,8 @@ github.com/containerd/containerd v1.5.0-beta.4/go.mod h1:GmdgZd2zA2GYIBZ0w09Zvgq
 github.com/containerd/containerd v1.5.0-rc.0/go.mod h1:V/IXoMqNGgBlabz3tHD2TWDoTJseu1FGOKuoA4nNb2s=
 github.com/containerd/containerd v1.5.1/go.mod h1:0DOxVqwDy2iZvrZp2JUx/E+hS0UNTVn7dJnIOwtYR4g=
 github.com/containerd/containerd v1.5.7/go.mod h1:gyvv6+ugqY25TiXxcZC3L5yOeYgEw0QMhscqVp1AR9c=
+github.com/containerd/containerd v1.7.19 h1:/xQ4XRJ0tamDkdzrrBAUy/LE5nCcxFKdBm4EcPrSMEE=
+github.com/containerd/containerd v1.7.19/go.mod h1:h4FtNYUUMB4Phr6v+xG89RYKj9XccvbNSCKjdufCrkc=
 github.com/containerd/continuity v0.0.0-20190426062206-aaeac12a7ffc/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
 github.com/containerd/continuity v0.0.0-20190815185530-f2a389ac0a02/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
 github.com/containerd/continuity v0.0.0-20191127005431-f65d91d395eb/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
@@ -276,9 +274,8 @@ 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 h1:XJtiaUW6dEEqVuZiMTn1ldk455QWwEIsMIJlo5vtkx0=
-github.com/cpuguy83/go-md2man/v2 v2.0.6/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=
@@ -286,8 +283,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.3.6 h1:4d9N5ykBnSp5Xn2JkhocYDkOpURL/18CYMpo6xB9uWM=
-github.com/cyphar/filepath-securejoin v0.3.6/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
+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/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=
@@ -306,16 +303,16 @@ github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5Qvfr
 github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
 github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
 github.com/docker/cli v0.0.0-20191017083524-a8ff7f821017/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
-github.com/docker/cli v27.4.1+incompatible h1:VzPiUlRJ/xh+otB75gva3r05isHMo5wXDfPRi5/b4hI=
-github.com/docker/cli v27.4.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v27.0.3+incompatible h1:usGs0/BoBW8MWxGeEtqPMkzOY56jZ6kYlSN5BLDioCQ=
+github.com/docker/cli v27.0.3+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
 github.com/docker/distribution v0.0.0-20190905152932-14b96e55d84c/go.mod h1:0+TTO4EOBfRPhZXAeF1Vu+W3hHZ8eLp8PgKVZlcvtFY=
 github.com/docker/distribution v2.7.1-0.20190205005809-0d3efadf0154+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/distribution v2.8.3+incompatible h1:AtKxIZ36LoNK51+Z6RpzLpddBirtxJnzDrHLEKxTAYk=
 github.com/docker/distribution v2.8.3+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/docker v1.4.2-0.20190924003213-a8608b5b67c7/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
-github.com/docker/docker v27.4.1+incompatible h1:ZJvcY7gfwHn1JF48PfbyXg7Jyt9ZCWDW+GGXOIxEwp4=
-github.com/docker/docker v27.4.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v27.0.3+incompatible h1:aBGI9TeQ4MPlhquTQKq9XbK79rKFVwXNUAYz9aXyEBE=
+github.com/docker/docker v27.0.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/docker-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=
@@ -341,8 +338,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 v1.2.3 h1:xwIyKHbaP5yfT6O9KIeYJR5549MXRQkoQMRXGztz8YQ=
-github.com/elazarl/goproxy v1.2.3/go.mod h1:YfEbZtqP4AetfO6d40vWchF3znWX7C7Vd6ZMfdL8z64=
+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/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=
@@ -373,16 +370,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.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
-github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
+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/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.6.1 h1:u+dcrgaguSSkbjzHwelEjc0Yj300NUevrrPphk/SoRA=
-github.com/go-git/go-billy/v5 v5.6.1/go.mod h1:0AsLr1z2+Uksi4NlElmMblP5rPcDZNRCD8ujZCRR2BE=
+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-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.13.1 h1:DAQ9APonnlvSWpvolXWIuV6Q6zXy2wHbN4cVlNR5Q+M=
-github.com/go-git/go-git/v5 v5.13.1/go.mod h1:qryJB4cSBoq3FRoBRf5A77joojuBcmPJ0qu3XXXVixc=
+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-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=
@@ -414,8 +411,8 @@ github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh
 github.com/go-sql-driver/mysql v1.3.0 h1:pgwjLi/dvffoP9aabwkT3AKpXQM93QARkjFhDDqC1UE=
 github.com/go-sql-driver/mysql v1.3.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-viper/mapstructure/v2 v2.2.1 h1:ZAaOCxANMuZx5RCeg0mBdEZk7DZasvvZIxtHqx8aGss=
-github.com/go-viper/mapstructure/v2 v2.2.1/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/go-viper/mapstructure/v2 v2.0.0 h1:dhn8MZ1gZ0mzeodTG3jt5Vj/o87xZKuNAprG2mQfMfc=
+github.com/go-viper/mapstructure/v2 v2.0.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
 github.com/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=
@@ -439,8 +436,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-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
-github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
+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/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=
@@ -520,10 +517,9 @@ github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
 github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo=
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.25.1 h1:VNqngBF40hVlDloBruUehVYC3ArSgIyScOAyMRqBxRg=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.25.1/go.mod h1:RBRO7fro65R6tjKzYgLAFo0t1QEXY1Dp+i/bvpRiqiQ=
+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/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=
@@ -574,6 +570,7 @@ 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=
@@ -585,8 +582,8 @@ github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+o
 github.com/klauspost/compress v1.11.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.11.13/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.14.2/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
-github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
+github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
+github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
 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=
@@ -602,8 +599,6 @@ 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/lib/pq v0.0.0-20150723085316-0dad96c0b94f/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/linuxkit/virtsock v0.0.0-20201010232012-f8cee7dfc7a3/go.mod h1:3r6x7q95whyfWQpmGZTu3gk3v2YkMi05HEzl7Tf7YEo=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
@@ -626,8 +621,9 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 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-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
-github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-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-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=
@@ -651,8 +647,6 @@ github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh
 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/mmcloughlin/avo v0.6.0 h1:QH6FU8SKoTLaVs80GA8TJuLNkUYl4VokHKlPhVDg4YY=
-github.com/mmcloughlin/avo v0.6.0/go.mod h1:8CoAGaCSYXtCPR+8y18Y9aB/kxb8JSS6FRI7mSkvD+8=
 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/locker v1.0.1/go.mod h1:S7SDdo5zpBK84bzzVlKr2V0hz+7x9hWbYC/kq7oQppc=
@@ -663,20 +657,16 @@ github.com/moby/sys/mountinfo v0.4.1/go.mod h1:rEr8tzG/lsIZHBtN/JjGG+LMYx9eXgW2J
 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.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/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/symlink v0.1.0/go.mod h1:GGDODQmbFOjFsXvfLVn3+ZRxkch54RkSiGqsZeMYowQ=
-github.com/moby/sys/user v0.3.0 h1:9ni5DlcW5an3SvRSx4MouotOygvzaXbaSrc/wGDFWPo=
-github.com/moby/sys/user v0.3.0/go.mod h1:bG+tYYYJgaMtRKgEmuueC0hJEAZWwtIbZTB+85uoHjs=
-github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g=
-github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28=
+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/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=
@@ -697,6 +687,8 @@ 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=
@@ -713,8 +705,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.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
-github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
+github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI=
+github.com/onsi/gomega v1.27.10/go.mod h1:RsS8tutOdbdgzbPtzzATp12yT7kM5I5aElG3evPbQ0M=
 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=
@@ -754,8 +746,8 @@ github.com/pelletier/go-toml v1.8.1/go.mod h1:T2/BmBdy8dvIRq1a/8aqjN41wvWlN4lrap
 github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8=
 github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
 github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
-github.com/pjbgf/sha1cd v0.3.1 h1:Dh2GYdpJnO84lIw0LJwTFXjcNbasP/bklicSznyAaPI=
-github.com/pjbgf/sha1cd v0.3.1/go.mod h1:Y8t7jSB/dEI/lQE04A1HVKteqjj9bX5O4+Cex0TCu8s=
+github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4=
+github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI=
 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=
@@ -771,8 +763,8 @@ 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.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=
-github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
+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_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=
@@ -786,8 +778,8 @@ github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y8
 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.61.0 h1:3gv/GThfX0cV2lpO7gkTUwZru38mxevy90Bj8YFSRQQ=
-github.com/prometheus/common v0.61.0/go.mod h1:zr29OCN/2BsJRaFwG8QOBr41D6kkchKbpeNH7pAjb/s=
+github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
+github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
 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=
@@ -808,16 +800,15 @@ github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUc
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
-github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww=
+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/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.17.1 h1:bI1MTaoQO+v5kzklBjYNRQLoVpe0zbyRZNK6DFkVC5U=
-github.com/schollz/progressbar/v3 v3.17.1/go.mod h1:RzqpnsPQNjUyIgdglUjRLgD7sVnxN1wpmBMV+UiEbL4=
+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/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=
@@ -834,8 +825,8 @@ github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic
 github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY=
-github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M=
+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/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=
@@ -870,6 +861,9 @@ github.com/stretchr/objx v0.0.0-20180129172003-8a3f7159479f/go.mod h1:HFkY916IF+
 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=
@@ -877,8 +871,11 @@ 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.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+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/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=
@@ -896,6 +893,8 @@ 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=
@@ -934,33 +933,29 @@ 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/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
-go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 h1:yd02MEjBdJkG3uabWP9apV+OuWRIXGDuJEUJbOHmCFU=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0/go.mod h1:umTcuxiv1n/s/S6/c2AT/g2CQ7u5C59sHDNmfSwgz7Q=
-go.opentelemetry.io/otel v1.33.0 h1:/FerN9bax5LoK51X/sI0SVYrjSE0/yUL7DpxW4K3FWw=
-go.opentelemetry.io/otel v1.33.0/go.mod h1:SUUkR6csvUQl+yjReHu5uM3EtVV7MBm5FHKRlNx4I8I=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.33.0 h1:7F29RDmnlqk6B5d+sUqemt8TBfDqxryYW5gX6L74RFA=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.33.0/go.mod h1:ZiGDq7xwDMKmWDrN1XsXAj0iC7hns+2DhxBFSncNHSE=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.33.0 h1:Vh5HayB/0HHfOQA7Ctx69E/Y/DcQSMPpKANYVMQ7fBA=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.33.0/go.mod h1:cpgtDBaqD/6ok/UG0jT15/uKjAY8mRA53diogHBg3UI=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.33.0 h1:5pojmb1U1AogINhN3SurB+zm/nIcusopeBNp42f45QM=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.33.0/go.mod h1:57gTHJSE5S1tqg+EKsLPlTWhpHMsWlVmer+LA926XiA=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 h1:4K4tsIXefpVJtvA/8srF4V4y0akAoPHkIslgAkjixJA=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0/go.mod h1:jjdQuTGVsXV4vSs+CJ2qYDeDPf9yIJV23qlIzBm73Vg=
+go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo=
+go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 h1:U2guen0GhqH8o/G2un8f/aG/y++OuW6MyCo6hT9prXk=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0/go.mod h1:yeGZANgEcpdx/WK0IvvRFC+2oLiMS2u4L/0Rj2M2Qr0=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 h1:3Q/xZUyC1BBkualc9ROb4G8qkH90LXEIICcs5zv1OYY=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0/go.mod h1:s75jGIWA9OfCMzF0xr+ZgfrB5FEbbV7UuYo32ahUiFI=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 h1:R3X6ZXmNPRR8ul6i3WgFURCHzaXjHdm0karRG/+dj3s=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0/go.mod h1:QWFXnDavXWwMx2EEcZsf3yxgEKAqsxQ+Syjp+seyInw=
 go.opentelemetry.io/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.33.0 h1:r+JOocAyeRVXD8lZpjdQjzMadVZp2M4WmQ+5WtEnklQ=
-go.opentelemetry.io/otel/metric v1.33.0/go.mod h1:L9+Fyctbp6HFTddIxClbQkjtubW6O9QS3Ann/M82u6M=
-go.opentelemetry.io/otel/sdk v1.33.0 h1:iax7M131HuAm9QkZotNHEfstof92xM+N8sr3uHXc2IM=
-go.opentelemetry.io/otel/sdk v1.33.0/go.mod h1:A1Q5oi7/9XaMlIWzPSxLRWOI8nG3FnzHJNbiENQuihM=
-go.opentelemetry.io/otel/sdk/metric v1.33.0 h1:Gs5VK9/WUJhNXZgn8MR6ITatvAmKeIuCtNbsP3JkNqU=
-go.opentelemetry.io/otel/sdk/metric v1.33.0/go.mod h1:dL5ykHZmm1B1nVRk9dDjChwDmt81MjVp3gLkQRwKf/Q=
-go.opentelemetry.io/otel/trace v1.33.0 h1:cCJuF7LRjUFso9LPnEAHJDB2pqzp+hbO8eu1qqW2d/s=
-go.opentelemetry.io/otel/trace v1.33.0/go.mod h1:uIcdVUZMpTAmz0tI1z04GoVSezK37CbGV4fr1f2nBck=
+go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bOeuA5Q=
+go.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s=
+go.opentelemetry.io/otel/sdk v1.28.0 h1:b9d7hIry8yZsgtbmM0DKyPWMMUMlK9NEKuIG4aBqWyE=
+go.opentelemetry.io/otel/sdk v1.28.0/go.mod h1:oYj7ClPUA7Iw3m+r7GeEjz0qckQRJK2B8zjcZEfu7Pg=
+go.opentelemetry.io/otel/sdk/metric v1.28.0 h1:OkuaKgKrgAbYrrY0t92c+cC+2F6hsFNnCQArXCKlg08=
+go.opentelemetry.io/otel/sdk/metric v1.28.0/go.mod h1:cWPjykihLAPvXKi4iZc1dpER3Jdq2Z0YLse3moQUCpg=
+go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+lkx9g=
+go.opentelemetry.io/otel/trace v1.28.0/go.mod h1:jPyXzNPg6da9+38HEwElrQiHlVMTnVfM3/yv2OlIHaI=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
-go.opentelemetry.io/proto/otlp v1.4.0 h1:TA9WRvW6zMwP+Ssb6fLoUIuirti1gGbP28GcKG1jgeg=
-go.opentelemetry.io/proto/otlp v1.4.0/go.mod h1:PPBWZIP98o2ElSqI35IHfu7hIhSwvc5N38Jw8pXuGFY=
-go.opentelemetry.io/proto/otlp v1.5.0 h1:xJvq7gMzB31/d406fB8U5CBdyQGw4P399D1aQWU/3i4=
-go.opentelemetry.io/proto/otlp v1.5.0/go.mod h1:keN8WnHxOy8PG0rQZjJJ5A2ebUoafqWp0eVQ4yIXvJ4=
+go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0=
+go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8=
 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=
@@ -985,10 +980,10 @@ golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWP
 golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
-golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
-golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
+golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
+golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
+golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
 golang.org/x/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=
@@ -999,10 +994,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-20250103183323-7d7fa50e5329 h1:9kj3STMvgqy3YA4VQXBrN7925ICMxD5wzMRcgA30588=
-golang.org/x/exp v0.0.0-20250103183323-7d7fa50e5329/go.mod h1:qj5a5QZpwLU2NLQudwIN5koi3beDhSAlJwa67PuM98c=
-golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 h1:yqrTHse8TCMW1M1ZCP+VAR/l0kKxwaAIqN/il7x4voA=
-golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8/go.mod h1:tujkw807nyEEAamNbDrEGzRav+ilXA7PCRAd6xsmwiU=
+golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 h1:yixxcjnhBmY0nkL253HFVIm0JsFHwrHdT3Yh6szTnfY=
+golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXyeI3r5MFf+NT2An6/9dOA95KSI=
 golang.org/x/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=
@@ -1025,8 +1018,7 @@ 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.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4=
-golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
+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=
@@ -1068,10 +1060,11 @@ 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.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
-golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
-golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
+golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
+golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
 golang.org/x/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=
@@ -1089,8 +1082,9 @@ 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.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
-golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+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=
@@ -1168,19 +1162,22 @@ golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBc
 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.0.0-20220908164124-27713097b956/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.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
-golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/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.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
-golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
-golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
-golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
+golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
+golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk=
+golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
 golang.org/x/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=
@@ -1190,18 +1187,18 @@ 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.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
-golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+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/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.8.0 h1:9i3RxcPv3PZnitoVGMPDKZSq1xW1gK1Xy3ArNOGZfEg=
-golang.org/x/time v0.8.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
-golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY=
-golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+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/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=
@@ -1247,10 +1244,7 @@ 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.28.0 h1:WuB6qZ4RPCQo5aP3WdKZS7i595EdWqWR8vqJTlwTVK8=
-golang.org/x/tools v0.28.0/go.mod h1:dcIOrVd3mfQKTgrDVQHqCPMWy6lnhfhtX3hLXYVLfRw=
-golang.org/x/tools v0.29.0 h1:Xx0h3TtM9rzQpQuR4dKLrdglAmCEN5Oi+P74JdhdzXE=
-golang.org/x/tools v0.29.0/go.mod h1:KMQVMRsVxU6nHCFXrBPhDB8XncLNLM0lIy/F14RP588=
+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=
@@ -1299,14 +1293,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-20250102185135-69823020774d h1:H8tOf8XM88HvKqLTxe755haY6r1fqqzLbEnfrmLXlSA=
-google.golang.org/genproto/googleapis/api v0.0.0-20250102185135-69823020774d/go.mod h1:2v7Z7gP2ZUOGsaFyxATQSRoBnKygqVq2Cwnvom7QiqY=
-google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422 h1:GVIKPyP/kLIyVOgOnTwFOrvQaQUzOzGMCxgFUOEmm24=
-google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422/go.mod h1:b6h1vNKhxaSoEI+5jc3PJUCustfli/mRab7295pY7rw=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250102185135-69823020774d h1:xJJRGY7TJcvIlpSrN3K6LAWgNFUILlO+OMAqtg9aqnw=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250102185135-69823020774d/go.mod h1:3ENsm/5D1mzDyhpzeRi1NR784I0BcofWBoSc5QqqMK4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250106144421-5f5ef82da422 h1:3UsHvIr4Wc2aW4brOaSCmcxh9ksica6fHEr8P1XhkYw=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250106144421-5f5ef82da422/go.mod h1:3ENsm/5D1mzDyhpzeRi1NR784I0BcofWBoSc5QqqMK4=
+google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094 h1:0+ozOGcrp+Y8Aq8TLNN2Aliibms5LEzsq99ZZmAGYm0=
+google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094/go.mod h1:fJ/e3If/Q67Mj99hin0hMhiNyCRmt6BQ2aWIJshUSJw=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 h1:BwIjyKYGsK9dMCBOorzRri8MQwmi7mT9rGHsCEinZkA=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
 google.golang.org/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=
@@ -1326,8 +1316,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.69.2 h1:U3S9QEtbXC0bYNvRtcoklF3xGtLViumSYxWykJS+7AU=
-google.golang.org/grpc v1.69.2/go.mod h1:vyjdE6jLBI76dgpDojsFGNaHlxdjXN9ghpnd2o7JGZ4=
+google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=
+google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ=
 google.golang.org/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=
@@ -1341,10 +1331,8 @@ 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.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=
-google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
-google.golang.org/protobuf v1.36.2 h1:R8FeyR1/eLmkutZOM5CWghmo5itiG9z0ktFlTVLuTmU=
-google.golang.org/protobuf v1.36.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
+google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
 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=
@@ -1384,7 +1372,6 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8=

pkg/app/app.go

@@ -36,7 +36,7 @@ func Get(appName string) (App, error) {
 		return App{}, err
 	}
 
-	log.Debugf("loaded app %s: %s", appName, app)
+	log.Debugf("retrieved %s for %s", app, appName)
 
 	return app, nil
 }
@@ -91,17 +91,6 @@ type App struct {
 	Path   string
 }
 
-// String outputs a human-friendly string representation.
-func (a App) String() string {
-	out := fmt.Sprintf("{name: %s, ", a.Name)
-	out += fmt.Sprintf("recipe: %s, ", a.Recipe)
-	out += fmt.Sprintf("domain: %s, ", a.Domain)
-	out += fmt.Sprintf("env %s, ", a.Env)
-	out += fmt.Sprintf("server %s, ", a.Server)
-	out += fmt.Sprintf("path %s}", a.Path)
-	return out
-}
-
 // Type aliases to make code hints easier to understand
 
 // AppName is AppName
@@ -246,6 +235,8 @@ func ReadAppEnvFile(appFile AppFile, name AppName) (App, error) {
 		return App{}, fmt.Errorf("env file for %s couldn't be read: %s", name, err.Error())
 	}
 
+	log.Debugf("read env %s from %s", env, appFile.Path)
+
 	app, err := NewApp(env, name, appFile)
 	if err != nil {
 		return App{}, fmt.Errorf("env file for %s has issues: %s", name, err.Error())
@@ -503,13 +494,13 @@ func GetAppComposeConfig(recipe string, opts stack.Deploy, appEnv envfile.AppEnv
 func ExposeAllEnv(stackName string, compose *composetypes.Config, appEnv envfile.AppEnv) {
 	for _, service := range compose.Services {
 		if service.Name == "app" {
-			log.Debugf("adding env vars to %s service config", stackName)
+			log.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
-					log.Debugf("%s: %s: %s", stackName, k, value)
+					log.Debugf("add env var: %s value: %s to %s", k, value, stackName)
 				}
 			}
 		}
@@ -578,96 +569,22 @@ func ReadAbraShCmdNames(abraSh string) ([]string, error) {
 	return cmdNames, nil
 }
 
-// Wipe removes the version from the app .env file.
-func (a App) WipeRecipeVersion() error {
+func (a App) WriteRecipeVersion(version string) error {
 	file, err := os.Open(a.Path)
 	if err != nil {
 		return err
 	}
 	defer file.Close()
 
-	var (
-		lines   []string
-		scanner = bufio.NewScanner(file)
-	)
-
+	scanner := bufio.NewScanner(file)
+	lines := []string{}
 	for scanner.Scan() {
 		line := scanner.Text()
-		if !strings.HasPrefix(line, "RECIPE=") && !strings.HasPrefix(line, "TYPE=") {
+		if !strings.Contains(line, "RECIPE=") && !strings.Contains(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.Debugf("version wiped from %s.env", a.Domain)
-
-	return nil
-}
-
-// WriteRecipeVersion writes the recipe version to the app .env file.
-func (a App) WriteRecipeVersion(version string, dryRun bool) error {
-	file, err := os.Open(a.Path)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	var (
-		dirtyVersion string
-		skipped      bool
-		lines        []string
-		scanner      = bufio.NewScanner(file)
-	)
-
-	for scanner.Scan() {
-		line := scanner.Text()
-		if !strings.HasPrefix(line, "RECIPE=") && !strings.HasPrefix(line, "TYPE=") {
-			lines = append(lines, line)
-			continue
-		}
-
-		if strings.HasPrefix(line, "#") {
-			lines = append(lines, line)
-			continue
-		}
-
-		if strings.Contains(line, version) && !a.Recipe.Dirty && !strings.HasSuffix(line, config.DIRTY_DEFAULT) {
-			skipped = true
-			lines = append(lines, line)
-			continue
-		}
-
-		splitted := strings.Split(line, ":")
-
-		if a.Recipe.Dirty {
-			dirtyVersion = fmt.Sprintf("%s%s", version, config.DIRTY_DEFAULT)
-			if strings.Contains(line, dirtyVersion) {
-				skipped = true
-				lines = append(lines, line)
-				continue
-			}
-
-			line = fmt.Sprintf("%s:%s", splitted[0], dirtyVersion)
-			lines = append(lines, line)
-			continue
-		}
-
 		line = fmt.Sprintf("%s:%s", splitted[0], version)
 		lines = append(lines, line)
 	}
@@ -676,23 +593,5 @@ func (a App) WriteRecipeVersion(version string, dryRun bool) error {
 		log.Fatal(err)
 	}
 
-	if a.Recipe.Dirty && dirtyVersion != "" {
-		version = dirtyVersion
-	}
-
-	if !dryRun {
-		if err := os.WriteFile(a.Path, []byte(strings.Join(lines, "\n")), os.ModePerm); err != nil {
-			log.Fatal(err)
-		}
-	} else {
-		log.Debugf("skipping writing version %s because dry run", version)
-	}
-
-	if !skipped {
-		log.Debugf("version %s saved to %s.env", version, a.Domain)
-	} else {
-		log.Debugf("skipping version %s write as already exists in %s.env", version, a.Domain)
-	}
-
-	return nil
+	return os.WriteFile(a.Path, []byte(strings.Join(lines, "\n")), os.ModePerm)
 }

pkg/app/app_test.go

@@ -198,41 +198,3 @@ 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)
-
-	app.Recipe.Dirty = true
-	if err := app.WriteRecipeVersion("foo+U", false); err != nil {
-		t.Fatal(err)
-	}
-
-	app, err = appPkg.GetApp(testPkg.ExpectedAppFiles, testPkg.AppName)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, "foo+U", app.Recipe.EnvVersion)
-}

pkg/autocomplete/autocomplete.go

@@ -2,123 +2,101 @@ package autocomplete
 
 import (
 	"fmt"
-	"sort"
 
 	"coopcloud.tech/abra/pkg/app"
-	appPkg "coopcloud.tech/abra/pkg/app"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/spf13/cobra"
+	"github.com/urfave/cli"
 )
 
 // AppNameComplete copletes app names.
-func AppNameComplete() ([]string, cobra.ShellCompDirective) {
-	appFiles, err := app.LoadAppFiles("")
+func AppNameComplete(c *cli.Context) {
+	appNames, err := app.GetAppNames()
 	if err != nil {
-		err := fmt.Sprintf("autocomplete failed: %s", err)
-		return []string{err}, cobra.ShellCompDirectiveError
+		log.Warn(err)
 	}
 
-	var appNames []string
-	for appName := range appFiles {
-		appNames = append(appNames, appName)
+	if c.NArg() > 0 {
+		return
 	}
 
-	return appNames, cobra.ShellCompDirectiveDefault
+	for _, a := range appNames {
+		fmt.Println(a)
+	}
 }
 
-func ServiceNameComplete(appName string) ([]string, cobra.ShellCompDirective) {
+func ServiceNameComplete(appName string) {
 	serviceNames, err := app.GetAppServiceNames(appName)
 	if err != nil {
-		err := fmt.Sprintf("autocomplete failed: %s", err)
-		return []string{err}, cobra.ShellCompDirectiveError
+		return
+	}
+	for _, s := range serviceNames {
+		fmt.Println(s)
 	}
-
-	return serviceNames, cobra.ShellCompDirectiveDefault
 }
 
 // RecipeNameComplete completes recipe names.
-func RecipeNameComplete() ([]string, cobra.ShellCompDirective) {
+func RecipeNameComplete(c *cli.Context) {
 	catl, err := recipe.ReadRecipeCatalogue(false)
 	if err != nil {
-		err := fmt.Sprintf("autocomplete failed: %s", err)
-		return []string{err}, cobra.ShellCompDirectiveError
+		log.Warn(err)
+	}
+
+	if c.NArg() > 0 {
+		return
 	}
 
-	var recipeNames []string
 	for name := range catl {
-		recipeNames = append(recipeNames, name)
+		fmt.Println(name)
 	}
-
-	return recipeNames, cobra.ShellCompDirectiveDefault
 }
 
 // RecipeVersionComplete completes versions for the recipe.
-func RecipeVersionComplete(recipeName string) ([]string, cobra.ShellCompDirective) {
-	catl, err := recipe.ReadRecipeCatalogue(true)
+func RecipeVersionComplete(recipeName string) {
+	catl, err := recipe.ReadRecipeCatalogue(false)
 	if err != nil {
-		err := fmt.Sprintf("autocomplete failed: %s", err)
-		return []string{err}, cobra.ShellCompDirectiveError
+		log.Warn(err)
 	}
 
-	var recipeVersions []string
 	for _, v := range catl[recipeName].Versions {
 		for v2 := range v {
-			recipeVersions = append(recipeVersions, v2)
+			fmt.Println(v2)
 		}
 	}
-
-	return recipeVersions, cobra.ShellCompDirectiveDefault
 }
 
 // ServerNameComplete completes server names.
-func ServerNameComplete() ([]string, cobra.ShellCompDirective) {
+func ServerNameComplete(c *cli.Context) {
 	files, err := app.LoadAppFiles("")
 	if err != nil {
-		err := fmt.Sprintf("autocomplete failed: %s", err)
-		return []string{err}, cobra.ShellCompDirectiveError
+		log.Fatal(err)
+	}
+
+	if c.NArg() > 0 {
+		return
 	}
 
-	var serverNames []string
 	for _, appFile := range files {
-		serverNames = append(serverNames, appFile.Server)
+		fmt.Println(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 := fmt.Sprintf("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 := fmt.Sprintf("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 := fmt.Sprintf("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

@@ -16,12 +16,13 @@ import (
 func EnsureCatalogue() error {
 	catalogueDir := path.Join(config.ABRA_DIR, "catalogue")
 	if _, err := os.Stat(catalogueDir); err != nil && os.IsNotExist(err) {
-		log.Debugf("catalogue is missing, retrieving now")
-
+		log.Warnf("local recipe catalogue is missing, retrieving now")
 		url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, config.CATALOGUE_JSON_REPO_NAME)
 		if err := gitPkg.Clone(catalogueDir, url); err != nil {
 			return err
 		}
+
+		log.Debugf("cloned catalogue repository to %s", catalogueDir)
 	}
 
 	return nil

pkg/config/abra.go

@@ -106,19 +106,5 @@ var (
 	RECIPES_JSON             = path.Join(config.GetCatalogueDir(), "recipes.json")
 	REPOS_BASE_URL           = "https://git.coopcloud.tech/coop-cloud"
 	CATALOGUE_JSON_REPO_NAME = "recipes-catalogue-json"
-	TOOLSHED_SSH_URL_TEMPLATE = "ssh://git@git.coopcloud.tech:2222/toolshed/%s.git"
-	RECIPES_SSH_URL_TEMPLATE  = "ssh://git@git.coopcloud.tech:2222/coop-cloud/%s.git"
-
-	// NOTE(d1): please note, this was done purely out of laziness on our part
-	// AFAICR. it's easy to punt the value into the label because that is what is
-	// expects. it's not particularly useful in terms of UI/UX but hey, nobody
-	// complained yet!
-	CHAOS_DEFAULT = "false"
-
-	DIRTY_DEFAULT = "+U"
-
-	NO_DOMAIN_DEFAULT  = "N/A"
-	NO_VERSION_DEFAULT = "N/A"
-
-	UNKNOWN_DEFAULT = "unknown"
+	SSH_URL_TEMPLATE         = "ssh://git@git.coopcloud.tech:2222/coop-cloud/%s.git"
 )

pkg/config/env.go

@@ -26,16 +26,9 @@ func GetServers() ([]string, error) {
 		return servers, err
 	}
 
-	var filtered []string
-	for _, s := range servers {
-		if !strings.HasPrefix(s, ".") {
-			filtered = append(filtered, s)
-		}
-	}
+	log.Debugf("retrieved %v servers: %s", len(servers), servers)
 
-	log.Debugf("retrieved %v servers: %s", len(filtered), filtered)
-
-	return filtered, nil
+	return servers, nil
 }
 
 // ReadServerNames retrieves all server names.

pkg/dns/dns.go

@@ -9,11 +9,12 @@ import (
 func EnsureIPv4(domainName string) (string, error) {
 	ipv4, err := net.ResolveIPAddr("ip4", domainName)
 	if err != nil {
-		return "", fmt.Errorf("%s: unable to resolve IPv4 address: %s", domainName, err)
+		return "", fmt.Errorf("unable to resolve ipv4 address for %s, %s", domainName, err)
 	}
 
+	// NOTE(d1): e.g. when there is only an ipv6 record available
 	if ipv4 == nil {
-		return "", fmt.Errorf("%s: no IPv4 available", domainName)
+		return "", fmt.Errorf("unable to resolve ipv4 address for %s", domainName)
 	}
 
 	return ipv4.String(), nil

pkg/dns/dns_test.go

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

pkg/envfile/envfile.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 
 	"coopcloud.tech/abra/pkg/log"
-	"git.coopcloud.tech/toolshed/godotenv"
+	"git.coopcloud.tech/coop-cloud/godotenv"
 )
 
 // envVarModifiers is a list of env var modifier strings. These are added to
@@ -31,6 +31,8 @@ func ReadEnv(filePath string) (AppEnv, error) {
 		return nil, err
 	}
 
+	log.Debugf("read %s from %s", envVars, filePath)
+
 	return envVars, nil
 }
 

pkg/envfile/envfile_test.go

@@ -11,7 +11,6 @@ import (
 	"coopcloud.tech/abra/pkg/envfile"
 	"coopcloud.tech/abra/pkg/recipe"
 	testPkg "coopcloud.tech/abra/pkg/test"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestGetAllFoldersInDirectory(t *testing.T) {
@@ -44,7 +43,13 @@ func TestReadEnv(t *testing.T) {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(env, testPkg.ExpectedAppEnv) {
-		t.Fatal("did not get expected application settings")
+		t.Fatalf(
+			"did not get expected application settings. Expected: DOMAIN=%s RECIPE=%s; Got: DOMAIN=%s RECIPE=%s",
+			testPkg.ExpectedAppEnv["DOMAIN"],
+			testPkg.ExpectedAppEnv["RECIPE"],
+			env["DOMAIN"],
+			env["RECIPE"],
+		)
 	}
 }
 
@@ -192,7 +197,7 @@ func TestEnvVarCommentsRemoved(t *testing.T) {
 
 	envVar, exists = envSample["SECRET_TEST_PASS_TWO_VERSION"]
 	if !exists {
-		t.Fatal("SECRET_TEST_PASS_TWO_VERSION env var should be present in .env.sample")
+		t.Fatal("WITH_COMMENT env var should be present in .env.sample")
 	}
 
 	if strings.Contains(envVar, "length") {
@@ -223,21 +228,3 @@ func TestEnvVarModifiersIncluded(t *testing.T) {
 		}
 	}
 }
-
-func TestNoOverwriteNonVersionEnvVars(t *testing.T) {
-	app, err := appPkg.GetApp(testPkg.ExpectedAppFiles, testPkg.AppName)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := app.WriteRecipeVersion("1.3.12", true); err != nil {
-		t.Fatal(err)
-	}
-
-	app, err = appPkg.GetApp(testPkg.ExpectedAppFiles, testPkg.AppName)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.NotEqual(t, app.Env["SMTP_AUTHTYPE"], "login:1.3.12")
-}

pkg/formatter/formatter.go

@@ -1,30 +1,18 @@
 package formatter
 
 import (
-	"bytes"
-	"encoding/json"
 	"fmt"
 	"os"
 	"strings"
 	"time"
 
-	"github.com/charmbracelet/lipgloss"
-	"github.com/charmbracelet/lipgloss/table"
 	"github.com/docker/go-units"
-	"golang.org/x/term"
-
-	"coopcloud.tech/abra/pkg/config"
+	// "github.com/olekukonko/tablewriter"
+	"coopcloud.tech/abra/pkg/jsontable"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/schollz/progressbar/v3"
 )
 
-var BoldStyle = lipgloss.NewStyle().
-	Bold(true)
-
-var BoldUnderlineStyle = lipgloss.NewStyle().
-	Bold(true).
-	Underline(true)
-
 func ShortenID(str string) string {
 	return str[:12]
 }
@@ -46,168 +34,11 @@ func HumanDuration(timestamp int64) string {
 }
 
 // CreateTable prepares a table layout for output.
-func CreateTable() (*table.Table, error) {
-	var (
-		renderer    = lipgloss.NewRenderer(os.Stdout)
-		headerStyle = renderer.NewStyle().Bold(true).Align(lipgloss.Center)
-		cellStyle   = renderer.NewStyle().Padding(0, 1)
-		borderStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("63"))
-	)
-
-	table := table.New().
-		Border(lipgloss.ThickBorder()).
-		BorderStyle(borderStyle).
-		StyleFunc(func(row, col int) lipgloss.Style {
-			var style lipgloss.Style
-
-			switch {
-			case row == table.HeaderRow:
-				return headerStyle
-			default:
-				style = cellStyle
-			}
-
-			return style
-		})
-
-	return table, nil
-}
-
-func PrintTable(t *table.Table) error {
-	if isAbraCI, ok := os.LookupEnv("ABRA_CI"); ok && isAbraCI == "1" {
-		// NOTE(d1): no width limits for CI testing since we test against outputs
-		log.Debug("detected ABRA_CI=1")
-		fmt.Println(t)
-		return nil
-	}
-
-	tWidth, _ := lipgloss.Size(t.String())
-
-	width, _, err := term.GetSize(0)
-	if err != nil {
-		return err
-	}
-
-	if tWidth > width {
-		t.Width(width - 10)
-	}
-
-	fmt.Println(t)
-
-	return nil
-}
-
-// horizontal is a JoinHorizontal helper function.
-func horizontal(left, mid, right string) string {
-	return lipgloss.JoinHorizontal(lipgloss.Right, left, mid, right)
-}
-
-func CreateOverview(header string, rows [][]string) string {
-	var borderStyle = lipgloss.NewStyle().
-		BorderStyle(lipgloss.ThickBorder()).
-		Padding(0, 1, 0, 1).
-		BorderForeground(lipgloss.Color("63"))
-
-	var headerStyle = lipgloss.NewStyle().
-		Underline(true).
-		Bold(true).
-		PaddingBottom(1)
-
-	var leftStyle = lipgloss.NewStyle()
-	var rightStyle = lipgloss.NewStyle()
-
-	var longest int
-	for _, row := range rows {
-		if len(row[0]) > longest {
-			longest = len(row[0])
-		}
-	}
-
-	var renderedRows []string
-	for _, row := range rows {
-		if len(row) < 2 {
-			continue
-		}
-
-		if len(row) > 2 {
-			panic("CreateOverview: only accepts rows of len == 2")
-		}
-
-		lenOffset := 4
-		if len(row[0]) < longest {
-			lenOffset += longest - len(row[0])
-		}
-
-		offset := ""
-		for range lenOffset {
-			offset = offset + " "
-		}
-
-		rendered := horizontal(leftStyle.Render(row[0]), offset, rightStyle.Render(row[1]))
-
-		if row[1] == "---" {
-			rendered = horizontal(
-				leftStyle.
-					Bold(true).
-					Underline(true).
-					PaddingTop(1).
-					Render(row[0]),
-				offset,
-				rightStyle.Render(""),
-			)
-		}
-
-		renderedRows = append(renderedRows, rendered)
-	}
-
-	body := strings.Builder{}
-	body.WriteString(
-		borderStyle.Render(
-			lipgloss.JoinVertical(
-				lipgloss.Center,
-				headerStyle.Render(header),
-				lipgloss.JoinVertical(
-					lipgloss.Left,
-					renderedRows...,
-				),
-			),
-		),
-	)
-
-	return body.String()
-}
-
-// ToJSON converts a lipgloss.Table to JSON representation. It's not a robust
-// implementation and mainly caters for our current use case which is basically
-// a bunch of strings. See https://github.com/charmbracelet/lipgloss/issues/335
-// for the real thing (hopefully).
-func ToJSON(headers []string, rows [][]string) (string, error) {
-	var buff bytes.Buffer
-
-	buff.Write([]byte("["))
-
-	for idx, row := range rows {
-		payload := make(map[string]string)
-
-		for idx, header := range headers {
-			payload[strings.ToLower(header)] = row[idx]
-		}
-
-		serialized, err := json.Marshal(payload)
-		if err != nil {
-			return "", err
-		}
-
-		buff.Write(serialized)
-
-		if idx < (len(rows) - 1) {
-			buff.Write([]byte(","))
-		}
-	}
-
-	buff.Write([]byte("]"))
-
-	return buff.String(), nil
+func CreateTable(columns []string) *jsontable.JSONTable {
+	table := jsontable.NewJSONTable(os.Stdout)
+	table.SetAutoWrapText(false)
+	table.SetHeader(columns)
+	return table
 }
 
 // CreateProgressbar generates a progress bar
@@ -217,6 +48,7 @@ func CreateProgressbar(length int, title string) *progressbar.ProgressBar {
 		progressbar.OptionClearOnFinish(),
 		progressbar.OptionSetPredictTime(false),
 		progressbar.OptionShowCount(),
+		progressbar.OptionFullWidth(),
 		progressbar.OptionSetDescription(title),
 	)
 }
@@ -257,18 +89,3 @@ func ByteCountSI(b uint64) string {
 
 	return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "kMGTPE"[exp])
 }
-
-// BoldDirtyDefault ensures a dirty modifier is rendered in bold.
-func BoldDirtyDefault(v string) string {
-	if strings.HasSuffix(v, config.DIRTY_DEFAULT) {
-		vBold := BoldStyle.Render(config.DIRTY_DEFAULT)
-		v = strings.Replace(v, config.DIRTY_DEFAULT, vBold, 1)
-	}
-
-	return v
-}
-
-// AddDirtyMarker adds the dirty marker to a version string.
-func AddDirtyMarker(v string) string {
-	return fmt.Sprintf("%s%s", v, config.DIRTY_DEFAULT)
-}

pkg/formatter/formatter_test.go

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

pkg/git/clone.go

@@ -1,7 +1,9 @@
 package git
 
 import (
+	"fmt"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"coopcloud.tech/abra/pkg/log"
@@ -9,38 +11,10 @@ import (
 	"github.com/go-git/go-git/v5/plumbing"
 )
 
-// gitCloneIgnoreErr checks whether we can ignore a git clone error or not.
-func gitCloneIgnoreErr(err error) bool {
-	if strings.Contains(err.Error(), "authentication required") {
-		return true
-	}
-
-	if strings.Contains(err.Error(), "remote repository is empty") {
-		return true
-	}
-
-	return false
-}
-
 // Clone runs a git clone which accounts for different default branches.
 func Clone(dir, url string) error {
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		log.Debugf("git clone: %s", dir, url)
-
-		_, err := git.PlainClone(dir, false, &git.CloneOptions{
-			URL:           url,
-			Tags:          git.AllTags,
-			ReferenceName: plumbing.ReferenceName("refs/heads/main"),
-			SingleBranch:  true,
-		})
-
-		if err != nil && gitCloneIgnoreErr(err) {
-			log.Debugf("git clone: %s cloned successfully", dir)
-			return nil
-		}
-
-		if err != nil {
-			log.Debug("git clone: main branch failed, attempting master branch")
+		log.Debugf("%s does not exist, attempting to git clone from %s", dir, url)
 
 		_, err := git.PlainClone(dir, false, &git.CloneOptions{
 			URL:           url,
@@ -48,20 +22,28 @@ func Clone(dir, url string) error {
 			ReferenceName: plumbing.ReferenceName("refs/heads/master"),
 			SingleBranch:  true,
 		})
+		if err != nil {
+			log.Debugf("cloning %s default branch failed, attempting from main branch", url)
 
-			if err != nil && gitCloneIgnoreErr(err) {
-				log.Debugf("git clone: %s cloned successfully", dir)
-				return nil
+			_, err := git.PlainClone(dir, false, &git.CloneOptions{
+				URL:           url,
+				Tags:          git.AllTags,
+				ReferenceName: plumbing.ReferenceName("refs/heads/main"),
+				SingleBranch:  true,
+			})
+			if err != nil {
+				if strings.Contains(err.Error(), "authentication required") {
+					name := filepath.Base(dir)
+					return fmt.Errorf("unable to clone %s, does %s exist?", name, url)
 				}
 
-			if err != nil {
 				return err
 			}
 		}
 
-		log.Debugf("git clone: %s cloned successfully", dir)
+		log.Debugf("%s has been git cloned successfully", dir)
 	} else {
-		log.Debugf("git clone: %s already exists", dir)
+		log.Debugf("%s already exists", dir)
 	}
 
 	return nil

pkg/git/init.go

@@ -5,21 +5,14 @@ import (
 
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/object"
 )
 
 // Init inits a new repo and commits all the stuff if you want
 func Init(repoPath string, commit bool, gitName, gitEmail string) error {
-	repo, err := git.PlainInit(repoPath, false)
-	if err != nil {
+	if _, err := git.PlainInit(repoPath, false); err != nil {
 		return fmt.Errorf("git init: %s", err)
 	}
-
-	if err = SwitchToMain(repo); err != nil {
-		return fmt.Errorf("git branch rename: %s", err)
-	}
-
 	log.Debugf("initialised new git repo in %s", repoPath)
 
 	if commit {
@@ -41,35 +34,11 @@ func Init(repoPath string, commit bool, gitName, gitEmail string) error {
 		if gitName != "" && gitEmail != "" {
 			author = &object.Signature{Name: gitName, Email: gitEmail}
 		}
-
 		if _, err = commitWorktree.Commit("init", &git.CommitOptions{Author: author}); err != nil {
 			return fmt.Errorf("git commit: %s", err)
 		}
-
 		log.Debugf("init committed all files for new git repo in %s", repoPath)
 	}
 
 	return nil
 }
-
-// SwitchToMain sets the default branch to "main".
-func SwitchToMain(repo *git.Repository) error {
-	ref := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.ReferenceName("refs/heads/main"))
-	if err := repo.Storer.SetReference(ref); err != nil {
-		return fmt.Errorf("set reference: %s", err)
-	}
-
-	cfg, err := repo.Config()
-	if err != nil {
-		return fmt.Errorf("repo config: %s", err)
-	}
-
-	cfg.Init.DefaultBranch = "main"
-	if err := repo.SetConfig(cfg); err != nil {
-		return fmt.Errorf("repo set config: %s", err)
-	}
-
-	log.Debug("set 'main' as the default branch")
-
-	return nil
-}

pkg/git/init_test.go

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

pkg/git/read.go

@@ -1,34 +1,48 @@
 package git
 
 import (
-	"errors"
-	"fmt"
 	"io/ioutil"
 	"os"
 	"os/user"
+	"path"
 	"path/filepath"
 	"strings"
 
+	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
 	gitConfigPkg "github.com/go-git/go-git/v5/config"
+	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/format/gitignore"
 )
 
+// GetRecipeHead retrieves latest HEAD metadata.
+func GetRecipeHead(recipeName string) (*plumbing.Reference, error) {
+	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
+
+	repo, err := git.PlainOpen(recipeDir)
+	if err != nil {
+		return nil, err
+	}
+
+	head, err := repo.Head()
+	if err != nil {
+		return nil, err
+	}
+
+	return head, nil
+}
+
 // IsClean checks if a repo has unstaged changes
 func IsClean(repoPath string) (bool, error) {
 	repo, err := git.PlainOpen(repoPath)
 	if err != nil {
-		if errors.Is(err, git.ErrRepositoryNotExists) {
-			return false, git.ErrRepositoryNotExists
-		}
-
-		return false, fmt.Errorf("unable to open %s: %s", repoPath, err)
+		return false, err
 	}
 
 	worktree, err := repo.Worktree()
 	if err != nil {
-		return false, fmt.Errorf("unable to open worktree of %s: %s", repoPath, err)
+		return false, err
 	}
 
 	patterns, err := GetExcludesFiles()
@@ -42,14 +56,13 @@ func IsClean(repoPath string) (bool, error) {
 
 	status, err := worktree.Status()
 	if err != nil {
-		return false, fmt.Errorf("unable to query status of %s: %s", repoPath, err)
+		return false, err
 	}
 
 	if status.String() != "" {
-		noNewline := strings.TrimSuffix(status.String(), "\n")
-		log.Debugf("git status: %s: %s", repoPath, noNewline)
+		log.Debugf("discovered git status in %s: %s", repoPath, status.String())
 	} else {
-		log.Debugf("git status: %s: clean", repoPath)
+		log.Debugf("discovered clean git status in %s", repoPath)
 	}
 
 	return status.IsClean(), nil

pkg/git/read_test.go

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

pkg/jsontable/jsontable.go

@@ -0,0 +1,211 @@
+package jsontable
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/olekukonko/tablewriter"
+)
+
+// A quick-and-dirty proxy/emulator of tablewriter to enable more easy machine readable output
+// - Does not strictly support types, just quoted or unquoted values
+// - Does not support nested values.
+// If a datalabel is set with SetDataLabel(true, "..."), that will be used as the key for teh data of the table,
+// otherwise if the caption is set with SetCaption(true, "..."), the data label will be set to the default of
+// "rows", otherwise the table will output as a JSON list.
+//
+// Proxys all actions through to the tablewriter except addrow and addbatch, which it does at render time
+//
+
+type JSONTable struct {
+	out             io.Writer
+	colsize         int
+	rows            [][]string
+	keys            []string
+	quoted          []bool // hack to do output typing, quoted vs. unquoted
+	hasDataLabel    bool
+	dataLabel       string
+	hasCaption      bool
+	caption         string // the actual caption
+	hasCaptionLabel bool
+	captionLabel    string // the key in the dictionary for the caption
+	tbl             *tablewriter.Table
+}
+
+func writeChar(w io.Writer, c byte) {
+	w.Write([]byte{c})
+
+}
+
+func NewJSONTable(writer io.Writer) *JSONTable {
+	t := &JSONTable{
+		out:             writer,
+		colsize:         0,
+		rows:            [][]string{},
+		keys:            []string{},
+		quoted:          []bool{},
+		hasDataLabel:    false,
+		dataLabel:       "rows",
+		hasCaption:      false,
+		caption:         "",
+		hasCaptionLabel: false,
+		captionLabel:    "caption",
+		tbl:             tablewriter.NewWriter(writer),
+	}
+	return t
+}
+
+func (t *JSONTable) NumLines() int {
+	// JSON only but reflects a shared state.
+	return len(t.rows)
+}
+
+func (t *JSONTable) SetHeader(keys []string) {
+	// Set the keys value which will assign each column to the keys.
+	// Note that we'll ignore values that are beyond the length of the keys list
+	t.colsize = len(keys)
+	t.keys = []string{}
+	for _, k := range keys {
+		t.keys = append(t.keys, k)
+		t.quoted = append(t.quoted, true)
+	}
+	t.tbl.SetHeader(keys)
+}
+
+func (t *JSONTable) SetColumnQuoting(quoting []bool) {
+	// Specify which columns are quoted or unquoted in output
+	// JSON only
+	for i := 0; i < t.colsize; i++ {
+		t.quoted[i] = quoting[i]
+	}
+}
+
+func (t *JSONTable) Append(row []string) {
+	// We'll just append whatever to the rows list. If they fix the keys after appending rows, it'll work as
+	// expected.
+	// We should detect if the row is narrower than the key list tho.
+	// JSON only (but we use the rows later when rendering a regular table)
+	t.rows = append(t.rows, row)
+}
+
+func (t *JSONTable) Render() {
+	// Load the table with rows and render.
+	// Proxy only
+	for _, row := range t.rows {
+		t.tbl.Append(row)
+	}
+
+	t.tbl.Render()
+}
+
+func (t *JSONTable) _JSONRenderInner() {
+	// JSON only
+	// Render the list of dictionaries to the writer.
+	//// inner render loop
+	writeChar(t.out, '[')
+	for rowidx, row := range t.rows {
+		if rowidx != 0 {
+			writeChar(t.out, ',')
+		}
+		writeChar(t.out, '{')
+		for keyidx, key := range t.keys {
+			key := strings.ToLower(key)
+			key = strings.ReplaceAll(key, " ", "-")
+
+			value := "nil"
+			if keyidx < len(row) {
+				value = row[keyidx]
+			}
+			if keyidx != 0 {
+				writeChar(t.out, ',')
+			}
+			if t.quoted[keyidx] {
+				fmt.Fprintf(t.out, "\"%s\":\"%s\"", key, value)
+			} else {
+				fmt.Fprintf(t.out, "\"%s\":%s", key, value)
+			}
+		}
+		writeChar(t.out, '}')
+	}
+	writeChar(t.out, ']')
+
+}
+
+func (t *JSONTable) JSONRender() {
+	// write JSON table to output
+	// JSON only
+
+	if t.hasDataLabel || t.hasCaption {
+		// dict mode
+		writeChar(t.out, '{')
+
+		if t.hasCaption {
+			fmt.Fprintf(t.out, "\"%s\":\"%s\",", t.captionLabel, t.caption)
+		}
+		fmt.Fprintf(t.out, "\"%s\":", t.dataLabel)
+	}
+
+	// write list
+	t._JSONRenderInner()
+
+	if t.hasDataLabel || t.hasCaption {
+		// dict mode
+		writeChar(t.out, '}')
+	}
+
+}
+
+func (t *JSONTable) SetCaption(caption bool, captionText ...string) {
+	t.hasCaption = caption
+	if len(captionText) == 1 {
+		t.caption = captionText[0]
+	}
+	t.tbl.SetCaption(caption, captionText...)
+}
+
+func (t *JSONTable) SetCaptionLabel(captionLabel bool, captionLabelText ...string) {
+	// JSON only
+	t.hasCaptionLabel = captionLabel
+	if len(captionLabelText) == 1 {
+		t.captionLabel = captionLabelText[0]
+	}
+}
+
+func (t *JSONTable) SetDataLabel(dataLabel bool, dataLabelText ...string) {
+	// JSON only
+	t.hasDataLabel = dataLabel
+	if len(dataLabelText) == 1 {
+		t.dataLabel = dataLabelText[0]
+	}
+}
+
+func (t *JSONTable) AppendBulk(rows [][]string) {
+	// JSON only but reflects shared state
+	for _, row := range rows {
+		t.Append(row)
+	}
+}
+
+// Stuff we should implement but we just proxy for now.
+func (t *JSONTable) SetAutoMergeCellsByColumnIndex(cols []int) {
+	// FIXME
+	t.tbl.SetAutoMergeCellsByColumnIndex(cols)
+}
+
+// Stuff we should implement but we just proxy for now.
+func (t *JSONTable) SetAlignment(align int) {
+	// FIXME
+	t.tbl.SetAlignment(align)
+}
+
+func (t *JSONTable) SetAutoMergeCells(auto bool) {
+	// FIXME
+	t.tbl.SetAutoMergeCells(auto)
+}
+
+// Stub functions
+func (t *JSONTable) SetAutoWrapText(auto bool) {
+	t.tbl.SetAutoWrapText(auto)
+	return
+}

pkg/jsontable/jsontable_test.go

@@ -0,0 +1,83 @@
+package jsontable
+
+import (
+	"testing"
+
+	"bytes"
+	"encoding/json"
+
+	"github.com/olekukonko/tablewriter"
+)
+
+var TestLine = []string{"1", "2"}
+var TestGroup = [][]string{{"1", "2", "3"}, {"a", "teohunteohu", "c", "d"}, {"☺", "☹"}}
+var TestKeys = []string{"key0", "key1", "key2"}
+
+// test creation
+func TestNewTable(t *testing.T) {
+	var b bytes.Buffer
+	tbl := NewJSONTable(&b)
+	if tbl.NumLines() != 0 {
+		t.Fatalf("Something went weird when making table (should have 0 lines)")
+	}
+}
+
+// test adding things
+func TestTableAdd(t *testing.T) {
+	var b bytes.Buffer
+	tbl := NewJSONTable(&b)
+
+	tbl.Append(TestLine)
+	if tbl.NumLines() != 1 {
+		t.Fatalf("Appending a line does not result in a length of 1.")
+	}
+
+	tbl.AppendBulk(TestGroup)
+	numlines := tbl.NumLines()
+	if numlines != (len(TestGroup) + 1) {
+		t.Fatalf("Appending two lines does not result in a length of 4 (length is %d).", numlines)
+	}
+}
+
+// test JSON output is parsable
+func TestJsonParsable(t *testing.T) {
+	var b bytes.Buffer
+	tbl := NewJSONTable(&b)
+
+	tbl.AppendBulk(TestGroup)
+	tbl.SetHeader(TestKeys)
+
+	tbl.JSONRender()
+
+	var son []map[string]interface{}
+
+	err := json.Unmarshal(b.Bytes(), &son)
+
+	if err != nil {
+		t.Fatalf("Did not produce parsable JSON: %s", err.Error())
+	}
+}
+
+// test identical commands to a tablewriter and jsontable produce the same rendered output
+func TestTableWriter(t *testing.T) {
+	var bjson bytes.Buffer
+	var btable bytes.Buffer
+
+	tbl := NewJSONTable(&bjson)
+
+	tbl.AppendBulk(TestGroup)
+	tbl.SetHeader(TestKeys)
+	tbl.Render()
+
+	wtbl := tablewriter.NewWriter(&btable)
+
+	wtbl.AppendBulk(TestGroup)
+	wtbl.SetHeader(TestKeys)
+	wtbl.Render()
+
+	if bytes.Compare(bjson.Bytes(), btable.Bytes()) != 0 {
+		t.Fatalf("JSON table and TableWriter produce non-identical outputs.\n%s\n%s", bjson.Bytes(), btable.Bytes())
+	}
+}
+
+/// FIXME test different output formats when captions etc. are added

pkg/lint/recipe.go

@@ -137,13 +137,6 @@ var LintRules = map[string][]LintRule{
 			HowToResolve: "name a servce 'app'",
 			Function:     LintAppService,
 		},
-		{
-			Ref:          "R015",
-			Level:        "error",
-			Description:  "deploy labels stanza present",
-			HowToResolve: "include \"deploy: labels: ...\" stanza",
-			Function:     LintDeployLabelsPresent,
-		},
 		{
 			Ref:           "R010",
 			Level:         "error",
@@ -276,21 +269,6 @@ func LintTraefikEnabled(recipe recipe.Recipe) (bool, error) {
 	return false, nil
 }
 
-func LintDeployLabelsPresent(recipe recipe.Recipe) (bool, error) {
-	config, err := recipe.GetComposeConfig(nil)
-	if err != nil {
-		return false, err
-	}
-
-	for _, service := range config.Services {
-		if service.Name == "app" && service.Deploy.Labels != nil {
-			return true, nil
-		}
-	}
-
-	return false, nil
-}
-
 func LintHealthchecks(recipe recipe.Recipe) (bool, error) {
 	config, err := recipe.GetComposeConfig(nil)
 	if err != nil {
@@ -409,7 +387,7 @@ func LintHasPublishedVersion(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintMetadataFilledIn(r recipe.Recipe) (bool, error) {
-	features, category, _, err := recipe.GetRecipeFeaturesAndCategory(r)
+	features, category, err := recipe.GetRecipeFeaturesAndCategory(r)
 	if err != nil {
 		return false, err
 	}

pkg/recipe/files.go

@@ -6,7 +6,6 @@ import (
 	"path"
 
 	"coopcloud.tech/abra/pkg/envfile"
-	"coopcloud.tech/abra/pkg/formatter"
 )
 
 func (r Recipe) SampleEnv() (map[string]string, error) {
@@ -30,10 +29,7 @@ func (r Recipe) GetReleaseNotes(version string) (string, error) {
 		if err != nil {
 			return "", err
 		}
-
-		title := formatter.BoldStyle.Render(fmt.Sprintf("%s release notes:", version))
-		withTitle := fmt.Sprintf("%s\n%s\n", title, releaseNotes)
-
+		withTitle := fmt.Sprintf("%s release notes:\n%s", version, string(releaseNotes))
 		return withTitle, nil
 	}
 

pkg/recipe/git.go

@@ -3,66 +3,52 @@ package recipe
 import (
 	"fmt"
 	"os"
-	"slices"
-	"sort"
+	"path"
 	"strings"
 
+	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/log"
-	"coopcloud.tech/tagcmp"
 	"github.com/distribution/reference"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
 )
 
-type EnsureContext struct {
-	Chaos            bool
-	Offline          bool
-	IgnoreEnvVersion bool
-}
-
-// Ensure makes sure the recipe exists, is up to date and has the specific
-// version checked out.
-func (r Recipe) Ensure(ctx EnsureContext) error {
+// Ensure makes sure the recipe exists, is up to date and has the latest version checked out.
+func (r Recipe) Ensure(chaos bool, offline bool) error {
 	if err := r.EnsureExists(); err != nil {
 		return err
 	}
 
-	if ctx.Chaos {
+	if chaos {
 		return nil
 	}
 
 	if err := r.EnsureIsClean(); err != nil {
 		return err
 	}
-
-	if !ctx.Offline {
+	if !offline {
 		if err := r.EnsureUpToDate(); err != nil {
 			log.Fatal(err)
 		}
 	}
-
-	if r.EnvVersion != "" && !ctx.IgnoreEnvVersion {
-		log.Debugf("ensuring env version %s", r.EnvVersion)
-
-		if _, err := r.EnsureVersion(r.EnvVersion); err != nil {
+	if r.Version != "" {
+		if _, err := r.EnsureVersion(r.Version); err != nil {
 			return err
 		}
-
-		return nil
-	}
-
+	} else {
 		if err := r.EnsureLatest(); err != nil {
 			return err
 		}
-
+	}
 	return nil
 }
 
 // EnsureExists ensures that the recipe is locally cloned
 func (r Recipe) EnsureExists() error {
 	if _, err := os.Stat(r.Dir); os.IsNotExist(err) {
+		log.Debugf("%s does not exist, attemmpting to clone", r.Dir)
 		if err := gitPkg.Clone(r.Dir, r.GitURL); err != nil {
 			return err
 		}
@@ -75,41 +61,6 @@ func (r Recipe) EnsureExists() error {
 	return nil
 }
 
-// IsChaosCommit determines if a version sttring is a chaos commit or not.
-func (r Recipe) IsChaosCommit(version string) (bool, error) {
-	isChaosCommit := false
-
-	if err := gitPkg.EnsureGitRepo(r.Dir); err != nil {
-		return isChaosCommit, err
-	}
-
-	repo, err := git.PlainOpen(r.Dir)
-	if err != nil {
-		return isChaosCommit, err
-	}
-
-	tags, err := repo.Tags()
-	if err != nil {
-		return isChaosCommit, err
-	}
-
-	var tagRef plumbing.ReferenceName
-	if err := tags.ForEach(func(ref *plumbing.Reference) (err error) {
-		if ref.Name().Short() == version {
-			tagRef = ref.Name()
-		}
-		return nil
-	}); err != nil {
-		return isChaosCommit, err
-	}
-
-	if tagRef.String() == "" {
-		isChaosCommit = true
-	}
-
-	return isChaosCommit, nil
-}
-
 // EnsureVersion checks whether a specific version exists for a recipe.
 func (r Recipe) EnsureVersion(version string) (bool, error) {
 	isChaosCommit := false
@@ -182,7 +133,8 @@ func (r Recipe) EnsureIsClean() error {
 	}
 
 	if !isClean {
-		return fmt.Errorf("%s (%s) has locally unstaged changes?", r.Name, r.Dir)
+		msg := "%s (%s) has locally unstaged changes? please commit/remove your changes before proceeding"
+		return fmt.Errorf(msg, r.Name, r.Dir)
 	}
 
 	return nil
@@ -190,11 +142,13 @@ func (r Recipe) EnsureIsClean() error {
 
 // EnsureLatest makes sure the latest commit is checked out for the local recipe repository
 func (r Recipe) EnsureLatest() error {
-	if err := gitPkg.EnsureGitRepo(r.Dir); err != nil {
+	recipeDir := path.Join(config.RECIPES_DIR, r.Name)
+
+	if err := gitPkg.EnsureGitRepo(recipeDir); err != nil {
 		return err
 	}
 
-	repo, err := git.PlainOpen(r.Dir)
+	repo, err := git.PlainOpen(recipeDir)
 	if err != nil {
 		return err
 	}
@@ -204,7 +158,7 @@ func (r Recipe) EnsureLatest() error {
 		return err
 	}
 
-	branch, err := gitPkg.GetDefaultBranch(repo, r.Dir)
+	branch, err := gitPkg.GetDefaultBranch(repo, recipeDir)
 	if err != nil {
 		return err
 	}
@@ -216,7 +170,7 @@ func (r Recipe) EnsureLatest() error {
 	}
 
 	if err := worktree.Checkout(checkOutOpts); err != nil {
-		log.Debugf("failed to check out %s in %s", branch, r.Dir)
+		log.Debugf("failed to check out %s in %s", branch, recipeDir)
 		return err
 	}
 
@@ -225,14 +179,16 @@ func (r Recipe) EnsureLatest() error {
 
 // EnsureUpToDate ensures that the local repo is synced to the remote
 func (r Recipe) EnsureUpToDate() error {
-	repo, err := git.PlainOpen(r.Dir)
+	recipeDir := path.Join(config.RECIPES_DIR, r.Name)
+
+	repo, err := git.PlainOpen(recipeDir)
 	if err != nil {
-		return fmt.Errorf("unable to open %s: %s", r.Dir, err)
+		return fmt.Errorf("unable to open %s: %s", recipeDir, err)
 	}
 
 	remotes, err := repo.Remotes()
 	if err != nil {
-		return fmt.Errorf("unable to read remotes in %s: %s", r.Dir, err)
+		return fmt.Errorf("unable to read remotes in %s: %s", recipeDir, err)
 	}
 
 	if len(remotes) == 0 {
@@ -242,18 +198,18 @@ func (r Recipe) EnsureUpToDate() error {
 
 	worktree, err := repo.Worktree()
 	if err != nil {
-		return fmt.Errorf("unable to open git work tree in %s: %s", r.Dir, err)
+		return fmt.Errorf("unable to open git work tree in %s: %s", recipeDir, err)
 	}
 
-	branch, err := gitPkg.CheckoutDefaultBranch(repo, r.Dir)
+	branch, err := gitPkg.CheckoutDefaultBranch(repo, recipeDir)
 	if err != nil {
-		return fmt.Errorf("unable to check out default branch in %s: %s", r.Dir, err)
+		return fmt.Errorf("unable to check out default branch in %s: %s", recipeDir, err)
 	}
 
 	fetchOpts := &git.FetchOptions{Tags: git.AllTags}
 	if err := repo.Fetch(fetchOpts); err != nil {
 		if !strings.Contains(err.Error(), "already up-to-date") {
-			return fmt.Errorf("unable to fetch tags in %s: %s", r.Dir, err)
+			return fmt.Errorf("unable to fetch tags in %s: %s", recipeDir, err)
 		}
 	}
 
@@ -265,7 +221,7 @@ func (r Recipe) EnsureUpToDate() error {
 
 	if err := worktree.Pull(opts); err != nil {
 		if !strings.Contains(err.Error(), "already up-to-date") {
-			return fmt.Errorf("unable to git pull in %s: %s", r.Dir, err)
+			return fmt.Errorf("unable to git pull in %s: %s", recipeDir, err)
 		}
 	}
 
@@ -274,36 +230,27 @@ func (r Recipe) EnsureUpToDate() error {
 	return nil
 }
 
-// IsDirty checks whether a recipe is dirty or not. N.B., if you call IsDirty
-// from another Recipe method, you should propagate the pointer reference (*).
-func (r *Recipe) IsDirty() error {
-	isClean, err := gitPkg.IsClean(r.Dir)
-	if err != nil {
-		return err
-	}
-
-	if !isClean {
-		r.Dirty = true
-	}
-
-	return nil
-}
-
 // ChaosVersion constructs a chaos mode recipe version.
-func (r *Recipe) ChaosVersion() (string, error) {
+func (r Recipe) ChaosVersion() (string, error) {
 	var version string
 
-	head, err := r.Head()
+	head, err := gitPkg.GetRecipeHead(r.Name)
 	if err != nil {
 		return version, err
 	}
 
 	version = formatter.SmallSHA(head.String())
 
-	if err := r.IsDirty(); err != nil {
+	recipeDir := path.Join(config.RECIPES_DIR, r.Name)
+	isClean, err := gitPkg.IsClean(recipeDir)
+	if err != nil {
 		return version, err
 	}
 
+	if !isClean {
+		version = fmt.Sprintf("%s + unstaged changes", version)
+	}
+
 	return version, nil
 }
 
@@ -347,44 +294,29 @@ func (r Recipe) Tags() ([]string, error) {
 		return tags, err
 	}
 
-	sort.Slice(tags, func(i, j int) bool {
-		version1, err := tagcmp.Parse(tags[i])
-		if err != nil {
-			return false
-		}
-		version2, err := tagcmp.Parse(tags[j])
-		if err != nil {
-			return false
-		}
-		return version1.IsLessThan(version2)
-	})
-
 	log.Debugf("detected %s as tags for recipe %s", strings.Join(tags, ", "), r.Name)
 
 	return tags, nil
 }
 
 // GetRecipeVersions retrieves all recipe versions.
-func (r Recipe) GetRecipeVersions() (RecipeVersions, []string, error) {
-	var warnMsg []string
-
+func (r Recipe) GetRecipeVersions() (RecipeVersions, error) {
 	versions := RecipeVersions{}
-
-	log.Debugf("git: opening repository in %s", r.Dir)
+	log.Debugf("attempting to open git repository in %s", r.Dir)
 
 	repo, err := git.PlainOpen(r.Dir)
 	if err != nil {
-		return versions, warnMsg, nil
+		return versions, err
 	}
 
 	worktree, err := repo.Worktree()
 	if err != nil {
-		return versions, warnMsg, nil
+		return versions, err
 	}
 
 	gitTags, err := repo.Tags()
 	if err != nil {
-		return versions, warnMsg, nil
+		return versions, err
 	}
 
 	if err := gitTags.ForEach(func(ref *plumbing.Reference) (err error) {
@@ -402,7 +334,7 @@ func (r Recipe) GetRecipeVersions() (RecipeVersions, []string, error) {
 			return err
 		}
 
-		log.Debugf("git checkout: %s in %s", ref.Name(), r.Dir)
+		log.Debugf("successfully checked out %s in %s", ref.Name(), r.Dir)
 
 		config, err := r.GetComposeConfig(nil)
 		if err != nil {
@@ -426,7 +358,7 @@ func (r Recipe) GetRecipeVersions() (RecipeVersions, []string, error) {
 			case reference.NamedTagged:
 				tag = img.(reference.NamedTagged).Tag()
 			case reference.Named:
-				warnMsg = append(warnMsg, fmt.Sprintf("%s service is missing image tag?", path))
+				log.Warnf("%s service is missing image tag?", path)
 				continue
 			}
 
@@ -440,39 +372,17 @@ func (r Recipe) GetRecipeVersions() (RecipeVersions, []string, error) {
 
 		return nil
 	}); err != nil {
-		return versions, warnMsg, nil
+		return versions, err
 	}
 
 	_, err = gitPkg.CheckoutDefaultBranch(repo, r.Dir)
 	if err != nil {
-		return versions, warnMsg, nil
+		return versions, err
 	}
 
 	sortRecipeVersions(versions)
 
 	log.Debugf("collected %s for %s", versions, r.Dir)
 
-	var uniqueWarnings []string
-	for _, w := range warnMsg {
-		if !slices.Contains(uniqueWarnings, w) {
-			uniqueWarnings = append(uniqueWarnings, w)
-		}
-	}
-
-	return versions, uniqueWarnings, nil
-}
-
-// Head retrieves latest HEAD metadata.
-func (r Recipe) Head() (*plumbing.Reference, error) {
-	repo, err := git.PlainOpen(r.Dir)
-	if err != nil {
-		return nil, err
-	}
-
-	head, err := repo.Head()
-	if err != nil {
-		return nil, err
-	}
-
-	return head, nil
+	return versions, nil
 }

pkg/recipe/git_test.go

@@ -1,39 +0,0 @@
-package recipe
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestIsDirty(t *testing.T) {
-	r := Get("abra-test-recipe")
-
-	if err := r.EnsureExists(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := r.IsDirty(); err != nil {
-		t.Fatal(err)
-	}
-
-	assert.False(t, r.Dirty)
-
-	fpath := filepath.Join(r.Dir, "foo.txt")
-	f, err := os.Create(fpath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-	defer t.Cleanup(func() {
-		os.Remove(fpath)
-	})
-
-	if err := r.IsDirty(); err != nil {
-		t.Fatal(err)
-	}
-
-	assert.True(t, r.Dirty)
-}

pkg/recipe/recipe.go

@@ -2,12 +2,12 @@ package recipe
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/url"
 	"os"
 	"path"
+	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -20,7 +20,6 @@ import (
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/web"
 	"coopcloud.tech/tagcmp"
-	"github.com/go-git/go-git/v5"
 )
 
 // RecipeCatalogueURL is the only current recipe catalogue available.
@@ -58,6 +57,11 @@ type RecipeMeta struct {
 	Website       string         `json:"website"`
 }
 
+// TopicMeta represents a list of topics for a repository.
+type TopicMeta struct {
+	Topics []string `json:"topics"`
+}
+
 // LatestVersion returns the latest version of a recipe.
 func (r RecipeMeta) LatestVersion() string {
 	var version string
@@ -119,38 +123,16 @@ type Features struct {
 	SSO         string `json:"sso"`
 }
 
-func GetEnvVersionRaw(name string) (string, error) {
-	var version string
-
-	if strings.Contains(name, ":") {
-		split := strings.Split(name, ":")
-		if len(split) > 2 {
-			return version, fmt.Errorf("version seems invalid: %s", name)
-		}
-		version = split[1]
-	}
-
-	return version, nil
-}
-
 func Get(name string) Recipe {
 	version := ""
 	if strings.Contains(name, ":") {
 		split := strings.Split(name, ":")
-		if len(split) > 2 {
-			log.Fatalf("version seems invalid: %s", name)
-		}
 		name = split[0]
-
 		version = split[1]
-		if strings.HasSuffix(version, config.DIRTY_DEFAULT) {
-			version = strings.Replace(split[1], config.DIRTY_DEFAULT, "", 1)
-			log.Debugf("removed dirty suffix from .env version: %s -> %s", split[1], version)
-		}
 	}
 
 	gitURL := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, name)
-	sshURL := fmt.Sprintf(config.RECIPES_SSH_URL_TEMPLATE, name)
+	sshURL := fmt.Sprintf(config.SSH_URL_TEMPLATE, name)
 	if strings.Contains(name, "/") {
 		u, err := url.Parse(name)
 		if err != nil {
@@ -166,9 +148,9 @@ func Get(name string) Recipe {
 
 	dir := path.Join(config.RECIPES_DIR, escapeRecipeName(name))
 
-	r := Recipe{
+	return Recipe{
 		Name:    name,
-		EnvVersion: version,
+		Version: version,
 		Dir:     dir,
 		GitURL:  gitURL,
 		SSHURL:  sshURL,
@@ -178,18 +160,11 @@ func Get(name string) Recipe {
 		SampleEnvPath: path.Join(dir, ".env.sample"),
 		AbraShPath:    path.Join(dir, "abra.sh"),
 	}
-
-	if err := r.IsDirty(); err != nil && !errors.Is(err, git.ErrRepositoryNotExists) {
-		log.Fatalf("failed to check git status of %s: %s", r.Name, err)
-	}
-
-	return r
 }
 
 type Recipe struct {
 	Name    string
-	EnvVersion string
-	Dirty      bool // NOTE(d1): git terminology for unstaged changes
+	Version string
 	Dir     string
 	GitURL  string
 	SSHURL  string
@@ -200,21 +175,6 @@ type Recipe struct {
 	AbraShPath    string
 }
 
-// String outputs a human-friendly string representation.
-func (r Recipe) String() string {
-	out := fmt.Sprintf("{name: %s, ", r.Name)
-	out += fmt.Sprintf("version : %s, ", r.EnvVersion)
-	out += fmt.Sprintf("dirty: %v, ", r.Dirty)
-	out += fmt.Sprintf("dir: %s, ", r.Dir)
-	out += fmt.Sprintf("git url: %s, ", r.GitURL)
-	out += fmt.Sprintf("ssh url: %s, ", r.SSHURL)
-	out += fmt.Sprintf("compose: %s, ", r.ComposePath)
-	out += fmt.Sprintf("readme: %s, ", r.ReadmePath)
-	out += fmt.Sprintf("sample env: %s, ", r.SampleEnvPath)
-	out += fmt.Sprintf("abra.sh: %s}", r.AbraShPath)
-	return out
-}
-
 func escapeRecipeName(recipeName string) string {
 	recipeName = strings.ReplaceAll(recipeName, "/", "_")
 	recipeName = strings.ReplaceAll(recipeName, ".", "_")
@@ -233,18 +193,16 @@ func GetRecipesLocal() ([]string, error) {
 	return recipes, nil
 }
 
-func GetRecipeFeaturesAndCategory(r Recipe) (Features, string, []string, error) {
-	var (
-		category string
-		warnMsgs []string
-		feat     = Features{}
-	)
+func GetRecipeFeaturesAndCategory(r Recipe) (Features, string, error) {
+	feat := Features{}
 
-	log.Debugf("%s: attempt recipe metadata parse", r.ReadmePath)
+	var category string
+
+	log.Debugf("attempting to open %s for recipe metadata parsing", r.ReadmePath)
 
 	readmeFS, err := ioutil.ReadFile(r.ReadmePath)
 	if err != nil {
-		return feat, category, warnMsgs, err
+		return feat, category, err
 	}
 
 	readmeMetadata, err := GetStringInBetween( // Find text between delimiters
@@ -253,7 +211,7 @@ func GetRecipeFeaturesAndCategory(r Recipe) (Features, string, []string, error)
 		"<!-- metadata -->", "<!-- endmetadata -->",
 	)
 	if err != nil {
-		return feat, category, warnMsgs, err
+		return feat, category, err
 	}
 
 	readmeLines := strings.Split( // Array item from lines
@@ -297,25 +255,20 @@ func GetRecipeFeaturesAndCategory(r Recipe) (Features, string, []string, error)
 			)
 		}
 		if strings.Contains(val, "**Image**") {
-			imageMetadata, warnings, err := GetImageMetadata(strings.TrimSpace(
+			imageMetadata, err := GetImageMetadata(strings.TrimSpace(
 				strings.TrimPrefix(val, "* **Image**:"),
 			), r.Name)
 			if err != nil {
 				continue
 			}
-			if len(warnings) > 0 {
-				warnMsgs = append(warnMsgs, warnings...)
-			}
 			feat.Image = imageMetadata
 		}
 	}
 
-	return feat, category, warnMsgs, nil
+	return feat, category, nil
 }
 
-func GetImageMetadata(imageRowString, recipeName string) (Image, []string, error) {
-	var warnMsgs []string
-
+func GetImageMetadata(imageRowString, recipeName string) (Image, error) {
 	img := Image{}
 
 	imgFields := strings.Split(imageRowString, ",")
@@ -326,18 +279,11 @@ func GetImageMetadata(imageRowString, recipeName string) (Image, []string, error
 
 	if len(imgFields) < 3 {
 		if imageRowString != "" {
-			warnMsgs = append(
-				warnMsgs,
-				fmt.Sprintf("%s: image meta has incorrect format: %s", recipeName, imageRowString),
-			)
+			log.Warnf("%s image meta has incorrect format: %s", recipeName, imageRowString)
 		} else {
-			warnMsgs = append(
-				warnMsgs,
-				fmt.Sprintf("%s: image meta is empty?", recipeName),
-			)
+			log.Warnf("%s image meta is empty?", recipeName)
 		}
-
-		return img, warnMsgs, nil
+		return img, nil
 	}
 
 	img.Rating = imgFields[1]
@@ -347,17 +293,17 @@ func GetImageMetadata(imageRowString, recipeName string) (Image, []string, error
 
 	imageName, err := GetStringInBetween(recipeName, imgString, "[", "]")
 	if err != nil {
-		return img, warnMsgs, err
+		log.Fatal(err)
 	}
 	img.Image = strings.ReplaceAll(imageName, "`", "")
 
 	imageURL, err := GetStringInBetween(recipeName, imgString, "(", ")")
 	if err != nil {
-		return img, warnMsgs, err
+		log.Fatal(err)
 	}
 	img.URL = imageURL
 
-	return img, warnMsgs, nil
+	return img, nil
 }
 
 // GetStringInBetween returns empty string if no start or end string found
@@ -548,11 +494,11 @@ type InternalTracker struct {
 type RepoCatalogue map[string]RepoMeta
 
 // ReadReposMetadata retrieves coop-cloud/... repo metadata from Gitea.
-func ReadReposMetadata(debug bool) (RepoCatalogue, error) {
+func ReadReposMetadata() (RepoCatalogue, error) {
 	reposMeta := make(RepoCatalogue)
 
 	pageIdx := 1
-	bar := formatter.CreateProgressbar(-1, "collecting recipe listing")
+	bar := formatter.CreateProgressbar(-1, "retrieving recipe repos list from git.coopcloud.tech...")
 	for {
 		var reposList []RepoMeta
 
@@ -565,32 +511,28 @@ func ReadReposMetadata(debug bool) (RepoCatalogue, error) {
 		}
 
 		if len(reposList) == 0 {
-			if !debug {
 			bar.Add(1)
-			}
 			break
 		}
 
 		for idx, repo := range reposList {
-			// NOTE(d1): the "example" recipe is a temporary special case
-			// https://git.coopcloud.tech/toolshed/organising/issues/666
-			if repo.Name == "example" {
-				continue
+			var topicMeta TopicMeta
+
+			topicsURL := getReposTopicUrl(repo.Name)
+			if err := web.ReadJSON(topicsURL, &topicMeta); err != nil {
+				return reposMeta, err
 			}
 
+			if slices.Contains(topicMeta.Topics, "recipe") && repo.Name != "example" {
 				reposMeta[repo.Name] = reposList[idx]
 			}
+		}
 
 		pageIdx++
-
-		if !debug {
 		bar.Add(1)
 	}
-	}
 
-	if err := bar.Close(); err != nil {
-		return reposMeta, err
-	}
+	fmt.Println() // newline for spinner
 
 	return reposMeta, nil
 }
@@ -652,7 +594,7 @@ func GetRecipeCatalogueVersions(recipeName string, catl RecipeCatalogue) ([]stri
 }
 
 // UpdateRepositories clones and updates all recipe repositories locally.
-func UpdateRepositories(repos RepoCatalogue, recipeName string, debug bool) error {
+func UpdateRepositories(repos RepoCatalogue, recipeName string) error {
 	var barLength int
 	if recipeName != "" {
 		barLength = 1
@@ -660,9 +602,9 @@ func UpdateRepositories(repos RepoCatalogue, recipeName string, debug bool) erro
 		barLength = len(repos)
 	}
 
-	cloneLimiter := limit.New(3)
+	cloneLimiter := limit.New(10)
 
-	retrieveBar := formatter.CreateProgressbar(barLength, "retrieving recipes")
+	retrieveBar := formatter.CreateProgressbar(barLength, "ensuring recipes are cloned & up-to-date...")
 	ch := make(chan string, barLength)
 	for _, repoMeta := range repos {
 		go func(rm RepoMeta) {
@@ -671,9 +613,7 @@ func UpdateRepositories(repos RepoCatalogue, recipeName string, debug bool) erro
 
 			if recipeName != "" && recipeName != rm.Name {
 				ch <- rm.Name
-				if !debug {
 				retrieveBar.Add(1)
-				}
 				return
 			}
 
@@ -682,9 +622,7 @@ func UpdateRepositories(repos RepoCatalogue, recipeName string, debug bool) erro
 			}
 
 			ch <- rm.Name
-			if !debug {
 			retrieveBar.Add(1)
-			}
 		}(repoMeta)
 	}
 
@@ -692,11 +630,12 @@ func UpdateRepositories(repos RepoCatalogue, recipeName string, debug bool) erro
 		<-ch // wait for everything
 	}
 
-	if err := retrieveBar.Close(); err != nil {
-		return err
+	return nil
 }
 
-	return nil
+// getReposTopicUrl retrieves the repository specific topic listing.
+func getReposTopicUrl(repoName string) string {
+	return fmt.Sprintf("https://git.coopcloud.tech/api/v1/repos/coop-cloud/%s/topics", repoName)
 }
 
 // ensurePathExists ensures that a path exists.

pkg/recipe/recipe_test.go

@@ -33,7 +33,7 @@ func TestGet(t *testing.T) {
 			name: "foo:1.2.3",
 			recipe: Recipe{
 				Name:          "foo",
-				EnvVersion:    "1.2.3",
+				Version:       "1.2.3",
 				Dir:           path.Join(cfg.GetAbraDir(), "/recipes/foo"),
 				GitURL:        "https://git.coopcloud.tech/coop-cloud/foo.git",
 				SSHURL:        "ssh://git@git.coopcloud.tech:2222/coop-cloud/foo.git",
@@ -60,7 +60,7 @@ func TestGet(t *testing.T) {
 			name: "mygit.org/myorg/cool-recipe:1.2.4",
 			recipe: Recipe{
 				Name:          "mygit.org/myorg/cool-recipe",
-				EnvVersion:    "1.2.4",
+				Version:       "1.2.4",
 				Dir:           path.Join(cfg.GetAbraDir(), "/recipes/mygit_org_myorg_cool-recipe"),
 				GitURL:        "https://mygit.org/myorg/cool-recipe.git",
 				SSHURL:        "ssh://git@mygit.org/myorg/cool-recipe.git",
@@ -105,16 +105,3 @@ func TestGetVersionLabelLocalDoesNotUseTimeoutLabel(t *testing.T) {
 		assert.NotEqual(t, label, defaultTimeoutLabel)
 	}
 }
-
-func TestDirtyMarkerRemoved(t *testing.T) {
-	r := Get("abra-test-recipe:1e83340e+U")
-	assert.Equal(t, "1e83340e", r.EnvVersion)
-}
-
-func TestGetEnvVersionRaw(t *testing.T) {
-	v, err := GetEnvVersionRaw("abra-test-recipe:1e83340e+U")
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, "1e83340e+U", v)
-}

pkg/secret/secret.go

@@ -181,7 +181,7 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server
 
 				if err := client.StoreSecret(cl, secret.RemoteName, passwords[0], server); err != nil {
 					if strings.Contains(err.Error(), "AlreadyExists") {
-						log.Warnf("%s already exists", secret.RemoteName)
+						log.Warnf("%s already exists, moving on...", secret.RemoteName)
 						ch <- nil
 					} else {
 						ch <- err
@@ -201,7 +201,7 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server
 
 				if err := client.StoreSecret(cl, secret.RemoteName, passphrases[0], server); err != nil {
 					if strings.Contains(err.Error(), "AlreadyExists") {
-						log.Warnf("%s already exists", secret.RemoteName)
+						log.Warnf("%s already exists, moving on...", secret.RemoteName)
 						ch <- nil
 					} else {
 						ch <- err

pkg/test/test.go

@@ -29,7 +29,6 @@ var (
 var ExpectedAppEnv = envfile.AppEnv{
 	"DOMAIN": "ecloud.evil.corp",
 	"RECIPE": "ecloud",
-	"SMTP_AUTHTYPE": "login",
 }
 
 var ExpectedApp = appPkg.App{

pkg/upstream/stack/stack.go

@@ -13,7 +13,6 @@ import (
 
 	stdlibErr "errors"
 
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/convert"
 	"github.com/docker/cli/cli/command/service/progress"
@@ -107,22 +106,13 @@ type DeployMeta struct {
 	ChaosVersion string // the --chaos deployment version
 }
 
-func (d DeployMeta) String() string {
-	var out string
-	out += fmt.Sprintf("{isDeployed: %v, ", d.IsDeployed)
-	out += fmt.Sprintf("version: %s, ", d.Version)
-	out += fmt.Sprintf("isChaos: %v, ", d.IsChaos)
-	out += fmt.Sprintf("chaosVersion: %s}", d.ChaosVersion)
-	return out
-}
-
 // IsDeployed gathers metadata about an app deployment.
 func IsDeployed(ctx context.Context, cl *dockerClient.Client, stackName string) (DeployMeta, error) {
 	deployMeta := DeployMeta{
 		IsDeployed:   false,
 		Version:      "unknown",
 		IsChaos:      false,
-		ChaosVersion: config.CHAOS_DEFAULT,
+		ChaosVersion: "false", // NOTE(d1): match string type used on label
 	}
 
 	filter := filters.NewArgs()
@@ -185,7 +175,6 @@ func pruneServices(ctx context.Context, cl *dockerClient.Client, namespace conve
 			pruneServices = append(pruneServices, service)
 		}
 	}
-
 	removeServices(ctx, cl, pruneServices)
 }
 
@@ -266,11 +255,9 @@ func deployCompose(ctx context.Context, cl *dockerClient.Client, opts Deploy, co
 
 	log.Infof("waiting for %s to deploy... please hold 🤚", appName)
 
-	if err := waitOnServices(ctx, cl, serviceIDs, appName); err != nil {
-		return err
-	}
-
+	if err := waitOnServices(ctx, cl, serviceIDs, appName); err == nil {
 		log.Infof("successfully deployed %s", appName)
+	}
 
 	return nil
 }
@@ -408,7 +395,7 @@ func deployServices(
 		)
 
 		if service, exists := existingServiceMap[name]; exists {
-			log.Infof("updating %s", name)
+			log.Infof("updating service %s (id: %s)", name, service.ID)
 
 			updateOpts := types.ServiceUpdateOptions{EncodedRegistryAuth: encodedAuth}
 
@@ -443,7 +430,7 @@ func deployServices(
 
 			response, err := cl.ServiceUpdate(ctx, service.ID, service.Version, serviceSpec, updateOpts)
 			if err != nil {
-				return nil, errors.Wrapf(err, "failed to update %s", name)
+				return nil, errors.Wrapf(err, "failed to update service %s", name)
 			}
 
 			for _, warning := range response.Warnings {
@@ -452,7 +439,7 @@ func deployServices(
 
 			serviceIDs = append(serviceIDs, service.ID)
 		} else {
-			log.Infof("creating %s", name)
+			log.Infof("creating service %s", name)
 
 			createOpts := types.ServiceCreateOptions{EncodedRegistryAuth: encodedAuth}
 
@@ -463,7 +450,7 @@ func deployServices(
 
 			serviceCreateResponse, err := cl.ServiceCreate(ctx, serviceSpec, createOpts)
 			if err != nil {
-				return nil, errors.Wrapf(err, "failed to create %s", name)
+				return nil, errors.Wrapf(err, "failed to create service %s", name)
 			}
 
 			serviceIDs = append(serviceIDs, serviceCreateResponse.ID)
@@ -523,14 +510,13 @@ func WaitOnService(ctx context.Context, cl *dockerClient.Client, serviceID, appN
 	case err := <-errChan:
 		return err
 	case <-sigintChannel:
-		return fmt.Errorf(`
+		return fmt.Errorf(fmt.Sprintf(`
 Not waiting for %s to deploy. The deployment is ongoing...
 
 If you want to stop the deployment, try:
-
-    abra app undeploy %s`, appName, appName)
+  abra app undeploy %s`, appName, appName))
 	case <-time.After(timeout):
-		return fmt.Errorf(`
+		return fmt.Errorf(fmt.Sprintf(`
 %s has not converged (%s second timeout reached).
 
 This does not necessarily mean your deployment has failed, it may just be that
@@ -544,7 +530,7 @@ You can track latest deployment status with:
 And inspect the logs with:
 
     abra app logs %s
-`, appName, timeout, appName, appName)
+`, appName, timeout, appName, appName))
 	}
 }
 
@@ -562,7 +548,7 @@ func GetStacks(cl *dockerClient.Client) ([]*formatter.Stack, error) {
 		labels := service.Spec.Labels
 		name, ok := labels[convert.LabelNamespace]
 		if !ok {
-			return nil, errors.Errorf("cannot get label %s for %s",
+			return nil, errors.Errorf("cannot get label %s for service %s",
 				convert.LabelNamespace, service.ID)
 		}
 		ztack, ok := m[name]

scripts/installer/installer

@@ -1,9 +1,9 @@
 #!/usr/bin/env bash
 
 ABRA_VERSION="0.9.0-beta"
-ABRA_RELEASE_URL="https://git.coopcloud.tech/api/v1/repos/toolshed/abra/releases/tags/$ABRA_VERSION"
-RC_VERSION="0.10.0-rc1-beta"
-RC_VERSION_URL="https://git.coopcloud.tech/api/v1/repos/toolshed/abra/releases/tags/$RC_VERSION"
+ABRA_RELEASE_URL="https://git.coopcloud.tech/api/v1/repos/coop-cloud/abra/releases/tags/$ABRA_VERSION"
+RC_VERSION="0.8.0-rc1-beta"
+RC_VERSION_URL="https://git.coopcloud.tech/api/v1/repos/coop-cloud/abra/releases/tags/$RC_VERSION"
 
 for arg in "$@"; do
   if [ "$arg" == "--rc" ]; then
@@ -40,7 +40,7 @@ function install_abra_release {
   if ! type "wget" > /dev/null 2>&1; then
     echo "'wget' is not installed, cannot proceed..."
     echo "perhaps try installing manually via the releases URL?"
-    echo "https://git.coopcloud.tech/toolshed/abra/releases"
+    echo "https://git.coopcloud.tech/coop-cloud/abra/releases"
     exit 1
   fi
 
@@ -87,7 +87,7 @@ function install_abra_release {
 
   x=$(echo $PATH | grep $HOME/.local/bin)
   if [ $? -ne 0 ]; then
-      echo "$(tput setaf 3)WARNING: $HOME/.local/bin/ is not in \$PATH! If you want to run abra by just typing "abra" you should add it to your \$PATH! To do that run this once and restart your terminal:$(tput sgr0)"
+      echo "$(tput setaf 3)WARNING: $HOME/.local/bin/ is not in \$PATH! If you want to run abra by just typing "abra" you should add it to your \$PATH! To do that run:$(tput sgr0)"
       p=$HOME/.local/bin
       com="echo PATH=\$PATH:$p"
       if [[ $SHELL =~ "bash" ]]; then

scripts/tests/run-ci-int

@@ -7,9 +7,10 @@
 # destroys resources on the swarm server you run it against. This is for
 # setup/teardown for the integration test suite.
 #
+# export DRONE_SOURCE_BRANCH=<your-branch-name>
 # ./run-ci-int
 
-set -eu
+set +e
 
 echo "========================================================================"
 echo "WIPING DOCKER RESOURCES FOR A CLEAN SLATE"
@@ -42,9 +43,19 @@ echo "========================================================================"
 echo "CLONING ABRA"
 echo "========================================================================"
 rm -rf abra
-git clone ssh://git@git.coopcloud.tech:2222/toolshed/abra.git
+git clone ssh://git@git.coopcloud.tech:2222/coop-cloud/abra.git
 cd abra
-git checkout main
+echo "========================================================================"
+
+echo "========================================================================"
+echo "FETCHING ABRA BRANCH FOR TESTING"
+echo "========================================================================"
+if [ -z "$DRONE_SOURCE_BRANCH" ]; then
+	DRONE_SOURCE_BRANCH="main"
+fi
+
+git fetch --all
+git checkout $DRONE_SOURCE_BRANCH
 echo "========================================================================"
 
 echo "========================================================================"
@@ -72,7 +83,6 @@ echo "========================================================================"
 export ABRA_DIR="$HOME/.abra_test"
 export TERM=xterm
 export TEST_SERVER=default
-export ABRA_CI=1
 
 rm -rf "$ABRA_DIR"
 bats -Tp tests/integration --filter-tags \!dns --print-output-on-failure

tests/integration/app_backup.bats

@@ -0,0 +1,188 @@
+#!/usr/bin/env bash
+
+setup_file() {
+  load "$PWD/tests/integration/helpers/common"
+  _common_setup
+  _add_server
+  _new_app
+}
+
+teardown_file() {
+  _rm_app
+  _rm_server
+  _reset_recipe
+}
+
+setup() {
+  load "$PWD/tests/integration/helpers/common"
+  _common_setup
+}
+
+teardown(){
+  _undeploy_app
+}
+
+@test "retrieve recipe if missing" {
+  skip "https://git.coopcloud.tech/coop-cloud/organising/issues/583"
+
+  assert_exists "$ABRA_DIR/recipes/$TEST_RECIPE"
+
+  run rm -rf "$ABRA_DIR/recipes/$TEST_RECIPE"
+  assert_success
+  assert_not_exists "$ABRA_DIR/recipes/$TEST_RECIPE"
+
+  run $ABRA app backup "$TEST_APP_DOMAIN"
+  assert_failure
+  assert_output --partial 'no containers matching'
+  assert_exists "$ABRA_DIR/recipes/$TEST_RECIPE"
+}
+
+@test "bail if unstaged changes and no --chaos" {
+  skip "https://git.coopcloud.tech/coop-cloud/organising/issues/583"
+
+  run bash -c "echo foo >> $ABRA_DIR/recipes/$TEST_RECIPE/foo"
+  assert_success
+  assert_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" status
+  assert_success
+  assert_output --partial 'foo'
+
+  run $ABRA app backup "$TEST_APP_DOMAIN" app
+  assert_failure
+  assert_output --partial 'locally unstaged changes'
+
+  run rm -rf "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+  assert_not_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+
+  _checkout_recipe
+}
+
+# bats test_tags=slow
+@test "do not bail if unstaged changes and --chaos" {
+  skip "https://git.coopcloud.tech/coop-cloud/organising/issues/583"
+
+  run bash -c 'echo "unstaged changes" >> "$ABRA_DIR/recipes/$TEST_RECIPE/foo"'
+  assert_success
+  assert_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" status
+  assert_success
+  assert_output --partial 'foo'
+
+  run $ABRA app deploy "$TEST_APP_DOMAIN" --chaos --no-input
+  assert_success
+
+  run $ABRA app backup "$TEST_APP_DOMAIN" app --chaos
+  assert_success
+  assert_output --partial 'running backup for the app service'
+
+  _undeploy_app
+
+  run rm -rf "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+  assert_not_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+}
+
+@test "ensure recipe up to date if no --offline" {
+  skip "https://git.coopcloud.tech/coop-cloud/organising/issues/583"
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" reset --hard HEAD~3
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" status
+  assert_output --partial 'behind 3'
+
+  run $ABRA app backup "$TEST_APP_DOMAIN" --debug
+  assert_failure
+  assert_output --partial 'no containers matching'
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" status
+  refute_output --partial 'behind 3'
+
+  _reset_recipe
+}
+
+@test "ensure recipe not up to date if --offline" {
+  skip "https://git.coopcloud.tech/coop-cloud/organising/issues/583"
+
+  latestCommit="$(git -C "$ABRA_DIR/recipes/$TEST_RECIPE" rev-parse --short HEAD)"
+  refute [ -z "$latestCommit" ];
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" reset --hard HEAD~3
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" status
+  assert_output --partial 'behind 3'
+
+  run $ABRA app backup "$TEST_APP_DOMAIN" --debug --offline
+  assert_failure
+  assert_output --partial 'no containers matching'
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" status
+  assert_output --partial 'behind 3'
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" checkout "$latestCommit"
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" status
+  refute_output --partial 'behind 3'
+
+  _reset_recipe
+}
+
+@test "detect backup labels" {
+  skip "https://git.coopcloud.tech/coop-cloud/organising/issues/583"
+
+  run $ABRA app backup "$TEST_APP_DOMAIN" --debug
+  assert_failure
+  assert_output --partial 'no containers matching'
+
+  assert_output --partial 'detected backup paths'
+  assert_output --partial 'detected pre-hook command'
+  assert_output --partial 'detected post-hook command'
+}
+
+@test "error if backups not enabled" {
+  skip "https://git.coopcloud.tech/coop-cloud/organising/issues/583"
+
+  run sed -i '/backupbot.backup=true/d' "$ABRA_DIR/recipes/$TEST_RECIPE/compose.yml"
+  assert_success
+
+  run $ABRA app backup "$TEST_APP_DOMAIN" app --chaos
+  assert_failure
+  assert_output --partial 'no backup config for app'
+
+  _checkout_recipe
+}
+
+@test "error if backup paths not configured" {
+  skip "https://git.coopcloud.tech/coop-cloud/organising/issues/583"
+
+  run sed -i '/backupbot.backup.path=.*/d' "$ABRA_DIR/recipes/$TEST_RECIPE/compose.yml"
+  assert_success
+
+  run $ABRA app backup "$TEST_APP_DOMAIN" app --chaos
+  assert_failure
+  assert_output --partial 'backup paths are empty for app?'
+
+  _checkout_recipe
+}
+
+# bats test_tags=slow
+@test "backup single service" {
+  skip "https://git.coopcloud.tech/coop-cloud/organising/issues/583"
+
+  _deploy_app
+
+  run $ABRA app backup "$TEST_APP_DOMAIN" app
+  assert_success
+  assert_output --partial 'running backup for the app service'
+
+  sanitisedDomainName="${TEST_APP_DOMAIN//./_}"
+  assert_output --partial "_$sanitisedDomainName_app"
+
+  assert_exists "$ABRA_DIR/backups"
+  assert bash -c "ls $ABRA_DIR/backups | grep -q $1_$sanitisedDomainName_app"
+
+  _undeploy_app
+}

tests/integration/app_check.bats

@@ -20,15 +20,16 @@ setup(){
 
 teardown(){
   _reset_recipe
-  _reset_tags
 }
 
 @test "validate app argument" {
   run $ABRA app check
   assert_failure
+  assert_output --partial 'no app provided'
 
   run $ABRA app check DOESNTEXIST
   assert_failure
+  assert_output --partial 'cannot find app'
 }
 
 @test "retrieve recipe if missing" {
@@ -50,9 +51,6 @@ teardown(){
   assert_failure
   assert_output --partial 'locally unstaged changes'
 
-  assert_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
-  assert_equal "$(_git_status)" "?? foo"
-
   run rm -rf "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
   assert_not_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
 }
@@ -65,9 +63,6 @@ teardown(){
   run $ABRA app check "$TEST_APP_DOMAIN" --chaos
   assert_success
 
-  assert_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
-  assert_equal "$(_git_status)" "?? foo"
-
   run rm -rf "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
   assert_not_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
 }
@@ -87,17 +82,19 @@ teardown(){
 }
 
 @test "ensure recipe not up to date if --offline" {
-  _ensure_env_version "0.1.0+1.20.0"
-  latestRelease=$(_latest_release)
+  wantHash=$(_get_n_hash 1)
 
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag -d "$latestRelease"
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" reset --hard HEAD~1
   assert_success
 
-  # NOTE(d1): don't assert success because it might flake
+  assert_equal $(_get_current_hash) "$wantHash"
+
+  # NOTE(d1): we can't quite tell if this will fail or not in the future, so,
+  # since it isn't an important part of what we're testing here, we don't check
+  # it
   run $ABRA app check "$TEST_APP_DOMAIN" --offline
 
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag -l
-  refute_output --partial "$latestRelease"
+  assert_equal $(_get_current_hash) "$wantHash"
 }
 
 @test "error if missing .env.sample" {
@@ -121,20 +118,3 @@ teardown(){
   assert_success
   assert_output --partial '❌'
 }
-
-# bats test_tags=slow
-@test "respects env version" {
-  tagHash=$(_get_tag_hash "0.1.0+1.20.0")
-
-  run $ABRA app deploy "$TEST_APP_DOMAIN" "0.1.0+1.20.0" --no-input --no-converge-checks
-  assert_success
-
-  run grep -q "TYPE=$TEST_RECIPE:0.1.0+1.20.0" \
-    "$ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
-  assert_success
-
-  run $ABRA app check "$TEST_APP_DOMAIN"
-  assert_success
-
-  assert_equal $(_get_current_hash) "$tagHash"
-}