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

See https://build.coopcloud.tech/coop-cloud/abra/2035/1/5

.drone.yml

@@ -10,10 +10,10 @@ steps:
   - name: make test
     image: golang:1.21
     environment:
-      ABRA_DIR: "/root/.abra"
+      CATL_URL: https://git.coopcloud.tech/coop-cloud/recipes-catalogue-json.git
     commands:
-      - make build-abra
+      - mkdir -p $HOME/.abra
-      - ./abra help # show version, initialise $ABRA_DIR
+      - git clone $CATL_URL $HOME/.abra/catalogue
       - make test
     depends_on:
       - make check
@@ -54,11 +54,36 @@ steps:
       tags: dev
       registry: git.coopcloud.tech
     when:
-      event:
+      branch:
-        exclude:
+        - main
-          - pull_request
     depends_on:
       - make check
+      - make test
+
+  - name: integration test
+    image: appleboy/drone-ssh
+    settings:
+      host:
+        - int.coopcloud.tech
+      username: abra
+      key:
+        from_secret: abra_int_private_key
+      port: 22
+      command_timeout: 60m
+      script_stop: true
+      envs: [ DRONE_SOURCE_BRANCH ]
+      request_pty: true
+      script:
+        - |
+          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:
+      event:
+        - cron:
+      cron:
+        # @daily https://docs.drone.io/cron/
+        - integration 
 
 volumes:
   - name: deps

cli/app/app.go

@@ -5,11 +5,10 @@ import (
 )
 
 var AppCommand = cli.Command{
-	Name:        "app",
+	Name:      "app",
-	Aliases:     []string{"a"},
+	Aliases:   []string{"a"},
-	Usage:       "Manage apps",
+	Usage:     "Manage apps",
-	ArgsUsage:   "<domain>",
+	ArgsUsage: "<domain>",
-	Description: "Functionality for managing the life cycle of your apps",
 	Subcommands: []cli.Command{
 		appBackupCommand,
 		appCheckCommand,
@@ -17,7 +16,6 @@ var AppCommand = cli.Command{
 		appConfigCommand,
 		appCpCommand,
 		appDeployCommand,
-		appErrorsCommand,
 		appListCommand,
 		appLogsCommand,
 		appNewCommand,
@@ -31,7 +29,6 @@ var AppCommand = cli.Command{
 		appServicesCommand,
 		appUndeployCommand,
 		appUpgradeCommand,
-		appVersionCommand,
 		appVolumeCommand,
 	},
 }

cli/app/backup.go

@@ -6,8 +6,7 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -47,48 +46,32 @@ var appBackupListCommand = cli.Command{
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
 		if snapshot != "" {
-			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
 			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
 		}
 		if includePath != "" {
-			logrus.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath)
+			log.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath)
 			execEnv = append(execEnv, fmt.Sprintf("INCLUDE_PATH=%s", includePath))
 		}
 
 		if err := internal.RunBackupCmdRemote(cl, "ls", targetContainer.ID, execEnv); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil
@@ -110,54 +93,54 @@ var appBackupDownloadCommand = cli.Command{
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := app.Recipe.EnsureExists(); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !internal.Chaos {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
+			if err := app.Recipe.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
+				if err := app.Recipe.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			}
 
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
+			if err := app.Recipe.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
 		if snapshot != "" {
-			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
 			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
 		}
 		if includePath != "" {
-			logrus.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath)
+			log.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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		remoteBackupDir := "/tmp/backup.tar.gz"
 		currentWorkingDir := "."
 		if err = CopyFromContainer(cl, targetContainer.ID, remoteBackupDir, currentWorkingDir); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		fmt.Println("backup successfully downloaded to current working directory")
@@ -180,44 +163,44 @@ var appBackupCreateCommand = cli.Command{
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := app.Recipe.EnsureExists(); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !internal.Chaos {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
+			if err := app.Recipe.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
+				if err := app.Recipe.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			}
 
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
+			if err := app.Recipe.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
 		if resticRepo != "" {
-			logrus.Debugf("including RESTIC_REPO=%s in backupbot exec invocation", resticRepo)
+			log.Debugf("including RESTIC_REPO=%s in backupbot exec invocation", resticRepo)
 			execEnv = append(execEnv, fmt.Sprintf("RESTIC_REPO=%s", resticRepo))
 		}
 
 		if err := internal.RunBackupCmdRemote(cl, "create", targetContainer.ID, execEnv); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil
@@ -238,44 +221,44 @@ var appBackupSnapshotsCommand = cli.Command{
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := app.Recipe.EnsureExists(); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !internal.Chaos {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
+			if err := app.Recipe.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
+				if err := app.Recipe.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			}
 
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
+			if err := app.Recipe.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
 		if snapshot != "" {
-			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", 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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil

cli/app/check.go

@@ -2,12 +2,10 @@ package app
 
 import (
 	"coopcloud.tech/abra/cli/internal"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -38,32 +36,16 @@ ${FOO:<default>} syntax). "check" does not confirm or deny this for you.`,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := recipePkg.EnsureIsClean(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipePkg.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
 		}
 
 		tableCol := []string{"recipe env sample", "app env"}
 		table := formatter.CreateTable(tableCol)
 
-		envVars, err := config.CheckEnv(app)
+		envVars, err := appPkg.CheckEnv(app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, envVar := range envVars {

cli/app/cmd.go

@@ -5,18 +5,15 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"path"
 	"sort"
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/app"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/log"
-	"coopcloud.tech/abra/pkg/recipe"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -31,10 +28,11 @@ They can be run within the context of a service (e.g. app) or locally on your
 work station by passing "--local". Arguments can be passed into these functions
 using the "-- <args>" syntax.
 
-Example:
+**WARNING**: options must be passed directly after the sub-command "cmd".
 
-  abra app cmd example.com app create_user -- me@example.com
+EXAMPLE:
-`,
+
+  abra app cmd --local example.com app create_user -- me@example.com`,
 	ArgsUsage: "<domain> [<service>] <command> [-- <args>]",
 	Flags: []cli.Flag{
 		internal.DebugFlag,
@@ -60,24 +58,8 @@ Example:
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := recipePkg.EnsureIsClean(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipePkg.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
 		}
 
 		if internal.LocalCmd && internal.RemoteUser != "" {
@@ -86,12 +68,11 @@ Example:
 
 		hasCmdArgs, parsedCmdArgs := parseCmdArgs(c.Args(), internal.LocalCmd)
 
-		abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
+		if _, err := os.Stat(app.Recipe.AbraShPath); err != nil {
-		if _, err := os.Stat(abraSh); err != nil {
 			if os.IsNotExist(err) {
-				logrus.Fatalf("%s does not exist for %s?", abraSh, app.Name)
+				log.Fatalf("%s does not exist for %s?", app.Recipe.AbraShPath, app.Name)
 			}
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if internal.LocalCmd {
@@ -100,11 +81,11 @@ Example:
 			}
 
 			cmdName := c.Args().Get(1)
-			if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
+			if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
-			logrus.Debugf("--local detected, running %s on local work station", cmdName)
+			log.Debugf("--local detected, running %s on local work station", cmdName)
 
 			var exportEnv string
 			for k, v := range app.Env {
@@ -113,22 +94,22 @@ Example:
 
 			var sourceAndExec string
 			if hasCmdArgs {
-				logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
+				log.Debugf("parsed following command arguments: %s", parsedCmdArgs)
-				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s %s", app.Name, app.StackName(), exportEnv, abraSh, cmdName, parsedCmdArgs)
+				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s %s", app.Name, app.StackName(), exportEnv, app.Recipe.AbraShPath, cmdName, parsedCmdArgs)
 			} else {
-				logrus.Debug("did not detect any command arguments")
+				log.Debug("did not detect any command arguments")
-				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s", app.Name, app.StackName(), exportEnv, abraSh, cmdName)
+				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s", app.Name, app.StackName(), exportEnv, app.Recipe.AbraShPath, cmdName)
 			}
 
 			shell := "/bin/bash"
 			if _, err := os.Stat(shell); errors.Is(err, os.ErrNotExist) {
-				logrus.Debugf("%s does not exist locally, use /bin/sh as fallback", shell)
+				log.Debugf("%s does not exist locally, use /bin/sh as fallback", shell)
 				shell = "/bin/sh"
 			}
 			cmd := exec.Command(shell, "-c", sourceAndExec)
 
 			if err := internal.RunCmd(cmd); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		} else {
 			if !(len(c.Args()) >= 3) {
@@ -138,13 +119,13 @@ Example:
 			targetServiceName := c.Args().Get(1)
 
 			cmdName := c.Args().Get(2)
-			if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
+			if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
-			serviceNames, err := config.GetAppServiceNames(app.Name)
+			serviceNames, err := appPkg.GetAppServiceNames(app.Name)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			matchingServiceName := false
@@ -155,24 +136,24 @@ Example:
 			}
 
 			if !matchingServiceName {
-				logrus.Fatalf("no service %s for %s?", targetServiceName, app.Name)
+				log.Fatalf("no service %s for %s?", targetServiceName, app.Name)
 			}
 
-			logrus.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName)
+			log.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName)
 
 			if hasCmdArgs {
-				logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
+				log.Debugf("parsed following command arguments: %s", parsedCmdArgs)
 			} else {
-				logrus.Debug("did not detect any command arguments")
+				log.Debug("did not detect any command arguments")
 			}
 
 			cl, err := client.New(app.Server)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
-			if err := internal.RunCmdRemote(cl, app, abraSh, targetServiceName, cmdName, parsedCmdArgs); err != nil {
+			if err := internal.RunCmdRemote(cl, app, app.Recipe.AbraShPath, targetServiceName, cmdName, parsedCmdArgs); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
@@ -228,29 +209,29 @@ var appCmdListCommand = cli.Command{
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := app.Recipe.EnsureExists(); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !internal.Chaos {
-			if err := recipePkg.EnsureIsClean(app.Recipe); err != nil {
+			if err := app.Recipe.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if !internal.Offline {
-				if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil {
+				if err := app.Recipe.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			}
 
-			if err := recipePkg.EnsureLatest(app.Recipe); err != nil {
+			if err := app.Recipe.EnsureLatest(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		cmdNames, err := getShCmdNames(app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, cmdName := range cmdNames {
@@ -261,9 +242,8 @@ var appCmdListCommand = cli.Command{
 	},
 }
 
-func getShCmdNames(app config.App) ([]string, error) {
+func getShCmdNames(app appPkg.App) ([]string, error) {
-	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
+	cmdNames, err := appPkg.ReadAbraShCmdNames(app.Recipe.AbraShPath)
-	cmdNames, err := config.ReadAbraShCmdNames(abraShPath)
 	if err != nil {
 		return nil, err
 	}

cli/app/config.go

@@ -6,10 +6,10 @@ import (
 	"os/exec"
 
 	"coopcloud.tech/abra/cli/internal"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -30,24 +30,24 @@ var appConfigCommand = cli.Command{
 			internal.ShowSubcommandHelpAndError(c, errors.New("no app provided"))
 		}
 
-		files, err := config.LoadAppFiles("")
+		files, err := appPkg.LoadAppFiles("")
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		appFile, exists := files[appName]
 		if !exists {
-			logrus.Fatalf("cannot find app with name %s", appName)
+			log.Fatalf("cannot find app with name %s", appName)
 		}
 
 		ed, ok := os.LookupEnv("EDITOR")
 		if !ok {
 			edPrompt := &survey.Select{
-				Message: "Which editor do you wish to use?",
+				Message: "which editor do you wish to use?",
 				Options: []string{"vi", "vim", "nvim", "nano", "pico", "emacs"},
 			}
 			if err := survey.AskOne(edPrompt, &ed); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
@@ -56,7 +56,7 @@ var appConfigCommand = cli.Command{
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
 		if err := cmd.Run(); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil

cli/app/cp.go

@@ -15,13 +15,13 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	containerPkg "coopcloud.tech/abra/pkg/container"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/docker/docker/errdefs"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -50,30 +50,34 @@ And if you want to copy that file back to your current working directory locally
 	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 := c.Args().Get(1)
 		dst := c.Args().Get(2)
 		if src == "" {
-			logrus.Fatal("missing <src> argument")
+			log.Fatal("missing <src> argument")
 		}
 		if dst == "" {
-			logrus.Fatal("missing <dest> argument")
+			log.Fatal("missing <dest> argument")
 		}
 
 		srcPath, dstPath, service, toContainer, err := parseSrcAndDst(src, dst)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		container, err := containerPkg.GetContainerFromStackAndService(cl, app.StackName(), service)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-		logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(container.ID), app.Server)
+		log.Debugf("retrieved %s as target container on %s", formatter.ShortenID(container.ID), app.Server)
 
 		if toContainer {
 			err = CopyToContainer(cl, container.ID, srcPath, dstPath)
@@ -81,7 +85,7 @@ And if you want to copy that file back to your current working directory locally
 			err = CopyFromContainer(cl, container.ID, srcPath, dstPath)
 		}
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil
@@ -167,7 +171,7 @@ func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 		return err
 	}
 
-	logrus.Debugf("copy %s from local to %s on container", srcPath, dstPath)
+	log.Debugf("copy %s from local to %s on container", srcPath, dstPath)
 	copyOpts := types.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
 	if err := cl.CopyToContainer(context.Background(), containerID, dstPath, content, copyOpts); err != nil {
 		return err

cli/app/deploy.go

@@ -2,21 +2,20 @@ package app
 
 import (
 	"context"
-	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
+	"coopcloud.tech/abra/pkg/envfile"
 	"coopcloud.tech/abra/pkg/secret"
 
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/dns"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/lint"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -35,160 +34,147 @@ var appDeployCommand = cli.Command{
 		internal.OfflineFlag,
 	},
 	Before: internal.SubCommandBefore,
-	Description: `
+	Description: `Deploy an app.
-Deploy an app. It does not support incrementing the version of a deployed app,
-for this you need to look at the "abra app upgrade <domain>" command.
 
-You may pass "--force" to re-deploy the same version again. This can be useful
+This command supports chaos operations. Use "--chaos" to deploy your recipe
-if the container runtime has gotten into a weird state.
+checkout as-is. Recipe commit hashes are also supported values for
+"[<version>]". Please note, "upgrade"/"rollback" do not support chaos
+operations.
 
-Chaos mode ("--chaos") will deploy your local checkout of a recipe as-is,
+EXAMPLE:
-including unstaged changes and can be useful for live hacking and testing new
+
-recipes.
+    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 {
-			logrus.Fatal("cannot use <version> and --chaos together")
+			log.Fatal("cannot use <version> and --chaos together")
 		}
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !internal.Chaos {
+		if err := lint.LintForErrors(app.Recipe); err != nil {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
+			log.Fatal(err)
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
 		}
 
-		r, err := recipe.Get(app.Recipe, internal.Offline)
+		log.Debugf("checking whether %s is already deployed", stackName)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := lint.LintForErrors(r); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
+		// NOTE(d1): handles "<version> as git hash" use case
+		var isChaosCommit bool
+
 		// NOTE(d1): check out specific version before dealing with secrets. This
 		// is because we need to deal with GetComposeFiles under the hood and these
 		// files change from version to version which therefore affects which
 		// secrets might be generated
-		version := deployedVersion
+		version := deployMeta.Version
 		if specificVersion != "" {
 			version = specificVersion
-			logrus.Debugf("choosing %s as version to deploy", version)
+			log.Debugf("choosing %s as version to deploy", version)
-			if err := recipe.EnsureVersion(app.Recipe, version); err != nil {
+
-				logrus.Fatal(err)
+			var err error
+			isChaosCommit, err = app.Recipe.EnsureVersion(version)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			if isChaosCommit {
+				log.Debugf("assuming '%s' is a chaos commit", version)
+				internal.Chaos = true
 			}
 		}
 
 		secStats, err := secret.PollSecretsStatus(cl, app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, secStat := range secStats {
 			if !secStat.CreatedOnRemote {
-				logrus.Fatalf("unable to deploy, secrets not generated (%s)?", secStat.LocalName)
+				log.Fatalf("unable to deploy, secrets not generated (%s)?", secStat.LocalName)
 			}
 		}
 
-		if isDeployed {
+		if deployMeta.IsDeployed {
 			if internal.Force || internal.Chaos {
-				logrus.Warnf("%s is already deployed but continuing (--force/--chaos)", app.Name)
+				log.Warnf("%s is already deployed but continuing (--force/--chaos)", app.Name)
 			} else {
-				logrus.Fatalf("%s is already deployed", app.Name)
+				log.Fatalf("%s is already deployed", app.Name)
 			}
 		}
 
 		if !internal.Chaos && specificVersion == "" {
-			catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
+			versions, err := app.Recipe.Tags()
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
-			}
-			versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if len(versions) == 0 && !internal.Chaos {
-				logrus.Warn("no published versions in catalogue, trying local recipe repository")
-				recipeVersions, err := recipe.GetRecipeVersions(app.Recipe, internal.Offline)
-				if err != nil {
-					logrus.Warn(err)
-				}
-				for _, recipeVersion := range recipeVersions {
-					for version := range recipeVersion {
-						versions = append(versions, version)
-					}
-				}
 			}
 
 			if len(versions) > 0 && !internal.Chaos {
 				version = versions[len(versions)-1]
-				logrus.Debugf("choosing %s as version to deploy", version)
+				log.Debugf("choosing %s as version to deploy", version)
-				if err := recipe.EnsureVersion(app.Recipe, version); err != nil {
+				if _, err := app.Recipe.EnsureVersion(version); err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			} else {
-				head, err := git.GetRecipeHead(app.Recipe)
+				head, err := git.GetRecipeHead(app.Recipe.Name)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 				version = formatter.SmallSHA(head.String())
-				logrus.Warn("no versions detected, using latest commit")
+				log.Warn("no versions detected, using latest commit")
 			}
 		}
 
+		chaosVersion := "false"
 		if internal.Chaos {
-			logrus.Warnf("chaos mode engaged")
+			log.Warnf("chaos mode engaged")
-			var err error
+
-			version, err = recipe.ChaosVersion(app.Recipe)
+			if isChaosCommit {
-			if err != nil {
+				chaosVersion = specificVersion
-				logrus.Fatal(err)
+				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)
+				}
 			}
 		}
 
-		abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
+		abraShEnv, err := envfile.ReadAbraShEnvVars(app.Recipe.AbraShPath)
-		abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		for k, v := range abraShEnv {
 			app.Env[k] = v
 		}
 
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		deployOpts := stack.Deploy{
@@ -196,61 +182,69 @@ recipes.
 			Namespace:    stackName,
 			Prune:        false,
 			ResolveImage: stack.ResolveImageAlways,
+			Detach:       false,
 		}
-		compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
+		compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		config.ExposeAllEnv(stackName, compose, app.Env)
+		appPkg.ExposeAllEnv(stackName, compose, app.Env)
-		config.SetRecipeLabel(compose, stackName, app.Recipe)
+		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
-		config.SetChaosLabel(compose, stackName, internal.Chaos)
+		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
-		config.SetChaosVersionLabel(compose, stackName, version)
+		appPkg.SetChaosVersionLabel(compose, stackName, chaosVersion)
-		config.SetUpdateLabel(compose, stackName, app.Env)
+		appPkg.SetUpdateLabel(compose, stackName, app.Env)
 
-		envVars, err := config.CheckEnv(app)
+		envVars, err := appPkg.CheckEnv(app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, envVar := range envVars {
 			if !envVar.Present {
-				logrus.Warnf("env var %s missing from %s.env, present in recipe .env.sample", 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, "continue with deployment?"); err != nil {
+		if err := internal.DeployOverview(app, version, chaosVersion, "continue with deployment?"); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !internal.NoDomainChecks {
 			domainName, ok := app.Env["DOMAIN"]
 			if ok {
 				if _, err = dns.EnsureDomainsResolveSameIPv4(domainName, app.Server); err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			} else {
-				logrus.Warn("skipping domain checks as no DOMAIN=... configured for app")
+				log.Warn("skipping domain checks as no DOMAIN=... configured for app")
 			}
 		} else {
-			logrus.Warn("skipping domain checks as requested")
+			log.Warn("skipping domain checks as requested")
 		}
 
-		stack.WaitTimeout, err = config.GetTimeoutFromLabel(compose, stackName)
+		stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-		logrus.Debugf("set waiting timeout to %d 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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		postDeployCmds, ok := app.Env["POST_DEPLOY_CMDS"]
 		if ok && !internal.DontWaitConverge {
-			logrus.Debugf("run the following post-deploy commands: %s", postDeployCmds)
+			log.Debugf("run the following post-deploy commands: %s", postDeployCmds)
 			if err := internal.PostCmds(cl, app, postDeployCmds); err != nil {
-				logrus.Fatalf("attempting to run post deploy commands, saw: %s", err)
+				log.Fatalf("attempting to run post deploy commands, saw: %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

cli/app/errors.go

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

cli/app/list.go

@@ -8,36 +8,41 @@ import (
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/config"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/tagcmp"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
-var status bool
+var (
-var statusFlag = &cli.BoolFlag{
+	status     bool
-	Name:        "status, S",
+	statusFlag = &cli.BoolFlag{
-	Usage:       "Show app deployment status",
+		Name:        "status, S",
-	Destination: &status,
+		Usage:       "Show app deployment status",
-}
+		Destination: &status,
+	}
+)
 
-var recipeFilter string
+var (
-var recipeFlag = &cli.StringFlag{
+	recipeFilter string
-	Name:        "recipe, r",
+	recipeFlag   = &cli.StringFlag{
-	Value:       "",
+		Name:        "recipe, r",
-	Usage:       "Show apps of a specific recipe",
+		Value:       "",
-	Destination: &recipeFilter,
+		Usage:       "Show apps of a specific recipe",
-}
+		Destination: &recipeFilter,
+	}
+)
 
-var listAppServer string
+var (
-var listAppServerFlag = &cli.StringFlag{
+	listAppServer     string
-	Name:        "server, s",
+	listAppServerFlag = &cli.StringFlag{
-	Value:       "",
+		Name:        "server, s",
-	Usage:       "Show apps of a specific server",
+		Value:       "",
-	Destination: &listAppServer,
+		Usage:       "Show apps of a specific server",
-}
+		Destination: &listAppServer,
+	}
+)
 
 type appStatus struct {
 	Server       string `json:"server"`
@@ -71,8 +76,7 @@ generate a report of all your apps.
 
 By passing the "--status/-S" flag, you can query all your servers for the
 actual live deployment status. Depending on how many servers you manage, this
-can take some time.
+can take some time.`,
-`,
 	Flags: []cli.Flag{
 		internal.DebugFlag,
 		internal.MachineReadableFlag,
@@ -83,20 +87,19 @@ can take some time.
 	},
 	Before: internal.SubCommandBefore,
 	Action: func(c *cli.Context) error {
-		appFiles, err := config.LoadAppFiles(listAppServer)
+		appFiles, err := appPkg.LoadAppFiles(listAppServer)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		apps, err := config.GetApps(appFiles, recipeFilter)
+		apps, err := appPkg.GetApps(appFiles, recipeFilter)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		sort.Sort(config.ByServerAndRecipe(apps))
+		sort.Sort(appPkg.ByServerAndRecipe(apps))
 
 		statuses := make(map[string]map[string]string)
-		var catl recipe.RecipeCatalogue
 		if status {
 			alreadySeen := make(map[string]bool)
 			for _, app := range apps {
@@ -105,14 +108,9 @@ can take some time.
 				}
 			}
 
-			statuses, err = config.GetAppStatuses(apps, internal.MachineReadable)
+			statuses, err = appPkg.GetAppStatuses(apps, internal.MachineReadable)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
-			}
-
-			catl, err = recipe.ReadRecipeCatalogue(internal.Offline)
-			if err != nil {
-				logrus.Fatal(err)
 			}
 		}
 
@@ -130,7 +128,7 @@ can take some time.
 				}
 			}
 
-			if app.Recipe == recipeFilter || recipeFilter == "" {
+			if app.Recipe.Name == recipeFilter || recipeFilter == "" {
 				if recipeFilter != "" {
 					// only count server if matches filter
 					totalServersCount++
@@ -177,20 +175,20 @@ can take some time.
 
 					var newUpdates []string
 					if version != "unknown" {
-						updates, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
+						updates, err := app.Recipe.Tags()
 						if err != nil {
-							logrus.Fatal(err)
+							log.Fatal(err)
 						}
 
 						parsedVersion, err := tagcmp.Parse(version)
 						if err != nil {
-							logrus.Fatal(err)
+							log.Fatal(err)
 						}
 
 						for _, update := range updates {
 							parsedUpdate, err := tagcmp.Parse(update)
 							if err != nil {
-								logrus.Fatal(err)
+								log.Fatal(err)
 							}
 
 							if update != version && parsedUpdate.IsGreaterThan(parsedVersion) {
@@ -214,7 +212,7 @@ can take some time.
 				}
 
 				appStats.Server = app.Server
-				appStats.Recipe = app.Recipe
+				appStats.Recipe = app.Recipe.Name
 				appStats.AppName = app.Name
 				appStats.Domain = app.Domain
 
@@ -226,7 +224,7 @@ can take some time.
 		if internal.MachineReadable {
 			jsonstring, err := json.Marshal(allStats)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			} else {
 				fmt.Println(string(jsonstring))
 			}
@@ -255,7 +253,7 @@ can take some time.
 					if chaosStatus != "unknown" {
 						chaosEnabled, err := strconv.ParseBool(chaosStatus)
 						if err != nil {
-							logrus.Fatal(err)
+							log.Fatal(err)
 						}
 						if chaosEnabled && appStat.ChaosVersion != "unknown" {
 							chaosStatus = appStat.ChaosVersion

cli/app/logs.go

@@ -9,17 +9,16 @@ import (
 	"time"
 
 	"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/log"
-	"coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/docker/docker/api/types"
 	containerTypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/swarm"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -39,22 +38,22 @@ var appLogsCommand = cli.Command{
 		app := internal.ValidateApp(c)
 		stackName := app.StackName()
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := app.Recipe.EnsureExists(); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
+		if !deployMeta.IsDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
 		serviceName := c.Args().Get(1)
@@ -64,7 +63,7 @@ var appLogsCommand = cli.Command{
 		}
 		err = tailLogs(cl, app, serviceNames)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil
@@ -74,7 +73,7 @@ var appLogsCommand = cli.Command{
 // tailLogs prints logs for the given app with optional service names to be
 // filtered on. It also checks if the latest task is not runnning and then
 // prints the past tasks.
-func tailLogs(cl *dockerClient.Client, app config.App, serviceNames []string) error {
+func tailLogs(cl *dockerClient.Client, app appPkg.App, serviceNames []string) error {
 	f, err := app.Filters(true, false, serviceNames...)
 	if err != nil {
 		return err
@@ -102,7 +101,7 @@ func tailLogs(cl *dockerClient.Client, app config.App, serviceNames []string) er
 			lastTask := tasks[0].Status
 			if lastTask.State != swarm.TaskStateRunning {
 				for _, task := range tasks {
-					logrus.Errorf("[%s] %s State %s: %s", service.Spec.Name, task.Meta.CreatedAt.Format(time.RFC3339), task.Status.State, task.Status.Err)
+					log.Errorf("[%s] %s State %s: %s", service.Spec.Name, task.Meta.CreatedAt.Format(time.RFC3339), task.Status.State, task.Status.Err)
 				}
 			}
 		}
@@ -122,13 +121,13 @@ func tailLogs(cl *dockerClient.Client, app config.App, serviceNames []string) er
 				Details:    false,
 			})
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 			defer logs.Close()
 
 			_, err = io.Copy(os.Stdout, logs)
 			if err != nil && err != io.EOF {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}(service.ID)
 	}

cli/app/new.go

@@ -2,25 +2,25 @@ package app
 
 import (
 	"fmt"
-	"path"
 
 	"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/jsontable"
+	"coopcloud.tech/abra/pkg/log"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/abra/pkg/secret"
 	"github.com/AlecAivazis/survey/v2"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
 var appNewDescription = `
-Take a recipe and uses it to create a new app. This new app configuration is
+Creates a new app from a default recipe. This new app configuration is stored
-stored in your ~/.abra directory under the appropriate server.
+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.
@@ -35,8 +35,7 @@ store them somewhere safe.
 
 You can use the "--pass/-P" to store these generated passwords locally in a
 pass store (see passwordstore.org for more). The pass command must be available
-on your $PATH.
+on your $PATH.`
-`
 
 var appNewCommand = cli.Command{
 	Name:        "new",
@@ -68,20 +67,20 @@ var appNewCommand = cli.Command{
 		recipe := internal.ValidateRecipe(c)
 
 		if !internal.Chaos {
-			if err := recipePkg.EnsureIsClean(recipe.Name); err != nil {
+			if err := recipe.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 			if !internal.Offline {
-				if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil {
+				if err := recipe.EnsureUpToDate(); err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			}
 			if c.Args().Get(1) == "" {
 				var version string
 
-				recipeVersions, err := recipePkg.GetRecipeVersions(recipe.Name, internal.Offline)
+				recipeVersions, err := recipe.GetRecipeVersions()
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 
 				// NOTE(d1): determine whether recipe versions exist or not and check
@@ -92,39 +91,39 @@ var appNewCommand = cli.Command{
 						version = tag
 					}
 
-					if err := recipePkg.EnsureVersion(recipe.Name, version); err != nil {
+					if _, err := recipe.EnsureVersion(version); err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 				} else {
-					if err := recipePkg.EnsureLatest(recipe.Name); err != nil {
+					if err := recipe.EnsureLatest(); err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 				}
 			} else {
-				if err := recipePkg.EnsureVersion(recipe.Name, c.Args().Get(1)); err != nil {
+				if _, err := recipe.EnsureVersion(c.Args().Get(1)); err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			}
 		}
 
 		if err := ensureServerFlag(); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if err := ensureDomainFlag(recipe, internal.NewAppServer); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		sanitisedAppName := config.SanitiseAppName(internal.Domain)
+		sanitisedAppName := appPkg.SanitiseAppName(internal.Domain)
-		logrus.Debugf("%s sanitised as %s for new app", internal.Domain, sanitisedAppName)
+		log.Debugf("%s sanitised as %s for new app", internal.Domain, sanitisedAppName)
 
-		if err := config.TemplateAppEnvSample(
+		if err := appPkg.TemplateAppEnvSample(
-			recipe.Name,
+			recipe,
 			internal.Domain,
 			internal.NewAppServer,
 			internal.Domain,
 		); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		var secrets AppSecrets
@@ -132,32 +131,31 @@ var appNewCommand = cli.Command{
 		if internal.Secrets {
 			sampleEnv, err := recipe.SampleEnv()
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
-			composeFiles, err := config.GetComposeFiles(recipe.Name, sampleEnv)
+			composeFiles, err := recipe.GetComposeFiles(sampleEnv)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
-			envSamplePath := path.Join(config.RECIPES_DIR, recipe.Name, ".env.sample")
+			secretsConfig, err := secret.ReadSecretsConfig(recipe.SampleEnvPath, composeFiles, appPkg.StackName(internal.Domain))
-			secretsConfig, err := secret.ReadSecretsConfig(envSamplePath, composeFiles, config.StackName(internal.Domain))
 			if err != nil {
 				return err
 			}
 
 			if err := promptForSecrets(recipe.Name, secretsConfig); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			cl, err := client.New(internal.NewAppServer)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			secrets, err = createSecrets(cl, secretsConfig, sanitisedAppName)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			secretCols := []string{"Name", "Value"}
@@ -175,22 +173,25 @@ var appNewCommand = cli.Command{
 		table := formatter.CreateTable(tableCol)
 		table.Append([]string{internal.NewAppServer, recipe.Name, internal.Domain})
 
-		fmt.Println(fmt.Sprintf("A new %s app has been created! Here is an overview:", recipe.Name))
+		log.Infof("new app '%s' created 🌞", recipe.Name)
+
 		fmt.Println("")
 		table.Render()
 		fmt.Println("")
-		fmt.Println("You can configure this app by running the following:")
+
+		fmt.Println("Configure this app:")
 		fmt.Println(fmt.Sprintf("\n    abra app config %s", internal.Domain))
+
 		fmt.Println("")
-		fmt.Println("You can deploy this app by running the following:")
+		fmt.Println("Deploy this app:")
 		fmt.Println(fmt.Sprintf("\n    abra app deploy %s", internal.Domain))
 
 		if len(secrets) > 0 {
 			fmt.Println("")
-			fmt.Println("Here are your generated secrets:")
+			fmt.Println("Generated secrets:")
 			fmt.Println("")
 			secretTable.Render()
-			logrus.Warn("generated secrets are not shown again, please take note of them NOW")
+			log.Warn("generated secrets are not shown again, please take note of them NOW")
 		}
 
 		return nil
@@ -204,7 +205,7 @@ type AppSecrets map[string]string
 func createSecrets(cl *dockerClient.Client, secretsConfig map[string]secret.Secret, sanitisedAppName string) (AppSecrets, error) {
 	// NOTE(d1): trim to match app.StackName() implementation
 	if len(sanitisedAppName) > config.MAX_SANITISED_APP_NAME_LENGTH {
-		logrus.Debugf("trimming %s to %s to avoid runtime limits", sanitisedAppName, sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH])
+		log.Debugf("trimming %s to %s to avoid runtime limits", sanitisedAppName, sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH])
 		sanitisedAppName = sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH]
 	}
 
@@ -252,7 +253,7 @@ func ensureDomainFlag(recipe recipePkg.Recipe, server string) error {
 // promptForSecrets asks if we should generate secrets for a new app.
 func promptForSecrets(recipeName string, secretsConfig map[string]secret.Secret) error {
 	if len(secretsConfig) == 0 {
-		logrus.Debugf("%s has no secrets to generate, skipping...", recipeName)
+		log.Debugf("%s has no secrets to generate, skipping...", recipeName)
 		return nil
 	}
 

cli/app/ps.go

@@ -4,22 +4,19 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"time"
 
 	"coopcloud.tech/abra/cli/internal"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
 	abraService "coopcloud.tech/abra/pkg/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/buger/goterm"
 	dockerFormatter "github.com/docker/cli/cli/command/formatter"
 	containerTypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -28,60 +25,60 @@ var appPsCommand = cli.Command{
 	Aliases:     []string{"p"},
 	Usage:       "Check app status",
 	ArgsUsage:   "<domain>",
-	Description: "Show a more detailed status output of a specific deployed app",
+	Description: "Show status of a deployed app.",
 	Flags: []cli.Flag{
 		internal.MachineReadableFlag,
-		internal.WatchFlag,
 		internal.DebugFlag,
 	},
 	Before:       internal.SubCommandBefore,
 	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
+		if err := app.Recipe.Ensure(false, false); err != nil {
+			log.Fatal(err)
+		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
+		if !deployMeta.IsDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		statuses, err := config.GetAppStatuses([]config.App{app}, true)
+		chaosVersion := "false"
+		statuses, err := appPkg.GetAppStatuses([]appPkg.App{app}, true)
 		if statusMeta, ok := statuses[app.StackName()]; ok {
-			if _, exists := statusMeta["chaos"]; !exists {
+			isChaos, exists := statusMeta["chaos"]
-				if err := recipe.EnsureVersion(app.Recipe, deployedVersion); err != nil {
+			if exists && isChaos == "false" {
-					logrus.Fatal(err)
+				if _, err := app.Recipe.EnsureVersion(deployMeta.Version); err != nil {
+					log.Fatal(err)
+				}
+			} else {
+				chaosVersion, err = app.Recipe.ChaosVersion()
+				if err != nil {
+					log.Fatal(err)
 				}
 			}
 		}
 
-		if !internal.Watch {
+		showPSOutput(app, cl, deployMeta.Version, chaosVersion)
-			showPSOutput(c, app, cl)
-			return nil
-		}
 
-		goterm.Clear()
+		return nil
-		for {
-			goterm.MoveCursor(1, 1)
-			showPSOutput(c, app, cl)
-			goterm.Flush()
-			time.Sleep(2 * time.Second)
-		}
 	},
 }
 
 // showPSOutput renders ps output.
-func showPSOutput(c *cli.Context, app config.App, cl *dockerClient.Client) {
+func showPSOutput(app appPkg.App, cl *dockerClient.Client, deployedVersion, chaosVersion string) {
-	composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
+	composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 		return
 	}
 
@@ -91,9 +88,9 @@ func showPSOutput(c *cli.Context, app config.App, cl *dockerClient.Client) {
 		Prune:        false,
 		ResolveImage: stack.ResolveImageAlways,
 	}
-	compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
+	compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 		return
 	}
 
@@ -105,51 +102,68 @@ func showPSOutput(c *cli.Context, app config.App, cl *dockerClient.Client) {
 
 		containers, err := cl.ContainerList(context.Background(), containerTypes.ListOptions{Filters: filters})
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 			return
 		}
 
 		var containerStats map[string]string
-
 		if len(containers) == 0 {
 			containerStats = map[string]string{
-				"service name": service.Name,
+				"version": deployedVersion,
-				"image":        "unknown",
+				"chaos":   chaosVersion,
-				"created":      "unknown",
+				"service": service.Name,
-				"status":       "unknown",
+				"image":   "unknown",
-				"state":        "unknown",
+				"created": "unknown",
-				"ports":        "unknown",
+				"status":  "unknown",
+				"state":   "unknown",
+				"ports":   "unknown",
 			}
 		} else {
 			container := containers[0]
 			containerStats = map[string]string{
-				"service name": abraService.ContainerToServiceName(container.Names, app.StackName()),
+				"version": deployedVersion,
-				"image":        formatter.RemoveSha(container.Image),
+				"chaos":   chaosVersion,
-				"created":      formatter.HumanDuration(container.Created),
+				"service": abraService.ContainerToServiceName(container.Names, app.StackName()),
-				"status":       container.Status,
+				"image":   formatter.RemoveSha(container.Image),
-				"state":        container.State,
+				"created": formatter.HumanDuration(container.Created),
-				"ports":        dockerFormatter.DisplayablePorts(container.Ports),
+				"status":  container.Status,
+				"state":   container.State,
+				"ports":   dockerFormatter.DisplayablePorts(container.Ports),
 			}
 		}
-		allContainerStats[containerStats["service name"]] = containerStats
 
-		var tablerow []string = []string{containerStats["service name"], containerStats["image"], containerStats["created"], containerStats["status"], containerStats["state"], containerStats["ports"]}
+		allContainerStats[containerStats["service"]] = containerStats
+
+		tablerow := []string{
+			deployedVersion,
+			chaosVersion,
+			containerStats["service"],
+			containerStats["image"],
+			containerStats["created"],
+			containerStats["status"],
+			containerStats["state"],
+			containerStats["ports"],
+		}
+
 		tablerows = append(tablerows, tablerow)
 	}
+
 	if internal.MachineReadable {
 		jsonstring, err := json.Marshal(allContainerStats)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
-		} else {
-			fmt.Println(string(jsonstring))
 		}
+
+		fmt.Println(string(jsonstring))
+
 		return
-	} else {
-		tableCol := []string{"service name", "image", "created", "status", "state", "ports"}
-		table := formatter.CreateTable(tableCol)
-		for _, row := range tablerows {
-			table.Append(row)
-		}
-		table.Render()
 	}
+
+	tableCol := []string{"version", "chaos", "service", "image", "created", "status", "state", "ports"}
+	table := formatter.CreateTable(tableCol)
+	for _, row := range tablerows {
+		table.Append(row)
+	}
+	table.SetAutoMergeCellsByColumnIndex([]int{0, 1})
+	table.Render()
 }

cli/app/remove.go

@@ -3,16 +3,15 @@ package app
 import (
 	"context"
 	"fmt"
-	"log"
 	"os"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
+	"coopcloud.tech/abra/pkg/log"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/docker/api/types"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -37,8 +36,7 @@ Please note, if you delete the local app env file without removing volumes and
 secrets first, Abra will *not* be able to help you remove them afterwards.
 
 To delete everything without prompt, use the "--force/-f" or the "--no-input/n"
-flag.
+flag.`,
-`,
 	Flags: []cli.Flag{
 		internal.ForceFlag,
 		internal.DebugFlag,
@@ -55,34 +53,34 @@ flag.
 			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 {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 			if !response {
-				logrus.Fatal("aborting as requested")
+				log.Fatal("aborting as requested")
 			}
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-		if isDeployed {
+		if deployMeta.IsDeployed {
-			logrus.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name)
+			log.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name)
 		}
 
 		fs, err := app.Filters(false, false)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: fs})
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secrets := make(map[string]string)
@@ -97,22 +95,22 @@ flag.
 			for _, name := range secretNames {
 				err := cl.SecretRemove(context.Background(), secrets[name])
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
-				logrus.Info(fmt.Sprintf("secret: %s removed", name))
+				log.Info(fmt.Sprintf("secret: %s removed", name))
 			}
 		} else {
-			logrus.Info("no secrets to remove")
+			log.Info("no secrets to remove")
 		}
 
 		fs, err = app.Filters(false, true)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, fs)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		volumeNames := client.GetVolumeNames(volumeList)
 
@@ -122,16 +120,16 @@ flag.
 				log.Fatalf("removing volumes failed: %s", err)
 			}
 
-			logrus.Infof("%d volumes removed successfully", len(volumeNames))
+			log.Infof("%d volumes removed successfully", len(volumeNames))
 		} else {
-			logrus.Info("no volumes to remove")
+			log.Info("no volumes to remove")
 		}
 
 		if err = os.Remove(app.Path); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Info(fmt.Sprintf("file: %s removed", app.Path))
+		log.Info(fmt.Sprintf("file: %s removed", app.Path))
 
 		return nil
 	},

cli/app/restart.go

@@ -6,11 +6,12 @@ import (
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
+	"coopcloud.tech/abra/pkg/log"
 	upstream "coopcloud.tech/abra/pkg/upstream/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -18,63 +19,93 @@ var appRestartCommand = cli.Command{
 	Name:      "restart",
 	Aliases:   []string{"re"},
 	Usage:     "Restart an app",
-	ArgsUsage: "<domain>",
+	ArgsUsage: "<domain> [<service>]",
 	Flags: []cli.Flag{
 		internal.DebugFlag,
 		internal.OfflineFlag,
+		internal.AllServicesFlag,
 	},
-	Before:       internal.SubCommandBefore,
+	Before: internal.SubCommandBefore,
-	Description:  `This command restarts a service within a deployed app.`,
+	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:
+
+    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)
+		}
 
-		serviceNameShort := c.Args().Get(1)
+		serviceName := c.Args().Get(1)
-		if serviceNameShort == "" {
+		if serviceName == "" && !internal.AllServices {
-			err := errors.New("missing service?")
+			err := errors.New("missing <service>")
 			internal.ShowSubcommandHelpAndError(c, err)
 		}
 
+		if serviceName != "" && internal.AllServices {
+			log.Fatal("cannot use <service> and --all-services together")
+		}
+
+		var serviceNames []string
+		if internal.AllServices {
+			var err error
+			serviceNames, err = appPkg.GetAppServiceNames(app.Name)
+			if err != nil {
+				log.Fatal(err)
+			}
+		} else {
+			serviceNames = append(serviceNames, serviceName)
+		}
+
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
+		if !deployMeta.IsDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		serviceName := fmt.Sprintf("%s_%s", app.StackName(), serviceNameShort)
+		for _, serviceName := range serviceNames {
+			stackServiceName := fmt.Sprintf("%s_%s", app.StackName(), serviceName)
 
-		logrus.Debugf("attempting to scale %s to 0 (restart logic)", serviceName)
+			log.Debugf("attempting to scale %s to 0", stackServiceName)
-		if err := upstream.RunServiceScale(context.Background(), cl, serviceName, 0); err != nil {
+
-			logrus.Fatal(err)
+			if err := upstream.RunServiceScale(context.Background(), cl, stackServiceName, 0); err != nil {
+				log.Fatal(err)
+			}
+
+			if err := stack.WaitOnService(context.Background(), cl, stackServiceName, app.Name); err != nil {
+				log.Fatal(err)
+			}
+
+			log.Debugf("%s has been scaled to 0", stackServiceName)
+			log.Debugf("attempting to scale %s to 1", stackServiceName)
+
+			if err := upstream.RunServiceScale(context.Background(), cl, stackServiceName, 1); err != nil {
+				log.Fatal(err)
+			}
+
+			if err := stack.WaitOnService(context.Background(), cl, stackServiceName, app.Name); err != nil {
+				log.Fatal(err)
+			}
+
+			log.Debugf("%s has been scaled to 1", stackServiceName)
+			log.Infof("%s service successfully restarted", serviceName)
 		}
 
-		if err := stack.WaitOnService(context.Background(), cl, serviceName, app.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("%s has been scaled to 0 (restart logic)", serviceName)
-
-		logrus.Debugf("attempting to scale %s to 1 (restart logic)", serviceName)
-		if err := upstream.RunServiceScale(context.Background(), cl, serviceName, 1); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := stack.WaitOnService(context.Background(), cl, serviceName, app.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("%s has been scaled to 1 (restart logic)", serviceName)
-
-		logrus.Infof("%s service successfully restarted", serviceNameShort)
-
 		return nil
 	},
 }

cli/app/restore.go

@@ -6,8 +6,7 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -32,49 +31,32 @@ var appRestoreCommand = cli.Command{
 	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
-
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+			log.Fatal(err)
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
 		if snapshot != "" {
-			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
 			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
 		}
 		if targetPath != "" {
-			logrus.Debugf("including TARGET=%s in backupbot exec invocation", targetPath)
+			log.Debugf("including TARGET=%s in backupbot exec invocation", targetPath)
 			execEnv = append(execEnv, fmt.Sprintf("TARGET=%s", targetPath))
 		}
 
 		if err := internal.RunBackupCmdRemote(cl, "restore", targetContainer.ID, execEnv); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil

cli/app/rollback.go

@@ -4,17 +4,17 @@ import (
 	"context"
 	"fmt"
 
+	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/lint"
-	"coopcloud.tech/abra/pkg/recipe"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/client"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -27,212 +27,195 @@ var appRollbackCommand = cli.Command{
 		internal.DebugFlag,
 		internal.NoInputFlag,
 		internal.ForceFlag,
-		internal.ChaosFlag,
 		internal.NoDomainChecksFlag,
 		internal.DontWaitConvergeFlag,
 		internal.OfflineFlag,
 	},
 	Before: internal.SubCommandBefore,
 	Description: `
-This command rolls an app back to a previous version if one exists.
+This command rolls an app back to a previous version.
 
-You may pass "--force/-f" to downgrade to the same version again. This can be
+Unlike "deploy", chaos operations are not supported here. Only recipe versions
-useful if the container runtime has gotten into a weird state.
+are supported values for "[<version>]".
 
-This action could be destructive, please ensure you have a copy of your app
+A rollback can be destructive, please ensure you have a copy of your app data
-data beforehand.
+beforehand.
 
-Chaos mode ("--chaos") will deploy your local checkout of a recipe as-is,
+EXAMPLE:
-including unstaged changes and can be useful for live hacking and testing new
+
-recipes.
+    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()
 
-		specificVersion := c.Args().Get(1)
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-		if specificVersion != "" && internal.Chaos {
+			log.Fatal(err)
-			logrus.Fatal("cannot use <version> and --chaos together")
 		}
 
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+		if err := lint.LintForErrors(app.Recipe); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		r, err := recipe.Get(app.Recipe, internal.Offline)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := lint.LintForErrors(r); err != nil {
-			logrus.Fatal(err)
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Debugf("checking whether %s is already deployed", stackName)
+		log.Debugf("checking whether %s is already deployed", stackName)
 
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
+		if !deployMeta.IsDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
+		versions, err := app.Recipe.Tags()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
-		}
-
-		versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if len(versions) == 0 && !internal.Chaos {
-			logrus.Warn("no published versions in catalogue, trying local recipe repository")
-			recipeVersions, err := recipe.GetRecipeVersions(app.Recipe, internal.Offline)
-			if err != nil {
-				logrus.Warn(err)
-			}
-			for _, recipeVersion := range recipeVersions {
-				for version := range recipeVersion {
-					versions = append(versions, version)
-				}
-			}
 		}
 
 		var availableDowngrades []string
-		if deployedVersion == "unknown" {
+		if deployMeta.Version == "unknown" {
 			availableDowngrades = versions
-			logrus.Warnf("failed to determine deployed version of %s", app.Name)
+			log.Warnf("failed to determine deployed version of %s", app.Name)
 		}
 
+		specificVersion := c.Args().Get(1)
+		if specificVersion == "" {
+			specificVersion = app.Recipe.Version
+		}
 		if specificVersion != "" {
-			parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
+			parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatalf("'%s' is not a known version for %s", deployMeta.Version, app.Recipe.Name)
 			}
+
 			parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatalf("'%s' is not a known version for %s", specificVersion, app.Recipe.Name)
 			}
-			if parsedSpecificVersion.IsGreaterThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) {
+
-				logrus.Fatalf("%s is not a downgrade for %s?", deployedVersion, specificVersion)
+			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 deployedVersion != "unknown" && !internal.Chaos && 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(deployedVersion)
+				parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
+
 				parsedVersion, err := tagcmp.Parse(version)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
+
 				if parsedVersion.IsLessThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
 					availableDowngrades = append(availableDowngrades, version)
 				}
 			}
 
 			if len(availableDowngrades) == 0 && !internal.Force {
-				logrus.Info("no available downgrades, you're on oldest ✌️")
+				log.Info("no available downgrades")
 				return nil
 			}
 		}
 
 		var chosenDowngrade string
-		if len(availableDowngrades) > 0 && !internal.Chaos {
+		if len(availableDowngrades) > 0 {
 			if internal.Force || internal.NoInput || specificVersion != "" {
 				chosenDowngrade = availableDowngrades[len(availableDowngrades)-1]
-				logrus.Debugf("choosing %s as version to downgrade to (--force/--no-input)", chosenDowngrade)
+				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: fmt.Sprintf("Please select a downgrade (current version: %s):", deployedVersion),
+					Message: msg,
 					Options: internal.ReverseStringList(availableDowngrades),
 				}
+
 				if err := survey.AskOne(prompt, &chosenDowngrade); err != nil {
 					return err
 				}
 			}
 		}
 
-		if !internal.Chaos {
+		log.Debugf("choosing %s as version to rollback", chosenDowngrade)
-			if err := recipe.EnsureVersion(app.Recipe, chosenDowngrade); err != nil {
+		if _, err := app.Recipe.EnsureVersion(chosenDowngrade); err != nil {
-				logrus.Fatal(err)
+			log.Fatal(err)
-			}
 		}
 
-		if internal.Chaos {
+		abraShEnv, err := envfile.ReadAbraShEnvVars(app.Recipe.AbraShPath)
-			logrus.Warn("chaos mode engaged")
-			var err error
-			chosenDowngrade, err = recipe.ChaosVersion(app.Recipe)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
-		abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		for k, v := range abraShEnv {
 			app.Env[k] = v
 		}
 
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
+
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
 			Prune:        false,
 			ResolveImage: stack.ResolveImageAlways,
+			Detach:       false,
 		}
-		compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
+
+		compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
+		}
+
+		appPkg.ExposeAllEnv(stackName, compose, app.Env)
+		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
+		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
+		appPkg.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
+		appPkg.SetUpdateLabel(compose, stackName, app.Env)
+
+		chaosVersion := "false"
+		if deployMeta.IsChaos {
+			chaosVersion = deployMeta.ChaosVersion
 		}
-		config.ExposeAllEnv(stackName, compose, app.Env)
-		config.SetRecipeLabel(compose, stackName, app.Recipe)
-		config.SetChaosLabel(compose, stackName, internal.Chaos)
-		config.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
-		config.SetUpdateLabel(compose, stackName, app.Env)
 
 		// NOTE(d1): no release notes implemeneted for rolling back
-		if err := internal.NewVersionOverview(app, deployedVersion, chosenDowngrade, ""); err != nil {
+		if err := internal.NewVersionOverview(app, deployMeta.Version, chaosVersion, chosenDowngrade, ""); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(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

cli/app/run.go

@@ -9,11 +9,11 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	containerPkg "coopcloud.tech/abra/pkg/container"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -55,7 +55,7 @@ var appRunCommand = cli.Command{
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		serviceName := c.Args().Get(1)
@@ -65,7 +65,7 @@ var appRunCommand = cli.Command{
 
 		targetContainer, err := containerPkg.GetContainer(context.Background(), cl, filters, false)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		cmd := c.Args()[2:]
@@ -88,11 +88,11 @@ var appRunCommand = cli.Command{
 		// FIXME: avoid instantiating a new CLI
 		dcli, err := command.NewDockerCli()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil

cli/app/secret.go

@@ -9,15 +9,14 @@ import (
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/secret"
 	"github.com/docker/docker/api/types"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -56,25 +55,8 @@ var appSecretGenerateCommand = cli.Command{
 	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
-
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+			log.Fatal(err)
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
 		}
 
 		if len(c.Args()) == 1 && !allSecrets {
@@ -87,14 +69,14 @@ var appSecretGenerateCommand = cli.Command{
 			internal.ShowSubcommandHelpAndError(c, err)
 		}
 
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secrets, err := secret.ReadSecretsConfig(app.Path, composeFiles, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !allSecrets {
@@ -102,7 +84,7 @@ var appSecretGenerateCommand = cli.Command{
 			secretVersion := c.Args().Get(2)
 			s, ok := secrets[secretName]
 			if !ok {
-				logrus.Fatalf("%s doesn't exist in the env config?", secretName)
+				log.Fatalf("%s doesn't exist in the env config?", secretName)
 			}
 			s.Version = secretVersion
 			secrets = map[string]secret.Secret{
@@ -112,24 +94,24 @@ var appSecretGenerateCommand = cli.Command{
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secretVals, err := secret.GenerateSecrets(cl, secrets, app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if internal.Pass {
 			for name, data := range secretVals {
 				if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			}
 		}
 
 		if len(secretVals) == 0 {
-			logrus.Warn("no secrets generated")
+			log.Warn("no secrets generated")
 			os.Exit(1)
 		}
 
@@ -144,7 +126,7 @@ var appSecretGenerateCommand = cli.Command{
 		} else {
 			table.Render()
 		}
-		logrus.Warn("generated secrets are not shown again, please take note of them NOW")
+		log.Warn("generated secrets are not shown again, please take note of them NOW")
 
 		return nil
 	},
@@ -184,7 +166,7 @@ Example:
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		name := c.Args().Get(1)
@@ -194,7 +176,7 @@ Example:
 		if internal.File {
 			raw, err := os.ReadFile(data)
 			if err != nil {
-				logrus.Fatalf("reading secret from file: %s", err)
+				log.Fatalf("reading secret from file: %s", err)
 			}
 			data = string(raw)
 		}
@@ -205,14 +187,14 @@ Example:
 
 		secretName := fmt.Sprintf("%s_%s_%s", app.StackName(), name, version)
 		if err := client.StoreSecret(cl, secretName, data, app.Server); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Infof("%s successfully stored on server", secretName)
+		log.Infof("%s successfully stored on server", secretName)
 
 		if internal.Pass {
 			if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
@@ -221,19 +203,19 @@ Example:
 }
 
 // secretRm removes a secret.
-func secretRm(cl *dockerClient.Client, app config.App, secretName, parsed string) error {
+func secretRm(cl *dockerClient.Client, app appPkg.App, secretName, parsed string) error {
 	if err := cl.SecretRemove(context.Background(), secretName); err != nil {
 		return err
 	}
 
-	logrus.Infof("deleted %s successfully from server", secretName)
+	log.Infof("deleted %s successfully from server", secretName)
 
 	if internal.PassRemove {
 		if err := secret.PassRmSecret(parsed, app.StackName(), app.Server); err != nil {
 			return err
 		}
 
-		logrus.Infof("deleted %s successfully from local pass store", secretName)
+		log.Infof("deleted %s successfully from local pass store", secretName)
 	}
 
 	return nil
@@ -263,35 +245,18 @@ Example:
 `,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
-
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+			log.Fatal(err)
-			logrus.Fatal(err)
 		}
 
-		if !internal.Chaos {
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secrets, err := secret.ReadSecretsConfig(app.Path, composeFiles, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if c.Args().Get(1) != "" && rmAllSecrets {
@@ -304,17 +269,17 @@ Example:
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		filters, err := app.Filters(false, false)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: filters})
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		remoteSecretNames := make(map[string]bool)
@@ -330,7 +295,7 @@ Example:
 				if secretToRm != "" {
 					if secretName == secretToRm {
 						if err := secretRm(cl, app, secretRemoteName, secretName); err != nil {
-							logrus.Fatal(err)
+							log.Fatal(err)
 						}
 
 						return nil
@@ -339,18 +304,18 @@ Example:
 					match = true
 
 					if err := secretRm(cl, app, secretRemoteName, secretName); err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 				}
 			}
 		}
 
 		if !match && secretToRm != "" {
-			logrus.Fatalf("%s doesn't exist on server?", secretToRm)
+			log.Fatalf("%s doesn't exist on server?", secretToRm)
 		}
 
 		if !match {
-			logrus.Fatal("no secrets to remove?")
+			log.Fatal("no secrets to remove?")
 		}
 
 		return nil
@@ -371,30 +336,13 @@ var appSecretLsCommand = cli.Command{
 	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
-
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-		if err := recipe.EnsureExists(app.Recipe); err != nil {
+			log.Fatal(err)
-			logrus.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
 		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		tableCol := []string{"Name", "Version", "Generated Name", "Created On Server"}
@@ -402,7 +350,7 @@ var appSecretLsCommand = cli.Command{
 
 		secStats, err := secret.PollSecretsStatus(cl, app)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, secStat := range secStats {
@@ -422,7 +370,7 @@ var appSecretLsCommand = cli.Command{
 				table.Render()
 			}
 		} else {
-			logrus.Warnf("no secrets stored for %s", app.Name)
+			log.Warnf("no secrets stored for %s", app.Name)
 		}
 
 		return nil

cli/app/services.go

@@ -9,10 +9,10 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	containerTypes "github.com/docker/docker/api/types/container"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -28,29 +28,32 @@ var appServicesCommand = cli.Command{
 	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)
+		}
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
+		if !deployMeta.IsDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
 		filters, err := app.Filters(true, true)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		containers, err := cl.ContainerList(context.Background(), containerTypes.ListOptions{Filters: filters})
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		tableCol := []string{"service name", "image"}

cli/app/undeploy.go

@@ -3,17 +3,16 @@ package app
 import (
 	"context"
 	"fmt"
-	"time"
 
 	"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"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -28,27 +27,10 @@ var pruneFlag = &cli.BoolFlag{
 // pruneApp runs the equivalent of a "docker system prune" but only filtering
 // against resources connected with the app deployment. It is not a system wide
 // prune. Volumes are not pruned to avoid unwated data loss.
-func pruneApp(c *cli.Context, cl *dockerClient.Client, app config.App) error {
+func pruneApp(cl *dockerClient.Client, app appPkg.App) error {
 	stackName := app.StackName()
 	ctx := context.Background()
 
-	for {
-		logrus.Debugf("polling for %s stack, waiting to be undeployed...", stackName)
-
-		services, err := stack.GetStackServices(ctx, cl, stackName)
-		if err != nil {
-			return err
-		}
-
-		if len(services) == 0 {
-			logrus.Debugf("%s undeployed, moving on with pruning logic", stackName)
-			time.Sleep(time.Second) // give runtime more time to tear down related state
-			break
-		}
-
-		time.Sleep(time.Second)
-	}
-
 	pruneFilters := filters.NewArgs()
 	stackSearch := fmt.Sprintf("%s*", stackName)
 	pruneFilters.Add("label", stackSearch)
@@ -58,14 +40,14 @@ func pruneApp(c *cli.Context, cl *dockerClient.Client, app config.App) error {
 	}
 
 	cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
-	logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
+	log.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
 
 	nr, err := cl.NetworksPrune(ctx, pruneFilters)
 	if err != nil {
 		return err
 	}
 
-	logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted))
+	log.Infof("networks pruned: %d", len(nr.NetworksDeleted))
 
 	ir, err := cl.ImagesPrune(ctx, pruneFilters)
 	if err != nil {
@@ -73,7 +55,7 @@ func pruneApp(c *cli.Context, cl *dockerClient.Client, app config.App) error {
 	}
 
 	imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed)
-	logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
+	log.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
 
 	return nil
 }
@@ -96,40 +78,50 @@ This does not destroy any of the application data.
 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.
+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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Debugf("checking whether %s is already deployed", stackName)
+		log.Debugf("checking whether %s is already deployed", stackName)
 
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
+		if !deployMeta.IsDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		if err := internal.DeployOverview(app, deployedVersion, "continue with undeploy?"); err != nil {
+		chaosVersion := "false"
-			logrus.Fatal(err)
+		if deployMeta.IsChaos {
+			chaosVersion = deployMeta.ChaosVersion
 		}
 
-		rmOpts := stack.Remove{Namespaces: []string{app.StackName()}}
+		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 {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if prune {
-			if err := pruneApp(c, cl, app); err != nil {
+			if err := pruneApp(cl, app); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 

cli/app/upgrade.go

@@ -5,16 +5,15 @@ import (
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/envfile"
 	"coopcloud.tech/abra/pkg/lint"
-	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -27,7 +26,6 @@ var appUpgradeCommand = cli.Command{
 		internal.DebugFlag,
 		internal.NoInputFlag,
 		internal.ForceFlag,
-		internal.ChaosFlag,
 		internal.NoDomainChecksFlag,
 		internal.DontWaitConvergeFlag,
 		internal.OfflineFlag,
@@ -35,128 +33,94 @@ var appUpgradeCommand = cli.Command{
 	},
 	Before: internal.SubCommandBefore,
 	Description: `
-Upgrade an app. You can use it to choose and roll out a new upgrade to an
+Upgrade an app.
-existing app.
 
-This command specifically supports incrementing the version of running apps, as
+Unlike "deploy", chaos operations are not supported here. Only recipe versions
-opposed to "abra app deploy <domain>" which will not change the version of a
+are supported values for "[<version>]".
-deployed app.
 
-You may pass "--force/-f" to upgrade to the same version again. This can be
+An upgrade can be destructive, please ensure you have a copy of your app data
-useful if the container runtime has gotten into a weird state.
+beforehand.
 
-This action could be destructive, please ensure you have a copy of your app
+EXAMPLE:
-data beforehand.
 
-Chaos mode ("--chaos") will deploy your local checkout of a recipe as-is,
+    abra app upgrade foo.example.com
-including unstaged changes and can be useful for live hacking and testing new
+    abra app upgrade foo.example.com 1.2.3+3.2.1`,
-recipes.
-`,
 	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 		stackName := app.StackName()
 
-		specificVersion := c.Args().Get(1)
+		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-		if specificVersion != "" && internal.Chaos {
+			log.Fatal(err)
-			logrus.Fatal("cannot use <version> and --chaos together")
 		}
 
-		if !internal.Chaos {
+		if err := lint.LintForErrors(app.Recipe); err != nil {
-			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
+			log.Fatal(err)
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
 		}
 
-		recipe, err := recipePkg.Get(app.Recipe, internal.Offline)
+		log.Debugf("checking whether %s is already deployed", stackName)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := lint.LintForErrors(recipe); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if !isDeployed {
+		if !deployMeta.IsDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
+			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline)
+		versions, err := app.Recipe.Tags()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
-		}
-
-		versions, err := recipePkg.GetRecipeCatalogueVersions(app.Recipe, catl)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if len(versions) == 0 && !internal.Chaos {
-			logrus.Warn("no published versions in catalogue, trying local recipe repository")
-			recipeVersions, err := recipePkg.GetRecipeVersions(app.Recipe, internal.Offline)
-			if err != nil {
-				logrus.Warn(err)
-			}
-			for _, recipeVersion := range recipeVersions {
-				for version := range recipeVersion {
-					versions = append(versions, version)
-				}
-			}
 		}
 
 		var availableUpgrades []string
-		if deployedVersion == "unknown" {
+		if deployMeta.Version == "unknown" {
 			availableUpgrades = versions
-			logrus.Warnf("failed to determine deployed version of %s", app.Name)
+			log.Warnf("failed to determine deployed version of %s", app.Name)
 		}
 
+		specificVersion := c.Args().Get(1)
 		if specificVersion != "" {
-			parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
+			parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatalf("'%s' is not a known version for %s", deployMeta.Version, app.Recipe.Name)
 			}
 			parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatalf("'%s' is not a known version for %s", specificVersion, app.Recipe.Name)
 			}
-			if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) {
+
-				logrus.Fatalf("%s is not an upgrade for %s?", deployedVersion, specificVersion)
+			if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) && !parsedSpecificVersion.Equals(parsedDeployedVersion) {
+				log.Fatalf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
 			}
+
+			if parsedSpecificVersion.Equals(parsedDeployedVersion) && !internal.Force {
+				log.Fatalf("%s is not an upgrade for %s?", deployMeta.Version, specificVersion)
+			}
+
 			availableUpgrades = append(availableUpgrades, specificVersion)
 		}
 
-		parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
+		parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if deployedVersion != "unknown" && !internal.Chaos && specificVersion == "" {
+		if deployMeta.Version != "unknown" && specificVersion == "" {
+			if deployMeta.IsChaos {
+				log.Warn("attempting to upgrade a chaos deployment")
+			}
+
 			for _, version := range versions {
 				parsedVersion, err := tagcmp.Parse(version)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 				if parsedVersion.IsGreaterThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
 					availableUpgrades = append(availableUpgrades, version)
@@ -164,21 +128,27 @@ recipes.
 			}
 
 			if len(availableUpgrades) == 0 && !internal.Force {
-				logrus.Infof("no available upgrades, you're on latest (%s) ✌️", deployedVersion)
+				log.Info("no available upgrades")
 				return nil
 			}
 		}
 
 		var chosenUpgrade string
-		if len(availableUpgrades) > 0 && !internal.Chaos {
+		if len(availableUpgrades) > 0 {
 			if internal.Force || internal.NoInput || specificVersion != "" {
 				chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
-				logrus.Debugf("choosing %s as version to upgrade to", chosenUpgrade)
+				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: fmt.Sprintf("Please select an upgrade (current version: %s):", deployedVersion),
+					Message: msg,
 					Options: internal.ReverseStringList(availableUpgrades),
 				}
+
 				if err := survey.AskOne(prompt, &chosenUpgrade); err != nil {
 					return err
 				}
@@ -186,8 +156,8 @@ recipes.
 		}
 
 		if internal.Force && chosenUpgrade == "" {
-			logrus.Warnf("%s is already upgraded to latest but continuing (--force/--chaos)", app.Name)
+			log.Warnf("%s is already upgraded to latest but continuing (--force)", app.Name)
-			chosenUpgrade = deployedVersion
+			chosenUpgrade = deployMeta.Version
 		}
 
 		// if release notes written after git tag published, read them before we
@@ -197,15 +167,15 @@ recipes.
 		if chosenUpgrade != "" {
 			parsedChosenUpgrade, err := tagcmp.Parse(chosenUpgrade)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 			for _, version := range versions {
 				parsedVersion, err := tagcmp.Parse(version)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 				if parsedVersion.IsGreaterThan(parsedDeployedVersion) && parsedVersion.IsLessThan(parsedChosenUpgrade) {
-					note, err := internal.GetReleaseNotes(app.Recipe, version)
+					note, err := app.Recipe.GetReleaseNotes(version)
 					if err != nil {
 						return err
 					}
@@ -216,58 +186,51 @@ recipes.
 			}
 		}
 
-		if !internal.Chaos {
+		log.Debugf("choosing %s as version to upgrade", chosenUpgrade)
-			if err := recipePkg.EnsureVersion(app.Recipe, chosenUpgrade); err != nil {
+		if _, err := app.Recipe.EnsureVersion(chosenUpgrade); err != nil {
-				logrus.Fatal(err)
+			log.Fatal(err)
-			}
 		}
 
-		if internal.Chaos {
+		abraShEnv, err := envfile.ReadAbraShEnvVars(app.Recipe.AbraShPath)
-			logrus.Warn("chaos mode engaged")
-			var err error
-			chosenUpgrade, err = recipePkg.ChaosVersion(app.Recipe)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
-		abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		for k, v := range abraShEnv {
 			app.Env[k] = v
 		}
 
-		composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
+		composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
+
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
 			Prune:        false,
 			ResolveImage: stack.ResolveImageAlways,
+			Detach:       false,
 		}
-		compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		config.ExposeAllEnv(stackName, compose, app.Env)
-		config.SetRecipeLabel(compose, stackName, app.Recipe)
-		config.SetChaosLabel(compose, stackName, internal.Chaos)
-		config.SetChaosVersionLabel(compose, stackName, chosenUpgrade)
-		config.SetUpdateLabel(compose, stackName, app.Env)
 
-		envVars, err := config.CheckEnv(app)
+		compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
+		}
+
+		appPkg.ExposeAllEnv(stackName, compose, app.Env)
+		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
+		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
+		appPkg.SetChaosVersionLabel(compose, stackName, chosenUpgrade)
+		appPkg.SetUpdateLabel(compose, stackName, app.Env)
+
+		envVars, err := appPkg.CheckEnv(app)
+		if err != nil {
+			log.Fatal(err)
 		}
 
 		for _, envVar := range envVars {
 			if !envVar.Present {
-				logrus.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain)
+				log.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain)
 			}
 		}
 
@@ -277,25 +240,37 @@ recipes.
 			return nil
 		}
 
-		if err := internal.NewVersionOverview(app, deployedVersion, chosenUpgrade, releaseNotes); err != nil {
+		chaosVersion := "false"
-			logrus.Fatal(err)
+		if deployMeta.IsChaos {
+			chaosVersion = deployMeta.ChaosVersion
 		}
 
-		stack.WaitTimeout, err = config.GetTimeoutFromLabel(compose, stackName)
+		if err := internal.NewVersionOverview(app, deployMeta.Version, chaosVersion, chosenUpgrade, releaseNotes); err != nil {
-		if err != nil {
+			log.Fatal(err)
-			logrus.Fatal(err)
 		}
-		logrus.Debugf("set waiting timeout to %d s", stack.WaitTimeout)
+
+		stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Debugf("set waiting timeout to %d s", stack.WaitTimeout)
 
 		if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		postDeployCmds, ok := app.Env["POST_UPGRADE_CMDS"]
 		if ok && !internal.DontWaitConverge {
-			logrus.Debugf("run the following post-deploy commands: %s", postDeployCmds)
+			log.Debugf("run the following post-deploy commands: %s", postDeployCmds)
 			if err := internal.PostCmds(cl, app, postDeployCmds); err != nil {
-				logrus.Fatalf("attempting to run post deploy commands, saw: %s", err)
+				log.Fatalf("attempting to run post deploy commands, saw: %s", err)
+			}
+		}
+
+		if app.Recipe.Version != "" {
+			err := app.WriteRecipeVersion(chosenUpgrade)
+			if err != nil {
+				log.Fatalf("writing new recipe version in env file: %s", err)
 			}
 		}
 

cli/app/version.go

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

cli/app/volume.go

@@ -2,15 +2,14 @@ package app
 
 import (
 	"context"
-	"log"
 
 	"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/stack"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -30,17 +29,17 @@ var appVolumeListCommand = cli.Command{
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		filters, err := app.Filters(false, true)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, filters)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		table := formatter.CreateTable([]string{"name", "created", "mounted"})
@@ -55,7 +54,7 @@ var appVolumeListCommand = cli.Command{
 		if table.NumLines() > 0 {
 			table.Render()
 		} else {
-			logrus.Warnf("no volumes created for %s", app.Name)
+			log.Warnf("no volumes created for %s", app.Name)
 		}
 
 		return nil
@@ -74,8 +73,7 @@ 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.
+Passing "--force/-f" will select all volumes for removal. Be careful.`,
-`,
 	ArgsUsage: "<domain>",
 	Aliases:   []string{"rm"},
 	Flags: []cli.Flag{
@@ -90,26 +88,26 @@ Passing "--force/-f" will select all volumes for removal. Be careful.
 
 		cl, err := client.New(app.Server)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, app.StackName())
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		if isDeployed {
+		if deployMeta.IsDeployed {
-			logrus.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name)
+			log.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name)
 		}
 
 		filters, err := app.Filters(false, true)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, filters)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		volumeNames := client.GetVolumeNames(volumeList)
 
@@ -123,7 +121,7 @@ Passing "--force/-f" will select all volumes for removal. Be careful.
 				Default: volumeNames,
 			}
 			if err := survey.AskOne(volumesPrompt, &volumesToRemove); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
@@ -137,9 +135,9 @@ Passing "--force/-f" will select all volumes for removal. Be careful.
 				log.Fatalf("removing volumes failed: %s", err)
 			}
 
-			logrus.Infof("%d volumes removed successfully", len(volumesToRemove))
+			log.Infof("%d volumes removed successfully", len(volumesToRemove))
 		} else {
-			logrus.Info("no volumes removed")
+			log.Info("no volumes removed")
 		}
 
 		return nil

cli/catalogue/catalogue.go

@@ -12,9 +12,9 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -33,14 +33,7 @@ var catalogueGenerateCommand = cli.Command{
 	},
 	Before: internal.SubCommandBefore,
 	Description: `
-Generate a new copy of the recipe catalogue which can be found on:
+Generate a new copy of the recipe catalogue.
-
-    https://recipes.coopcloud.tech (website that humans read)
-    https://recipes.coopcloud.tech/recipes.json (JSON that Abra reads)
-
-It polls the entire git.coopcloud.tech/coop-cloud/... recipe repository
-listing, parses README.md and git tags to produce recipe metadata which is
-loaded into the catalogue JSON file.
 
 It is possible to generate new metadata for a single recipe by passing
 <recipe>. The existing local catalogue will be updated, not overwritten.
@@ -51,12 +44,12 @@ If you have a Hub account you can have Abra log you in to avoid this. Pass
 
 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.
+keys configured on your account.`,
-`,
 	ArgsUsage:    "[<recipe>]",
 	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
 		recipeName := c.Args().First()
+		r := recipe.Get(recipeName)
 
 		if recipeName != "" {
 			internal.ValidateRecipe(c)
@@ -64,13 +57,13 @@ keys configured on your account.
 
 		if !internal.Chaos {
 			if err := catalogue.EnsureIsClean(); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		repos, err := recipe.ReadReposMetadata()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		var barLength int
@@ -84,9 +77,9 @@ keys configured on your account.
 		}
 
 		if !internal.SkipUpdates {
-			logrus.Warn(logMsg)
+			log.Warn(logMsg)
 			if err := recipe.UpdateRepositories(repos, recipeName); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
@@ -98,14 +91,14 @@ keys configured on your account.
 				continue
 			}
 
-			versions, err := recipe.GetRecipeVersions(recipeMeta.Name, internal.Offline)
+			versions, err := r.GetRecipeVersions()
 			if err != nil {
-				logrus.Warn(err)
+				log.Warn(err)
 			}
 
-			features, category, err := recipe.GetRecipeFeaturesAndCategory(recipeMeta.Name)
+			features, category, err := recipe.GetRecipeFeaturesAndCategory(r)
 			if err != nil {
-				logrus.Warn(err)
+				log.Warn(err)
 			}
 
 			catl[recipeMeta.Name] = recipe.RecipeMeta{
@@ -126,84 +119,84 @@ keys configured on your account.
 
 		recipesJSON, err := json.MarshalIndent(catl, "", "    ")
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if recipeName == "" {
 			if err := ioutil.WriteFile(config.RECIPES_JSON, recipesJSON, 0764); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		} else {
 			catlFS, err := recipe.ReadRecipeCatalogue(internal.Offline)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			catlFS[recipeName] = catl[recipeName]
 
 			updatedRecipesJSON, err := json.MarshalIndent(catlFS, "", "    ")
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if err := ioutil.WriteFile(config.RECIPES_JSON, updatedRecipesJSON, 0764); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
-		logrus.Infof("generated new recipe catalogue in %s", config.RECIPES_JSON)
+		log.Infof("generated new recipe catalogue in %s", config.RECIPES_JSON)
 
 		cataloguePath := path.Join(config.ABRA_DIR, "catalogue")
 		if internal.Publish {
 
 			isClean, err := gitPkg.IsClean(cataloguePath)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if isClean {
 				if !internal.Dry {
-					logrus.Fatalf("no changes discovered in %s, nothing to publish?", cataloguePath)
+					log.Fatalf("no changes discovered in %s, nothing to publish?", cataloguePath)
 				}
 			}
 
 			msg := "chore: publish new catalogue release changes"
 			if err := gitPkg.Commit(cataloguePath, msg, internal.Dry); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			repo, err := git.PlainOpen(cataloguePath)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			sshURL := fmt.Sprintf(config.SSH_URL_TEMPLATE, config.CATALOGUE_JSON_REPO_NAME)
 			if err := gitPkg.CreateRemote(repo, "origin-ssh", sshURL, internal.Dry); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if err := gitPkg.Push(cataloguePath, "origin-ssh", false, internal.Dry); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		repo, err := git.PlainOpen(cataloguePath)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		head, err := repo.Head()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !internal.Dry && internal.Publish {
 			url := fmt.Sprintf("%s/%s/commit/%s", config.REPOS_BASE_URL, config.CATALOGUE_JSON_REPO_NAME, head.Hash())
-			logrus.Infof("new changes published: %s", url)
+			log.Infof("new changes published: %s", url)
 		}
 
 		if internal.Dry {
-			logrus.Info("dry run: no changes published")
+			log.Info("dry run: no changes published")
 		}
 
 		return nil
@@ -212,11 +205,10 @@ keys configured on your account.
 
 // CatalogueCommand defines the `abra catalogue` command and sub-commands.
 var CatalogueCommand = cli.Command{
-	Name:        "catalogue",
+	Name:      "catalogue",
-	Usage:       "Manage the recipe catalogue",
+	Usage:     "Manage the recipe catalogue",
-	Aliases:     []string{"c"},
+	Aliases:   []string{"c"},
-	ArgsUsage:   "<recipe>",
+	ArgsUsage: "<recipe>",
-	Description: "This command helps recipe packagers interact with the recipe catalogue",
 	Subcommands: []cli.Command{
 		catalogueGenerateCommand,
 	},

cli/cli.go

@@ -14,10 +14,10 @@ import (
 	"coopcloud.tech/abra/cli/recipe"
 	"coopcloud.tech/abra/cli/server"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	cataloguePkg "coopcloud.tech/abra/pkg/catalogue"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/web"
-	"github.com/sirupsen/logrus"
+	charmLog "github.com/charmbracelet/log"
 	"github.com/urfave/cli"
 )
 
@@ -25,16 +25,15 @@ import (
 var AutoCompleteCommand = cli.Command{
 	Name:    "autocomplete",
 	Aliases: []string{"ac"},
-	Usage:   "Configure shell autocompletion (recommended)",
+	Usage:   "Configure shell autocompletion",
 	Description: `
-Set up auto-completion in your shell by downloading the relevant files and
+Set up shell auto-completion.
-laying out what additional information must be loaded. Supported shells are as
-follows: bash, fish, fizsh & zsh.
 
-Example:
+Supported shells are: bash, fish, fizsh & zsh.
 
-    abra autocomplete bash
+EXAMPLE:
-`,
+
+    abra autocomplete bash`,
 	ArgsUsage: "<shell>",
 	Flags: []cli.Flag{
 		internal.DebugFlag,
@@ -54,7 +53,7 @@ Example:
 		}
 
 		if _, ok := supportedShells[shellType]; !ok {
-			logrus.Fatalf("%s is not a supported shell right now, sorry", shellType)
+			log.Fatalf("%s is not a supported shell right now, sorry", shellType)
 		}
 
 		if shellType == "fizsh" {
@@ -64,24 +63,24 @@ Example:
 		autocompletionDir := path.Join(config.ABRA_DIR, "autocompletion")
 		if err := os.Mkdir(autocompletionDir, 0764); err != nil {
 			if !os.IsExist(err) {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
-			logrus.Debugf("%s already created", autocompletionDir)
+			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)
-			logrus.Infof("fetching %s", url)
+			log.Infof("fetching %s", url)
 			if err := web.GetFile(autocompletionFile, url); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		switch shellType {
 		case "bash":
 			fmt.Println(fmt.Sprintf(`
-# Run the following commands to install auto-completion
+# 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
@@ -89,19 +88,19 @@ echo "source /etc/bash_completion.d/abra" >> ~/.bashrc
 `, autocompletionFile))
 		case "zsh":
 			fmt.Println(fmt.Sprintf(`
-# Run the following commands to install auto-completion
+# 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!
+# 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
+# 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!
+# to test, run the following: "abra app <hit tab key>" - you should see command completion!
 `, autocompletionFile))
 		}
 
@@ -113,14 +112,18 @@ echo "source /etc/fish/completions/abra" >> ~/.config/fish/config.fish
 var UpgradeCommand = cli.Command{
 	Name:    "upgrade",
 	Aliases: []string{"u"},
-	Usage:   "Upgrade Abra itself",
+	Usage:   "Upgrade abra",
 	Description: `
-Upgrade Abra in-place with the latest stable or release candidate.
+Upgrade abra in-place with the latest stable or release candidate.
 
-Pass "-r/--rc" to install the latest release candidate. Please bear in mind
+Use "-r/--rc" to install the latest release candidate. Please bear in mind that
-that it may contain catastrophic bugs. Thank you very much for the testing
+it may contain absolutely catastrophic deal-breaker bugs. Thank you very much
-efforts!
+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"
@@ -131,10 +134,10 @@ efforts!
 			cmd = exec.Command("bash", "-c", fmt.Sprintf("wget -q -O- %s | bash -s -- --rc", releaseCandidateURL))
 		}
 
-		logrus.Debugf("attempting to run %s", cmd)
+		log.Debugf("attempting to run %s", cmd)
 
 		if err := internal.RunCmd(cmd); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil
@@ -144,7 +147,7 @@ efforts!
 func newAbraApp(version, commit string) *cli.App {
 	app := &cli.App{
 		Name: "abra",
-		Usage: `The Co-op Cloud command-line utility belt 🎩🐇
+		Usage: `the Co-op Cloud command-line utility belt 🎩🐇
     ____                           ____ _                 _
    / ___|___         ___  _ __    / ___| | ___  _   _  __| |
   | |   / _ \ _____ / _ \| '_ \  | |   | |/ _ \| | | |/ _' |
@@ -178,17 +181,14 @@ func newAbraApp(version, commit string) *cli.App {
 		for _, path := range paths {
 			if err := os.Mkdir(path, 0764); err != nil {
 				if !os.IsExist(err) {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 				continue
 			}
 		}
 
-		if err := cataloguePkg.EnsureCatalogue(); err != nil {
+		charmLog.SetDefault(log.Logger)
-			logrus.Fatal(err)
+		log.Debugf("abra version %s, commit %s", version, commit)
-		}
-
-		logrus.Debugf("abra version %s, commit %s", version, commit)
 
 		return nil
 	}
@@ -201,6 +201,6 @@ func RunApp(version, commit string) {
 	app := newAbraApp(version, commit)
 
 	if err := app.Run(os.Args); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 }

cli/internal/backup.go

@@ -5,13 +5,13 @@ import (
 
 	"coopcloud.tech/abra/pkg/config"
 	containerPkg "coopcloud.tech/abra/pkg/container"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/service"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
 // RetrieveBackupBotContainer gets the deployed backupbot container.
@@ -22,7 +22,7 @@ func RetrieveBackupBotContainer(cl *dockerClient.Client) (types.Container, error
 		return types.Container{}, err
 	}
 
-	logrus.Debugf("retrieved %s as backup enabled service", chosenService.Spec.Name)
+	log.Debugf("retrieved %s as backup enabled service", chosenService.Spec.Name)
 
 	filters := filters.NewArgs()
 	filters.Add("name", chosenService.Spec.Name)
@@ -51,7 +51,7 @@ func RunBackupCmdRemote(cl *dockerClient.Client, backupCmd string, containerID s
 		Tty:          true,
 	}
 
-	logrus.Debugf("running backup %s on %s with exec config %v", backupCmd, containerID, execBackupListOpts)
+	log.Debugf("running backup %s on %s with exec config %v", backupCmd, containerID, execBackupListOpts)
 
 	// FIXME: avoid instantiating a new CLI
 	dcli, err := command.NewDockerCli()

cli/internal/cli.go

@@ -3,8 +3,7 @@ package internal
 import (
 	"os"
 
-	logrusStack "github.com/Gurpartap/logrus-stack"
+	"coopcloud.tech/abra/pkg/log"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -193,7 +192,7 @@ var NewAppServerFlag = &cli.StringFlag{
 var NoDomainChecks bool
 var NoDomainChecksFlag = &cli.BoolFlag{
 	Name:        "no-domain-checks, D",
-	Usage:       "Disable app domain sanity checks",
+	Usage:       "Disable public DNS checks",
 	Destination: &NoDomainChecks,
 }
 
@@ -262,13 +261,35 @@ var RemoteUserFlag = &cli.StringFlag{
 	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 {
-		logrus.SetLevel(logrus.DebugLevel)
+		log.SetLevel(log.DebugLevel)
-		logrus.SetFormatter(&logrus.TextFormatter{})
+		log.SetOutput(os.Stderr)
-		logrus.SetOutput(os.Stderr)
+		log.SetReportCaller(true)
-		logrus.AddHook(logrusStack.StandardHook())
 	}
 
 	return nil

cli/internal/command.go

@@ -8,20 +8,20 @@ import (
 	"os/exec"
 	"strings"
 
-	"coopcloud.tech/abra/pkg/config"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	containerPkg "coopcloud.tech/abra/pkg/container"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/sirupsen/logrus"
 )
 
 // RunCmdRemote executes an abra.sh command in the target service
-func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName, cmdName, cmdArgs string) error {
+func RunCmdRemote(cl *dockerClient.Client, app appPkg.App, abraSh, serviceName, cmdName, cmdArgs string) error {
 	filters := filters.NewArgs()
 	filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), serviceName))
 
@@ -30,7 +30,7 @@ func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName,
 		return err
 	}
 
-	logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(targetContainer.ID), app.Server)
+	log.Debugf("retrieved %s as target container on %s", formatter.ShortenID(targetContainer.ID), app.Server)
 
 	toTarOpts := &archive.TarOptions{NoOverwriteDirNonDir: true, Compression: archive.Gzip}
 	content, err := archive.TarWithOptions(abraSh, toTarOpts)
@@ -61,7 +61,7 @@ func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName,
 	}
 
 	if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
-		logrus.Infof("%s does not exist for %s, use /bin/sh as fallback", shell, app.Name)
+		log.Infof("%s does not exist for %s, use /bin/sh as fallback", shell, app.Name)
 		shell = "/bin/sh"
 	}
 
@@ -72,10 +72,10 @@ func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName,
 		cmd = []string{shell, "-c", fmt.Sprintf("TARGET=%s; APP_NAME=%s; STACK_NAME=%s; . /tmp/abra.sh; %s", serviceName, app.Name, app.StackName(), cmdName)}
 	}
 
-	logrus.Debugf("running command: %s", strings.Join(cmd, " "))
+	log.Debugf("running command: %s", strings.Join(cmd, " "))
 
 	if RemoteUser != "" {
-		logrus.Debugf("running command with user %s", RemoteUser)
+		log.Debugf("running command with user %s", RemoteUser)
 		execCreateOpts.User = RemoteUser
 	}
 

cli/internal/deploy.go

@@ -2,21 +2,19 @@ package internal
 
 import (
 	"fmt"
-	"io/ioutil"
 	"os"
-	"path"
 	"strings"
 
-	"coopcloud.tech/abra/pkg/config"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
 // NewVersionOverview shows an upgrade or downgrade overview
-func NewVersionOverview(app config.App, currentVersion, newVersion, releaseNotes string) error {
+func NewVersionOverview(app appPkg.App, currentVersion, chaosVersion, newVersion, releaseNotes string) error {
-	tableCol := []string{"server", "recipe", "config", "domain", "current version", "to be deployed"}
+	tableCol := []string{"server", "recipe", "config", "domain", "version", "chaos", "to deploy"}
 	table := formatter.CreateTable(tableCol)
 
 	deployConfig := "compose.yml"
@@ -29,14 +27,22 @@ func NewVersionOverview(app config.App, currentVersion, newVersion, releaseNotes
 		server = "local"
 	}
 
-	table.Append([]string{server, app.Recipe, deployConfig, app.Domain, currentVersion, newVersion})
+	table.Append([]string{
+		server,
+		app.Recipe.Name,
+		deployConfig,
+		app.Domain,
+		currentVersion,
+		chaosVersion,
+		newVersion,
+	})
 	table.Render()
 
 	if releaseNotes != "" && newVersion != "" {
 		fmt.Println()
 		fmt.Print(releaseNotes)
 	} else {
-		logrus.Warnf("no release notes available for %s", newVersion)
+		log.Warnf("no release notes available for %s", newVersion)
 	}
 
 	if NoInput {
@@ -53,40 +59,19 @@ func NewVersionOverview(app config.App, currentVersion, newVersion, releaseNotes
 	}
 
 	if !response {
-		logrus.Fatal("exiting as requested")
+		log.Fatal("exiting as requested")
 	}
 
 	return nil
 }
 
-// GetReleaseNotes prints release notes for a recipe version
-func GetReleaseNotes(recipeName, version string) (string, error) {
-	if version == "" {
-		return "", nil
-	}
-
-	fpath := path.Join(config.RECIPES_DIR, recipeName, "release", version)
-
-	if _, err := os.Stat(fpath); !os.IsNotExist(err) {
-		releaseNotes, err := ioutil.ReadFile(fpath)
-		if err != nil {
-			return "", err
-		}
-		withTitle := fmt.Sprintf("%s release notes:\n%s", version, string(releaseNotes))
-		return withTitle, nil
-	}
-
-	return "", nil
-}
-
 // PostCmds parses a string of commands and executes them inside of the respective services
 // the commands string must have the following format:
 // "<service> <command> <arguments>|<service> <command> <arguments>|... "
-func PostCmds(cl *dockerClient.Client, app config.App, commands string) error {
+func PostCmds(cl *dockerClient.Client, app appPkg.App, commands string) error {
-	abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
+	if _, err := os.Stat(app.Recipe.AbraShPath); err != nil {
-	if _, err := os.Stat(abraSh); err != nil {
 		if os.IsNotExist(err) {
-			return fmt.Errorf(fmt.Sprintf("%s does not exist for %s?", abraSh, app.Name))
+			return fmt.Errorf(fmt.Sprintf("%s does not exist for %s?", app.Recipe.AbraShPath, app.Name))
 		}
 		return err
 	}
@@ -102,13 +87,13 @@ func PostCmds(cl *dockerClient.Client, app config.App, commands string) error {
 		if len(commandParts) > 2 {
 			parsedCmdArgs = fmt.Sprintf("%s ", strings.Join(commandParts[2:], " "))
 		}
-		logrus.Infof("running post-command '%s %s' in container %s", cmdName, parsedCmdArgs, targetServiceName)
+		log.Infof("running post-command '%s %s' in container %s", cmdName, parsedCmdArgs, targetServiceName)
 
-		if err := EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
+		if err := EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
 			return err
 		}
 
-		serviceNames, err := config.GetAppServiceNames(app.Name)
+		serviceNames, err := appPkg.GetAppServiceNames(app.Name)
 		if err != nil {
 			return err
 		}
@@ -124,10 +109,10 @@ func PostCmds(cl *dockerClient.Client, app config.App, commands string) error {
 			return fmt.Errorf(fmt.Sprintf("no service %s for %s?", targetServiceName, app.Name))
 		}
 
-		logrus.Debugf("running command %s %s within the context of %s_%s", cmdName, parsedCmdArgs, app.StackName(), targetServiceName)
+		log.Debugf("running command %s %s within the context of %s_%s", cmdName, parsedCmdArgs, app.StackName(), targetServiceName)
 
 		Tty = true
-		if err := RunCmdRemote(cl, app, abraSh, targetServiceName, cmdName, parsedCmdArgs); err != nil {
+		if err := RunCmdRemote(cl, app, app.Recipe.AbraShPath, targetServiceName, cmdName, parsedCmdArgs); err != nil {
 			return err
 		}
 	}
@@ -135,8 +120,8 @@ func PostCmds(cl *dockerClient.Client, app config.App, commands string) error {
 }
 
 // DeployOverview shows a deployment overview
-func DeployOverview(app config.App, version, message string) error {
+func DeployOverview(app appPkg.App, version, chaosVersion, message string) error {
-	tableCol := []string{"server", "recipe", "config", "domain", "version"}
+	tableCol := []string{"server", "recipe", "config", "domain", "version", "chaos"}
 	table := formatter.CreateTable(tableCol)
 
 	deployConfig := "compose.yml"
@@ -149,7 +134,14 @@ func DeployOverview(app config.App, version, message string) error {
 		server = "local"
 	}
 
-	table.Append([]string{server, app.Recipe, deployConfig, app.Domain, version})
+	table.Append([]string{
+		server,
+		app.Recipe.Name,
+		deployConfig,
+		app.Domain,
+		version,
+		chaosVersion,
+	})
 	table.Render()
 
 	if NoInput {
@@ -166,7 +158,7 @@ func DeployOverview(app config.App, version, message string) error {
 	}
 
 	if !response {
-		logrus.Fatal("exiting as requested")
+		log.Fatal("exiting as requested")
 	}
 
 	return nil

cli/internal/errors.go

@@ -3,7 +3,7 @@ package internal
 import (
 	"os"
 
-	"github.com/sirupsen/logrus"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/urfave/cli"
 )
 
@@ -11,8 +11,8 @@ import (
 // terminal, and shows the help command.
 func ShowSubcommandHelpAndError(c *cli.Context, err interface{}) {
 	if err2 := cli.ShowSubcommandHelp(c); err2 != nil {
-		logrus.Error(err2)
+		log.Error(err2)
 	}
-	logrus.Error(err)
+	log.Error(err)
 	os.Exit(1)
 }

cli/internal/recipe.go

@@ -4,10 +4,10 @@ import (
 	"fmt"
 
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
-	"github.com/sirupsen/logrus"
 )
 
 // PromptBumpType prompts for version bump type
@@ -65,7 +65,7 @@ func GetBumpType() string {
 	} else if Patch {
 		bumpType = "patch"
 	} else {
-		logrus.Fatal("no version bump type specififed?")
+		log.Fatal("no version bump type specififed?")
 	}
 
 	return bumpType
@@ -80,7 +80,7 @@ func SetBumpType(bumpType string) {
 	} else if bumpType == "patch" {
 		Patch = true
 	} else {
-		logrus.Fatal("no version bump type specififed?")
+		log.Fatal("no version bump type specififed?")
 	}
 }
 
@@ -88,7 +88,11 @@ func SetBumpType(bumpType string) {
 func GetMainAppImage(recipe recipe.Recipe) (string, error) {
 	var path string
 
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return "", err
+	}
+	for _, service := range config.Services {
 		if service.Name == "app" {
 			img, err := reference.ParseNormalizedNamed(service.Image)
 			if err != nil {

cli/internal/validate.go

@@ -6,9 +6,9 @@ import (
 
 	"coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -21,7 +21,7 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe {
 
 		catl, err := recipe.ReadRecipeCatalogue(Offline)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		knownRecipes := make(map[string]bool)
@@ -31,7 +31,7 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe {
 
 		localRecipes, err := recipe.GetRecipesLocal()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, recipeLocal := range localRecipes {
@@ -49,7 +49,7 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe {
 			Options: recipes,
 		}
 		if err := survey.AskOne(prompt, &recipeName); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 	}
 
@@ -57,28 +57,33 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe {
 		ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
 	}
 
-	chosenRecipe, err := recipe.Get(recipeName, Offline)
+	chosenRecipe := recipe.Get(recipeName)
+	err := chosenRecipe.EnsureExists()
+	if err != nil {
+		log.Fatal(err)
+	}
+	_, err = chosenRecipe.GetComposeConfig(nil)
 	if err != nil {
 		if c.Command.Name == "generate" {
 			if strings.Contains(err.Error(), "missing a compose") {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
-			logrus.Warn(err)
+			log.Warn(err)
 		} else {
 			if strings.Contains(err.Error(), "template_driver is not allowed") {
-				logrus.Warnf("ensure %s recipe compose.* files include \"version: '3.8'\"", recipeName)
+				log.Warnf("ensure %s recipe compose.* files include \"version: '3.8'\"", recipeName)
 			}
-			logrus.Fatalf("unable to validate recipe: %s", err)
+			log.Fatalf("unable to validate recipe: %s", err)
 		}
 	}
 
-	logrus.Debugf("validated %s as recipe argument", recipeName)
+	log.Debugf("validated %s as recipe argument", recipeName)
 
 	return chosenRecipe
 }
 
 // ValidateApp ensures the app name arg is valid.
-func ValidateApp(c *cli.Context) config.App {
+func ValidateApp(c *cli.Context) app.App {
 	appName := c.Args().First()
 
 	if appName == "" {
@@ -87,10 +92,10 @@ func ValidateApp(c *cli.Context) config.App {
 
 	app, err := app.Get(appName)
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
-	logrus.Debugf("validated %s as app argument", appName)
+	log.Debugf("validated %s as app argument", appName)
 
 	return app
 }
@@ -105,7 +110,7 @@ func ValidateDomain(c *cli.Context) string {
 			Default: "example.com",
 		}
 		if err := survey.AskOne(prompt, &domainName); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 	}
 
@@ -113,7 +118,7 @@ func ValidateDomain(c *cli.Context) string {
 		ShowSubcommandHelpAndError(c, errors.New("no domain provided"))
 	}
 
-	logrus.Debugf("validated %s as domain argument", domainName)
+	log.Debugf("validated %s as domain argument", domainName)
 
 	return domainName
 }
@@ -138,7 +143,7 @@ func ValidateServer(c *cli.Context) string {
 
 	serverNames, err := config.ReadServerNames()
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	if serverName == "" && !NoInput {
@@ -147,7 +152,7 @@ func ValidateServer(c *cli.Context) string {
 			Options: serverNames,
 		}
 		if err := survey.AskOne(prompt, &serverName); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 	}
 
@@ -166,7 +171,7 @@ func ValidateServer(c *cli.Context) string {
 		ShowSubcommandHelpAndError(c, errors.New("server doesn't exist?"))
 	}
 
-	logrus.Debugf("validated %s as server argument", serverName)
+	log.Debugf("validated %s as server argument", serverName)
 
 	return serverName
 }

cli/recipe/diff.go

@@ -1,20 +1,17 @@
 package recipe
 
 import (
-	"path"
-
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
 	gitPkg "coopcloud.tech/abra/pkg/git"
-	"github.com/sirupsen/logrus"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/urfave/cli"
 )
 
 var recipeDiffCommand = cli.Command{
 	Name:        "diff",
 	Usage:       "Show unstaged changes in recipe config",
-	Description: "Due to limitations in our underlying Git dependency, this command requires /usr/bin/git.",
+	Description: "This command requires /usr/bin/git.",
 	Aliases:     []string{"d"},
 	ArgsUsage:   "<recipe>",
 	Flags: []cli.Flag{
@@ -24,15 +21,10 @@ var recipeDiffCommand = cli.Command{
 	Before:       internal.SubCommandBefore,
 	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
-		recipeName := c.Args().First()
+		r := internal.ValidateRecipe(c)
 
-		if recipeName != "" {
+		if err := gitPkg.DiffUnstaged(r.Dir); err != nil {
-			internal.ValidateRecipe(c)
+			log.Fatal(err)
-		}
-
-		recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-		if err := gitPkg.DiffUnstaged(recipeDir); err != nil {
-			logrus.Fatal(err)
 		}
 
 		return nil

cli/recipe/fetch.go

@@ -4,8 +4,8 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -24,23 +24,25 @@ var recipeFetchCommand = cli.Command{
 	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
 		recipeName := c.Args().First()
+		r := recipe.Get(recipeName)
 		if recipeName != "" {
 			internal.ValidateRecipe(c)
-			if err := recipe.Ensure(recipeName); err != nil {
+			if err := r.Ensure(false, false); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 			return nil
 		}
 
 		catalogue, err := recipe.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		catlBar := formatter.CreateProgressbar(len(catalogue), "fetching latest recipes...")
 		for recipeName := range catalogue {
-			if err := recipe.Ensure(recipeName); err != nil {
+			r := recipe.Get(recipeName)
-				logrus.Error(err)
+			if err := r.Ensure(false, false); err != nil {
+				log.Error(err)
 			}
 			catlBar.Add(1)
 		}

cli/recipe/lint.go

@@ -7,8 +7,7 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/lint"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/log"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -29,24 +28,8 @@ var recipeLintCommand = cli.Command{
 	Action: func(c *cli.Context) error {
 		recipe := internal.ValidateRecipe(c)
 
-		if err := recipePkg.EnsureExists(recipe.Name); err != nil {
+		if err := recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
-		}
-
-		if !internal.Chaos {
-			if err := recipePkg.EnsureIsClean(recipe.Name); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !internal.Offline {
-				if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if err := recipePkg.EnsureLatest(recipe.Name); err != nil {
-				logrus.Fatal(err)
-			}
 		}
 
 		tableCol := []string{"ref", "rule", "severity", "satisfied", "skipped", "resolve"}
@@ -57,7 +40,7 @@ var recipeLintCommand = cli.Command{
 		for level := range lint.LintRules {
 			for _, rule := range lint.LintRules[level] {
 				if internal.OnlyErrors && rule.Level != "error" {
-					logrus.Debugf("skipping %s, does not have level \"error\"", rule.Ref)
+					log.Debugf("skipping %s, does not have level \"error\"", rule.Ref)
 					continue
 				}
 
@@ -75,7 +58,7 @@ var recipeLintCommand = cli.Command{
 				if !skipped {
 					ok, err := rule.Function(recipe)
 					if err != nil {
-						logrus.Warn(err)
+						log.Warn(err)
 					}
 
 					if !ok && rule.Level == "error" {
@@ -114,7 +97,7 @@ var recipeLintCommand = cli.Command{
 		}
 
 		if hasError {
-			logrus.Warn("watch out, some critical errors are present in your recipe config")
+			log.Warn("watch out, some critical errors are present in your recipe config")
 		}
 
 		return nil

cli/recipe/list.go

@@ -8,8 +8,8 @@ import (
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -35,7 +35,7 @@ var recipeListCommand = cli.Command{
 	Action: func(c *cli.Context) error {
 		catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
-			logrus.Fatal(err.Error())
+			log.Fatal(err.Error())
 		}
 
 		recipes := catl.Flatten()

cli/recipe/new.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path"
 	"text/template"
@@ -12,7 +11,8 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/git"
-	"github.com/sirupsen/logrus"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/urfave/cli"
 )
 
@@ -37,6 +37,8 @@ var recipeNewCommand = cli.Command{
 		internal.DebugFlag,
 		internal.NoInputFlag,
 		internal.OfflineFlag,
+		internal.GitNameFlag,
+		internal.GitEmailFlag,
 	},
 	Before:    internal.SubCommandBefore,
 	Usage:     "Create a new recipe",
@@ -46,79 +48,55 @@ Create a new recipe.
 
 Abra uses the built-in example repository which is available here:
 
-    https://git.coopcloud.tech/coop-cloud/example
+    https://git.coopcloud.tech/coop-cloud/example`,
-
-Files within the example repository make use of the Golang templating system
-which Abra uses to inject values into the generated recipe folder (e.g. name of
-recipe and domain in the sample environment config).
-`,
 	Action: func(c *cli.Context) error {
 		recipeName := c.Args().First()
+		r := recipe.Get(recipeName)
 
 		if recipeName == "" {
 			internal.ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
 		}
 
-		directory := path.Join(config.RECIPES_DIR, recipeName)
+		if _, err := os.Stat(r.Dir); !os.IsNotExist(err) {
-		if _, err := os.Stat(directory); !os.IsNotExist(err) {
+			log.Fatalf("%s recipe directory already exists?", r.Dir)
-			logrus.Fatalf("%s recipe directory already exists?", directory)
 		}
 
 		url := fmt.Sprintf("%s/example.git", config.REPOS_BASE_URL)
-		if err := git.Clone(directory, url); err != nil {
+		if err := git.Clone(r.Dir, url); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		gitRepo := path.Join(config.RECIPES_DIR, recipeName, ".git")
+		gitRepo := path.Join(r.Dir, ".git")
 		if err := os.RemoveAll(gitRepo); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
-		logrus.Debugf("removed example git repo in %s", gitRepo)
+		log.Debugf("removed example git repo in %s", gitRepo)
 
 		meta := newRecipeMeta(recipeName)
 
-		toParse := []string{
+		for _, path := range []string{r.ReadmePath, r.SampleEnvPath} {
-			path.Join(config.RECIPES_DIR, recipeName, "README.md"),
-			path.Join(config.RECIPES_DIR, recipeName, ".env.sample"),
-		}
-		for _, path := range toParse {
 			tpl, err := template.ParseFiles(path)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			var templated bytes.Buffer
 			if err := tpl.Execute(&templated, meta); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
-			if err := ioutil.WriteFile(path, templated.Bytes(), 0644); err != nil {
+			if err := os.WriteFile(path, templated.Bytes(), 0o644); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 		}
 
-		newGitRepo := path.Join(config.RECIPES_DIR, recipeName)
+		if err := git.Init(r.Dir, true, internal.GitName, internal.GitEmail); err != nil {
-		if err := git.Init(newGitRepo, true); err != nil {
+			log.Fatal(err)
-			logrus.Fatal(err)
 		}
 
-		fmt.Print(fmt.Sprintf(`
+		log.Infof("new recipe '%s' created: %s", recipeName, path.Join(r.Dir))
-Your new %s recipe has been created in %s.
+		log.Info("happy hacking 🎉")
-
-In order to share your recipe, you can upload it the git repository to:
-
-    https://git.coopcloud.tech/coop-cloud/%s
-
-If you're not sure how to do that, come chat with us:
-
-    https://docs.coopcloud.tech/intro/contact
-
-See "abra recipe -h" for additional recipe maintainer commands.
-
-Happy Hacking!
-
-`, recipeName, path.Join(config.RECIPES_DIR, recipeName), recipeName))
 
 		return nil
 	},

cli/recipe/recipe.go

@@ -18,9 +18,7 @@ for you.
 
 Anyone who uses a recipe can become a maintainer. Maintainers typically make
 sure the recipe is in good working order and the config upgraded in a timely
-manner. Abra supports convenient automation for recipe maintainenace, see the
+manner.`,
-"abra recipe upgrade", "abra recipe sync" and "abra recipe release" commands.
-`,
 	Subcommands: []cli.Command{
 		recipeFetchCommand,
 		recipeLintCommand,

cli/recipe/release.go

@@ -10,16 +10,14 @@ import (
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
 	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -46,8 +44,7 @@ major and therefore require intervention while doing the upgrade work.
 
 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.
+your SSH keys configured on your account.`,
-`,
 	Flags: []cli.Flag{
 		internal.DebugFlag,
 		internal.NoInputFlag,
@@ -65,74 +62,74 @@ your SSH keys configured on your account.
 
 		imagesTmp, err := getImageVersions(recipe)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		mainApp, err := internal.GetMainAppImage(recipe)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		mainAppVersion := imagesTmp[mainApp]
 		if mainAppVersion == "" {
-			logrus.Fatalf("main app service version for %s is empty?", recipe.Name)
+			log.Fatalf("main app service version for %s is empty?", recipe.Name)
 		}
 
 		tagString := c.Args().Get(1)
 		if tagString != "" {
 			if _, err := tagcmp.Parse(tagString); err != nil {
-				logrus.Fatalf("cannot parse %s, invalid tag specified?", tagString)
+				log.Fatalf("cannot parse %s, invalid tag specified?", tagString)
 			}
 		}
 
 		if (internal.Major || internal.Minor || internal.Patch) && tagString != "" {
-			logrus.Fatal("cannot specify tag and bump type at the same time")
+			log.Fatal("cannot specify tag and bump type at the same time")
 		}
 
 		if tagString != "" {
 			if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		tags, err := recipe.Tags()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if tagString == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
 			var err error
 			tagString, err = getLabelVersion(recipe, false)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
-		isClean, err := gitPkg.IsClean(recipe.Dir())
+		isClean, err := gitPkg.IsClean(recipe.Dir)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !isClean {
-			logrus.Infof("%s currently has these unstaged changes 👇", recipe.Name)
+			log.Infof("%s currently has these unstaged changes 👇", recipe.Name)
-			if err := gitPkg.DiffUnstaged(recipe.Dir()); err != nil {
+			if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		if len(tags) > 0 {
-			logrus.Warnf("previous git tags detected, assuming this is a new semver release")
+			log.Warnf("previous git tags detected, assuming this is a new semver release")
 			if err := createReleaseFromPreviousTag(tagString, mainAppVersion, recipe, tags); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		} else {
-			logrus.Warnf("no tag specified and no previous tag available for %s, assuming this is the initial release", recipe.Name)
+			log.Warnf("no tag specified and no previous tag available for %s, assuming this is the initial release", recipe.Name)
 
 			if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
-				if cleanUpErr := cleanUpTag(tagString, recipe.Name); err != nil {
+				if cleanUpErr := cleanUpTag(recipe, tagString); err != nil {
-					logrus.Fatal(cleanUpErr)
+					log.Fatal(cleanUpErr)
 				}
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
@@ -144,8 +141,12 @@ your SSH keys configured on your account.
 func getImageVersions(recipe recipe.Recipe) (map[string]string, error) {
 	services := make(map[string]string)
 
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return nil, err
+	}
 	missingTag := false
-	for _, service := range recipe.Config.Services {
+	for _, service := range config.Services {
 		if service.Image == "" {
 			continue
 		}
@@ -184,8 +185,7 @@ func getImageVersions(recipe recipe.Recipe) (map[string]string, error) {
 func createReleaseFromTag(recipe recipe.Recipe, tagString, mainAppVersion string) error {
 	var err error
 
-	directory := path.Join(config.RECIPES_DIR, recipe.Name)
+	repo, err := git.PlainOpen(recipe.Dir)
-	repo, err := git.PlainOpen(directory)
 	if err != nil {
 		return err
 	}
@@ -210,19 +210,19 @@ func createReleaseFromTag(recipe recipe.Recipe, tagString, mainAppVersion string
 	}
 
 	if err := addReleaseNotes(recipe, tagString); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	if err := commitRelease(recipe, tagString); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	if err := tagRelease(tagString, repo); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	if err := pushRelease(recipe, tagString); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	return nil
@@ -246,8 +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 {
-	repoPath := path.Join(config.RECIPES_DIR, recipe.Name)
+	tagReleaseNotePath := path.Join(recipe.Dir, "release", tag)
-	tagReleaseNotePath := path.Join(repoPath, "release", tag)
 	if _, err := os.Stat(tagReleaseNotePath); err == nil {
 		// Release note for current tag already exist exists.
 		return nil
@@ -255,11 +254,11 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 		return err
 	}
 
-	nextReleaseNotePath := path.Join(repoPath, "release", "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 {
-			logrus.Debugf("dry run: move release note from 'next' to %s", tag)
+			log.Debugf("dry run: move release note from 'next' to %s", tag)
 			return nil
 		}
 		if !internal.NoInput {
@@ -278,11 +277,11 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 		if err != nil {
 			return err
 		}
-		err = gitPkg.Add(repoPath, path.Join("release", "next"), internal.Dry)
+		err = gitPkg.Add(recipe.Dir, path.Join("release", "next"), internal.Dry)
 		if err != nil {
 			return err
 		}
-		err = gitPkg.Add(repoPath, path.Join("release", tag), internal.Dry)
+		err = gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry)
 		if err != nil {
 			return err
 		}
@@ -311,7 +310,7 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 	if err != nil {
 		return err
 	}
-	err = gitPkg.Add(repoPath, path.Join("release", tag), internal.Dry)
+	err = gitPkg.Add(recipe.Dir, path.Join("release", tag), internal.Dry)
 	if err != nil {
 		return err
 	}
@@ -321,24 +320,23 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 
 func commitRelease(recipe recipe.Recipe, tag string) error {
 	if internal.Dry {
-		logrus.Debugf("dry run: no changes committed")
+		log.Debugf("dry run: no changes committed")
 		return nil
 	}
 
-	isClean, err := gitPkg.IsClean(recipe.Dir())
+	isClean, err := gitPkg.IsClean(recipe.Dir)
 	if err != nil {
 		return err
 	}
 
 	if isClean {
 		if !internal.Dry {
-			return fmt.Errorf("no changes discovered in %s, nothing to publish?", recipe.Dir())
+			return fmt.Errorf("no changes discovered in %s, nothing to publish?", recipe.Dir)
 		}
 	}
 
 	msg := fmt.Sprintf("chore: publish %s release", tag)
-	repoPath := path.Join(config.RECIPES_DIR, recipe.Name)
+	if err := gitPkg.Commit(recipe.Dir, msg, internal.Dry); err != nil {
-	if err := gitPkg.Commit(repoPath, msg, internal.Dry); err != nil {
 		return err
 	}
 
@@ -347,7 +345,7 @@ func commitRelease(recipe recipe.Recipe, tag string) error {
 
 func tagRelease(tagString string, repo *git.Repository) error {
 	if internal.Dry {
-		logrus.Debugf("dry run: no git tag created (%s)", tagString)
+		log.Debugf("dry run: no git tag created (%s)", tagString)
 		return nil
 	}
 
@@ -367,14 +365,14 @@ func tagRelease(tagString string, repo *git.Repository) error {
 	}
 
 	hash := formatter.SmallSHA(head.Hash().String())
-	logrus.Debugf(fmt.Sprintf("created tag %s at %s", tagString, hash))
+	log.Debugf(fmt.Sprintf("created tag %s at %s", tagString, hash))
 
 	return nil
 }
 
 func pushRelease(recipe recipe.Recipe, tagString string) error {
 	if internal.Dry {
-		logrus.Info("dry run: no changes published")
+		log.Info("dry run: no changes published")
 		return nil
 	}
 
@@ -392,18 +390,17 @@ func pushRelease(recipe recipe.Recipe, tagString string) error {
 		if err := recipe.Push(internal.Dry); err != nil {
 			return err
 		}
-		url := fmt.Sprintf("%s/%s/src/tag/%s", config.REPOS_BASE_URL, recipe.Name, tagString)
+		url := fmt.Sprintf("%s/src/tag/%s", recipe.GitURL, tagString)
-		logrus.Infof("new release published: %s", url)
+		log.Infof("new release published: %s", url)
 	} else {
-		logrus.Info("no -p/--publish passed, not publishing")
+		log.Info("no -p/--publish passed, not publishing")
 	}
 
 	return nil
 }
 
 func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recipe.Recipe, tags []string) error {
-	directory := path.Join(config.RECIPES_DIR, recipe.Name)
+	repo, err := git.PlainOpen(recipe.Dir)
-	repo, err := git.PlainOpen(directory)
 	if err != nil {
 		return err
 	}
@@ -468,7 +465,7 @@ func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recip
 	}
 
 	if lastGitTag.String() == tagString {
-		logrus.Fatalf("latest git tag (%s) and synced label (%s) are the same?", lastGitTag, tagString)
+		log.Fatalf("latest git tag (%s) and synced label (%s) are the same?", lastGitTag, tagString)
 	}
 
 	if !internal.NoInput {
@@ -478,37 +475,36 @@ func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recip
 
 		var ok bool
 		if err := survey.AskOne(prompt, &ok); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !ok {
-			logrus.Fatal("exiting as requested")
+			log.Fatal("exiting as requested")
 		}
 	}
 
 	if err := addReleaseNotes(recipe, tagString); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	if err := commitRelease(recipe, tagString); err != nil {
-		logrus.Fatalf("failed to commit changes: %s", err.Error())
+		log.Fatalf("failed to commit changes: %s", err.Error())
 	}
 
 	if err := tagRelease(tagString, repo); err != nil {
-		logrus.Fatalf("failed to tag release: %s", err.Error())
+		log.Fatalf("failed to tag release: %s", err.Error())
 	}
 
 	if err := pushRelease(recipe, tagString); err != nil {
-		logrus.Fatalf("failed to publish new release: %s", err.Error())
+		log.Fatalf("failed to publish new release: %s", err.Error())
 	}
 
 	return nil
 }
 
 // cleanUpTag removes a freshly created tag
-func cleanUpTag(tag, recipeName string) error {
+func cleanUpTag(recipe recipe.Recipe, tag string) error {
-	directory := path.Join(config.RECIPES_DIR, recipeName)
+	repo, err := git.PlainOpen(recipe.Dir)
-	repo, err := git.PlainOpen(directory)
 	if err != nil {
 		return err
 	}
@@ -519,22 +515,22 @@ func cleanUpTag(tag, recipeName string) error {
 		}
 	}
 
-	logrus.Debugf("removed freshly created tag %s", tag)
+	log.Debugf("removed freshly created tag %s", tag)
 
 	return nil
 }
 
 func getLabelVersion(recipe recipe.Recipe, prompt bool) (string, error) {
-	initTag, err := recipePkg.GetVersionLabelLocal(recipe)
+	initTag, err := recipe.GetVersionLabelLocal()
 	if err != nil {
 		return "", err
 	}
 
 	if initTag == "" {
-		logrus.Fatalf("unable to read version for %s from synced label. Did you try running \"abra recipe sync %s\" already?", recipe.Name, recipe.Name)
+		log.Fatalf("unable to read version for %s from synced label. Did you try running \"abra recipe sync %s\" already?", recipe.Name, recipe.Name)
 	}
 
-	logrus.Warnf("discovered %s as currently synced recipe label", initTag)
+	log.Warnf("discovered %s as currently synced recipe label", initTag)
 
 	if prompt && !internal.NoInput {
 		var response bool

cli/recipe/reset.go

@@ -1,20 +1,18 @@
 package recipe
 
 import (
-	"path"
-
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
 var recipeResetCommand = cli.Command{
 	Name:        "reset",
 	Usage:       "Remove all unstaged changes from recipe config",
-	Description: "WARNING, this will delete your changes. Be Careful.",
+	Description: "WARNING: this will delete your changes. Be Careful.",
 	Aliases:     []string{"rs"},
 	ArgsUsage:   "<recipe>",
 	Flags: []cli.Flag{
@@ -25,30 +23,30 @@ var recipeResetCommand = cli.Command{
 	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
 		recipeName := c.Args().First()
+		r := recipe.Get(recipeName)
 
 		if recipeName != "" {
 			internal.ValidateRecipe(c)
 		}
 
-		repoPath := path.Join(config.RECIPES_DIR, recipeName)
+		repo, err := git.PlainOpen(r.Dir)
-		repo, err := git.PlainOpen(repoPath)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		ref, err := repo.Head()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		worktree, err := repo.Worktree()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		opts := &git.ResetOptions{Commit: ref.Hash(), Mode: git.HardReset}
 		if err := worktree.Reset(opts); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil

cli/recipe/sync.go

@@ -2,18 +2,16 @@ package recipe
 
 import (
 	"fmt"
-	"path"
 	"strconv"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -39,34 +37,33 @@ named "app") which corresponds to the following format:
 
 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.
+local file system.`,
-`,
 	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
 		recipe := internal.ValidateRecipe(c)
 
 		mainApp, err := internal.GetMainAppImage(recipe)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		imagesTmp, err := getImageVersions(recipe)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		mainAppVersion := imagesTmp[mainApp]
 
 		tags, err := recipe.Tags()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		nextTag := c.Args().Get(1)
 		if len(tags) == 0 && nextTag == "" {
-			logrus.Warnf("no git tags found for %s", recipe.Name)
+			log.Warnf("no git tags found for %s", recipe.Name)
 			if internal.NoInput {
-				logrus.Fatalf("unable to continue, input required for initial version")
+				log.Fatalf("unable to continue, input required for initial version")
 			}
 			fmt.Println(fmt.Sprintf(`
 The following options are two types of initial semantic version that you can
@@ -93,7 +90,7 @@ likely to change.
 			}
 
 			if err := survey.AskOne(edPrompt, &chosenVersion); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			nextTag = fmt.Sprintf("%s+%s", chosenVersion, mainAppVersion)
@@ -102,27 +99,26 @@ likely to change.
 		if nextTag == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
 			latestRelease := tags[len(tags)-1]
 			if err := internal.PromptBumpType("", latestRelease); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
 		if nextTag == "" {
-			recipeDir := path.Join(config.RECIPES_DIR, recipe.Name)
+			repo, err := git.PlainOpen(recipe.Dir)
-			repo, err := git.PlainOpen(recipeDir)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			var lastGitTag tagcmp.Tag
 			iter, err := repo.Tags()
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if err := iter.ForEach(func(ref *plumbing.Reference) error {
 				obj, err := repo.TagObject(ref.Hash())
 				if err != nil {
-					logrus.Fatal("Tag at commit ", ref.Hash(), " is unannotated or otherwise broken. Please fix it.")
+					log.Fatal("Tag at commit ", ref.Hash(), " is unannotated or otherwise broken. Please fix it.")
 					return err
 				}
 
@@ -139,7 +135,7 @@ likely to change.
 
 				return nil
 			}); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			// bumpType is used to decide what part of the tag should be incremented
@@ -147,7 +143,7 @@ likely to change.
 			if bumpType != 0 {
 				// a bitwise check if the number is a power of 2
 				if (bumpType & (bumpType - 1)) != 0 {
-					logrus.Fatal("you can only use one version flag: --major, --minor or --patch")
+					log.Fatal("you can only use one version flag: --major, --minor or --patch")
 				}
 			}
 
@@ -156,14 +152,14 @@ likely to change.
 				if internal.Patch {
 					now, err := strconv.Atoi(newTag.Patch)
 					if err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 
 					newTag.Patch = strconv.Itoa(now + 1)
 				} else if internal.Minor {
 					now, err := strconv.Atoi(newTag.Minor)
 					if err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 
 					newTag.Patch = "0"
@@ -171,7 +167,7 @@ likely to change.
 				} else if internal.Major {
 					now, err := strconv.Atoi(newTag.Major)
 					if err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 
 					newTag.Patch = "0"
@@ -181,32 +177,32 @@ likely to change.
 			}
 
 			newTag.Metadata = mainAppVersion
-			logrus.Debugf("choosing %s as new version for %s", newTag.String(), recipe.Name)
+			log.Debugf("choosing %s as new version for %s", newTag.String(), recipe.Name)
 			nextTag = newTag.String()
 		}
 
 		if _, err := tagcmp.Parse(nextTag); err != nil {
-			logrus.Fatalf("invalid version %s specified", nextTag)
+			log.Fatalf("invalid version %s specified", nextTag)
 		}
 
 		mainService := "app"
 		label := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", nextTag)
 		if !internal.Dry {
 			if err := recipe.UpdateLabel("compose.y*ml", mainService, label); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		} else {
-			logrus.Infof("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name)
+			log.Infof("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name)
 		}
 
-		isClean, err := gitPkg.IsClean(recipe.Dir())
+		isClean, err := gitPkg.IsClean(recipe.Dir)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		if !isClean {
-			logrus.Infof("%s currently has these unstaged changes 👇", recipe.Name)
+			log.Infof("%s currently has these unstaged changes 👇", recipe.Name)
-			if err := gitPkg.DiffUnstaged(recipe.Dir()); err != nil {
+			if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 

cli/recipe/upgrade.go

@@ -12,14 +12,13 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/log"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -54,10 +53,11 @@ 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:
+You may invoke this command in "wizard" mode and be prompted for input.
 
-    abra recipe upgrade
+EXAMPLE:
-`,
+
+    abra recipe upgrade`,
 	ArgsUsage: "<recipe>",
 	Flags: []cli.Flag{
 		internal.DebugFlag,
@@ -73,27 +73,15 @@ You may invoke this command in "wizard" mode and be prompted for input:
 	Action: func(c *cli.Context) error {
 		recipe := internal.ValidateRecipe(c)
 
-		if err := recipePkg.EnsureIsClean(recipe.Name); err != nil {
+		if err := recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
-		}
-
-		if err := recipePkg.EnsureExists(recipe.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := recipePkg.EnsureLatest(recipe.Name); err != nil {
-			logrus.Fatal(err)
 		}
 
 		bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
 		if bumpType != 0 {
 			// a bitwise check if the number is a power of 2
 			if (bumpType & (bumpType - 1)) != 0 {
-				logrus.Fatal("you can only use one of: --major, --minor, --patch.")
+				log.Fatal("you can only use one of: --major, --minor, --patch.")
 			}
 		}
 
@@ -106,26 +94,25 @@ You may invoke this command in "wizard" mode and be prompted for input:
 
 		// check for versions file and load pinned versions
 		versionsPresent := false
-		recipeDir := path.Join(config.RECIPES_DIR, recipe.Name)
+		versionsPath := path.Join(recipe.Dir, "versions")
-		versionsPath := path.Join(recipeDir, "versions")
+		servicePins := make(map[string]imgPin)
-		var servicePins = make(map[string]imgPin)
 		if _, err := os.Stat(versionsPath); err == nil {
-			logrus.Debugf("found versions file for %s", recipe.Name)
+			log.Debugf("found versions file for %s", recipe.Name)
 			file, err := os.Open(versionsPath)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 			scanner := bufio.NewScanner(file)
 			for scanner.Scan() {
 				line := scanner.Text()
 				splitLine := strings.Split(line, " ")
 				if splitLine[0] != "pin" || len(splitLine) != 3 {
-					logrus.Fatalf("malformed version pin specification: %s", line)
+					log.Fatalf("malformed version pin specification: %s", line)
 				}
 				pinSlice := strings.Split(splitLine[2], ":")
 				pinTag, err := tagcmp.Parse(pinSlice[1])
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 				pin := imgPin{
 					image:   pinSlice[0],
@@ -134,45 +121,50 @@ You may invoke this command in "wizard" mode and be prompted for input:
 				servicePins[splitLine[1]] = pin
 			}
 			if err := scanner.Err(); err != nil {
-				logrus.Error(err)
+				log.Error(err)
 			}
 			versionsPresent = true
 		} else {
-			logrus.Debugf("did not find versions file for %s", recipe.Name)
+			log.Debugf("did not find versions file for %s", recipe.Name)
 		}
 
-		for _, service := range recipe.Config.Services {
+		config, err := recipe.GetComposeConfig(nil)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, service := range config.Services {
 			img, err := reference.ParseNormalizedNamed(service.Image)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			regVersions, err := client.GetRegistryTags(img)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			image := reference.Path(img)
-			logrus.Debugf("retrieved %s from remote registry for %s", regVersions, image)
+			log.Debugf("retrieved %s from remote registry for %s", regVersions, image)
 			image = formatter.StripTagMeta(image)
 
 			switch img.(type) {
 			case reference.NamedTagged:
 				if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) {
-					logrus.Debugf("%s not considered semver-like", img.(reference.NamedTagged).Tag())
+					log.Debugf("%s not considered semver-like", img.(reference.NamedTagged).Tag())
 				}
 			default:
-				logrus.Warnf("unable to read tag for image %s, is it missing? skipping upgrade for %s", image, service.Name)
+				log.Warnf("unable to read tag for image %s, is it missing? skipping upgrade for %s", image, service.Name)
 				continue
 			}
 
 			tag, err := tagcmp.Parse(img.(reference.NamedTagged).Tag())
 			if err != nil {
-				logrus.Warnf("unable to parse %s, error was: %s, skipping upgrade for %s", image, err.Error(), service.Name)
+				log.Warnf("unable to parse %s, error was: %s, skipping upgrade for %s", image, err.Error(), service.Name)
 				continue
 			}
 
-			logrus.Debugf("parsed %s for %s", tag, service.Name)
+			log.Debugf("parsed %s for %s", tag, service.Name)
 
 			var compatible []tagcmp.Tag
 			for _, regVersion := range regVersions {
@@ -186,18 +178,18 @@ You may invoke this command in "wizard" mode and be prompted for input:
 				}
 			}
 
-			logrus.Debugf("detected potential upgradable tags %s for %s", compatible, service.Name)
+			log.Debugf("detected potential upgradable tags %s for %s", compatible, service.Name)
 
 			sort.Sort(tagcmp.ByTagDesc(compatible))
 
 			if len(compatible) == 0 && !internal.AllTags {
-				logrus.Info(fmt.Sprintf("no new versions available for %s, assuming %s is the latest (use -a/--all-tags to see all anyway)", image, tag))
+				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
 			}
 
 			catlVersions, err := recipePkg.VersionsOfService(recipe.Name, service.Name, internal.Offline)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			compatibleStrings := []string{"skip"}
@@ -213,7 +205,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 				}
 			}
 
-			logrus.Debugf("detected compatible upgradable tags %s for %s", compatibleStrings, service.Name)
+			log.Debugf("detected compatible upgradable tags %s for %s", compatibleStrings, service.Name)
 
 			var upgradeTag string
 			_, ok := servicePins[service.Name]
@@ -230,13 +222,13 @@ You may invoke this command in "wizard" mode and be prompted for input:
 						}
 					}
 					if contains {
-						logrus.Infof("upgrading service %s from %s to %s (pinned tag: %s)", service.Name, tag.String(), upgradeTag, pinnedTagString)
+						log.Infof("upgrading service %s from %s to %s (pinned tag: %s)", service.Name, tag.String(), upgradeTag, pinnedTagString)
 					} else {
-						logrus.Infof("service %s, image %s pinned to %s, no compatible upgrade found", service.Name, servicePins[service.Name].image, pinnedTagString)
+						log.Infof("service %s, image %s pinned to %s, no compatible upgrade found", service.Name, servicePins[service.Name].image, pinnedTagString)
 						continue
 					}
 				} else {
-					logrus.Fatalf("service %s is at version %s, but pinned to %s, please correct your compose.yml file manually!", service.Name, tag.String(), pinnedTag.String())
+					log.Fatalf("service %s is at version %s, but pinned to %s, please correct your compose.yml file manually!", service.Name, tag.String(), pinnedTag.String())
 					continue
 				}
 			} else {
@@ -253,7 +245,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 						}
 					}
 					if upgradeTag == "" {
-						logrus.Warnf("not upgrading from %s to %s for %s, because the upgrade type is more serious than what user wants", tag.String(), compatible[0].String(), image)
+						log.Warnf("not upgrading from %s to %s for %s, because the upgrade type is more serious than what user wants", tag.String(), compatible[0].String(), image)
 						continue
 					}
 				} else {
@@ -261,7 +253,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 					if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) || internal.AllTags {
 						tag := img.(reference.NamedTagged).Tag()
 						if !internal.AllTags {
-							logrus.Warning(fmt.Sprintf("unable to determine versioning semantics of %s, listing all tags", tag))
+							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)
 						compatibleStrings = []string{"skip"}
@@ -299,7 +291,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 							Options: compatibleStrings,
 						}
 						if err := survey.AskOne(prompt, &upgradeTag); err != nil {
-							logrus.Fatal(err)
+							log.Fatal(err)
 						}
 					}
 				}
@@ -307,14 +299,14 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			if upgradeTag != "skip" {
 				ok, err := recipe.UpdateTag(image, upgradeTag)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 				if ok {
-					logrus.Infof("tag upgraded from %s to %s for %s", tag.String(), upgradeTag, image)
+					log.Infof("tag upgraded from %s to %s for %s", tag.String(), upgradeTag, image)
 				}
 			} else {
 				if !internal.NoInput {
-					logrus.Warnf("not upgrading %s, skipping as requested", image)
+					log.Warnf("not upgrading %s, skipping as requested", image)
 				}
 			}
 		}
@@ -323,7 +315,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			if internal.MachineReadable {
 				jsonstring, err := json.Marshal(upgradeList)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 
 				fmt.Println(string(jsonstring))
@@ -332,21 +324,21 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			}
 
 			for _, upgrade := range upgradeList {
-				logrus.Infof("can upgrade service: %s, image: %s, tag: %s ::\n", upgrade.Service, upgrade.Image, upgrade.Tag)
+				log.Infof("can upgrade service: %s, image: %s, tag: %s ::", upgrade.Service, upgrade.Image, upgrade.Tag)
 				for _, utag := range upgrade.UpgradeTags {
-					logrus.Infof("    %s\n", utag)
+					log.Infof("    %s", utag)
 				}
 			}
 		}
 
-		isClean, err := gitPkg.IsClean(recipeDir)
+		isClean, err := gitPkg.IsClean(recipe.Dir)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 		if !isClean {
-			logrus.Infof("%s currently has these unstaged changes 👇", recipe.Name)
+			log.Infof("%s currently has these unstaged changes 👇", recipe.Name)
-			if err := gitPkg.DiffUnstaged(recipeDir); err != nil {
+			if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 

cli/recipe/version.go

@@ -7,9 +7,9 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"github.com/olekukonko/tablewriter"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -24,11 +24,10 @@ func sortServiceByName(versions [][]string) func(i, j int) bool {
 }
 
 var recipeVersionCommand = cli.Command{
-	Name:        "versions",
+	Name:      "versions",
-	Aliases:     []string{"v"},
+	Aliases:   []string{"v"},
-	Usage:       "List recipe versions",
+	Usage:     "List recipe versions",
-	ArgsUsage:   "<recipe>",
+	ArgsUsage: "<recipe>",
-	Description: "Versions are read from the recipe catalogue.",
 	Flags: []cli.Flag{
 		internal.DebugFlag,
 		internal.OfflineFlag,
@@ -42,16 +41,23 @@ var recipeVersionCommand = cli.Command{
 
 		catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		recipeMeta, ok := catl[recipe.Name]
 		if !ok {
-			logrus.Fatalf("%s is not published on the catalogue?", recipe.Name)
+			log.Warn("no published versions in catalogue, trying local recipe repository")
+
+			recipeVersions, err := recipe.GetRecipeVersions()
+			if err != nil {
+				log.Warn(err)
+			}
+
+			recipeMeta = recipePkg.RecipeMeta{Versions: recipeVersions}
 		}
 
 		if len(recipeMeta.Versions) == 0 {
-			logrus.Fatalf("%s has no catalogue published versions?", recipe.Name)
+			log.Fatalf("%s has no catalogue published versions?", recipe.Name)
 		}
 
 		tableCols := []string{"version", "service", "image", "tag"}

cli/server/add.go

@@ -10,9 +10,9 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	contextPkg "coopcloud.tech/abra/pkg/context"
 	"coopcloud.tech/abra/pkg/dns"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/server"
 	sshPkg "coopcloud.tech/abra/pkg/ssh"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -23,29 +23,29 @@ var localFlag = &cli.BoolFlag{
 	Destination: &local,
 }
 
-func cleanUp(domainName string) {
+// cleanUp cleans up the partially created context/client details for a failed
-	if domainName != "default" {
+// "server add" attempt.
-		logrus.Infof("cleaning up context for %s", domainName)
+func cleanUp(name string) {
-		if err := client.DeleteContext(domainName); err != nil {
+	if name != "default" {
-			logrus.Fatal(err)
+		log.Debugf("serverAdd: cleanUp: cleaning up context for %s", name)
+		if err := client.DeleteContext(name); err != nil {
+			log.Fatal(err)
 		}
 	}
 
-	logrus.Infof("attempting to clean up server directory for %s", domainName)
+	serverDir := filepath.Join(config.SERVERS_DIR, name)
-
-	serverDir := filepath.Join(config.SERVERS_DIR, domainName)
 	files, err := config.GetAllFilesInDirectory(serverDir)
 	if err != nil {
-		logrus.Fatalf("unable to list files in %s: %s", serverDir, err)
+		log.Fatalf("serverAdd: cleanUp: unable to list files in %s: %s", serverDir, err)
 	}
 
 	if len(files) > 0 {
-		logrus.Warnf("aborting clean up of %s because it is not empty", serverDir)
+		log.Debugf("serverAdd: cleanUp: %s is not empty, aborting cleanup", serverDir)
 		return
 	}
 
 	if err := os.RemoveAll(serverDir); err != nil {
-		logrus.Fatal(err)
+		log.Fatalf("serverAdd: cleanUp: failed to remove %s: %s", serverDir, err)
 	}
 }
 
@@ -53,123 +53,151 @@ func cleanUp(domainName string) {
 // Docker manages SSH connection details. These are stored to disk in
 // ~/.docker. Abra can manage this completely for the user, so it's an
 // implementation detail.
-func newContext(c *cli.Context, domainName string) error {
+func newContext(name string) (bool, error) {
 	store := contextPkg.NewDefaultDockerContextStore()
 	contexts, err := store.Store.List()
 	if err != nil {
-		return err
+		return false, err
 	}
 
 	for _, context := range contexts {
-		if context.Name == domainName {
+		if context.Name == name {
-			logrus.Debugf("context for %s already exists", domainName)
+			log.Debugf("context for %s already exists", name)
-			return nil
+			return false, nil
 		}
 	}
 
-	logrus.Debugf("creating context with domain %s", domainName)
+	log.Debugf("creating context with domain %s", name)
 
-	if err := client.CreateContext(domainName); err != nil {
+	if err := client.CreateContext(name); err != nil {
-		return err
+		return false, nil
 	}
 
-	return nil
+	return true, nil
 }
 
 // createServerDir creates the ~/.abra/servers/... directory for a new server.
-func createServerDir(domainName string) error {
+func createServerDir(name string) (bool, error) {
-	if err := server.CreateServerDir(domainName); err != nil {
+	if err := server.CreateServerDir(name); err != nil {
 		if !os.IsExist(err) {
-			return err
+			return false, err
 		}
-		logrus.Debugf("server dir for %s already created", domainName)
+
+		log.Debugf("server dir for %s already created", name)
+
+		return false, nil
 	}
 
-	return nil
+	return true, nil
 }
 
 var serverAddCommand = cli.Command{
 	Name:    "add",
 	Aliases: []string{"a"},
-	Usage:   "Add a server to your configuration",
+	Usage:   "Add a new server to your configuration",
 	Description: `
 Add a new server to your configuration so that it can be managed by Abra.
 
-Abra uses the SSH command-line to discover connection details for your server.
+Abra relies on the standard SSH command-line and ~/.ssh/config for client
-It is advised to configure an entry per-host in your ~/.ssh/config for each
+connection details. You must configure an entry per-host in your ~/.ssh/config
-server. For example:
+for each server. For example:
 
-Host example.com
+  Host example.com example
-  Hostname example.com
+    Hostname example.com
-  User exampleUser
+    User exampleUser
-  Port 12345
+    Port 12345
-  IdentityFile ~/.ssh/example@somewhere
+    IdentityFile ~/.ssh/example@somewhere
 
-Abra can then load SSH connection details from this configuratiion with:
+You can then add a server like so:
 
-    abra server add example.com
+  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.
+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: "<domain>",
+	ArgsUsage: "<name>",
 	Action: func(c *cli.Context) error {
 		if len(c.Args()) > 0 && local || !internal.ValidateSubCmdFlags(c) {
-			err := errors.New("cannot use <domain> and --local together")
+			err := errors.New("cannot use <name> and --local together")
 			internal.ShowSubcommandHelpAndError(c, err)
 		}
 
-		var domainName string
+		var name string
 		if local {
-			domainName = "default"
+			name = "default"
 		} else {
-			domainName = internal.ValidateDomain(c)
+			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 {
-			if err := createServerDir(domainName); err != nil {
+			created, err := createServerDir(name)
-				logrus.Fatal(err)
+			if err != nil {
+				log.Fatal(err)
 			}
 
-			logrus.Infof("attempting to create client for %s", domainName)
+			log.Debugf("attempting to create client for %s", name)
-			if _, err := client.New(domainName); err != nil {
+
-				cleanUp(domainName)
+			if _, err := client.New(name, timeout); err != nil {
-				logrus.Fatal(err)
+				cleanUp(name)
+				log.Fatal(err)
 			}
 
-			logrus.Info("local server added")
+			if created {
+				log.Info("local server successfully added")
+			} else {
+				log.Warn("local server already exists")
+			}
 
 			return nil
 		}
 
-		if _, err := dns.EnsureIPv4(domainName); err != nil {
+		if !internal.NoDomainChecks {
-			logrus.Fatal(err)
+			if _, err := dns.EnsureIPv4(name); err != nil {
+				log.Fatal(err)
+			}
 		}
 
-		if err := createServerDir(domainName); err != nil {
+		_, err := createServerDir(name)
-			logrus.Fatal(err)
+		if err != nil {
+			log.Fatal(err)
 		}
 
-		if err := newContext(c, domainName); err != nil {
+		created, err := newContext(name)
-			logrus.Fatal(err)
+		if err != nil {
+			cleanUp(name)
+			log.Fatal(err)
 		}
 
-		logrus.Infof("attempting to create client for %s", domainName)
+		log.Debugf("attempting to create client for %s", name)
-		if _, err := client.New(domainName); err != nil {
+		if _, err := client.New(name, timeout); err != nil {
-			cleanUp(domainName)
+			cleanUp(name)
-			logrus.Debugf("failed to construct client for %s, saw %s", domainName, err.Error())
+			log.Fatal(sshPkg.Fatal(name, err))
-			logrus.Fatal(sshPkg.Fatal(domainName, err))
 		}
 
-		logrus.Infof("%s added", domainName)
+		if created {
+			log.Infof("%s successfully added", name)
+		} else {
+			log.Warnf("%s already exists", name)
+		}
 
 		return nil
 	},

cli/server/list.go

@@ -7,25 +7,16 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/context"
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/cli/cli/connhelper/ssh"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
-var problemsFilter bool
-
-var problemsFilterFlag = &cli.BoolFlag{
-	Name:        "problems, p",
-	Usage:       "Show only servers with potential connection problems",
-	Destination: &problemsFilter,
-}
-
 var serverListCommand = cli.Command{
 	Name:    "list",
 	Aliases: []string{"ls"},
 	Usage:   "List managed servers",
 	Flags: []cli.Flag{
-		problemsFilterFlag,
 		internal.DebugFlag,
 		internal.MachineReadableFlag,
 		internal.OfflineFlag,
@@ -35,15 +26,15 @@ var serverListCommand = cli.Command{
 		dockerContextStore := context.NewDefaultDockerContextStore()
 		contexts, err := dockerContextStore.Store.List()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		tableColumns := []string{"name", "host", "user", "port"}
+		tableColumns := []string{"name", "host"}
 		table := formatter.CreateTable(tableColumns)
 
 		serverNames, err := config.ReadServerNames()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, serverName := range serverNames {
@@ -58,53 +49,35 @@ var serverListCommand = cli.Command{
 				if ctx.Name == serverName {
 					sp, err := ssh.ParseURL(endpoint)
 					if err != nil {
-						logrus.Fatal(err)
+						log.Fatal(err)
 					}
 
 					if sp.Host == "" {
 						sp.Host = "unknown"
 					}
-					if sp.User == "" {
-						sp.User = "unknown"
-					}
-					if sp.Port == "" {
-						sp.Port = "unknown"
-					}
 
-					row = []string{serverName, sp.Host, sp.User, sp.Port}
+					row = []string{serverName, sp.Host}
 				}
 			}
 
 			if len(row) == 0 {
 				if serverName == "default" {
-					row = []string{serverName, "local", "n/a", "n/a"}
+					row = []string{serverName, "local"}
 				} else {
-					row = []string{serverName, "unknown", "unknown", "unknown"}
+					row = []string{serverName, "unknown"}
 				}
 			}
 
-			if problemsFilter {
+			table.Append(row)
-				for _, val := range row {
-					if val == "unknown" {
-						table.Append(row)
-						break
-					}
-				}
-			} else {
-				table.Append(row)
-			}
 		}
 
 		if internal.MachineReadable {
 			table.JSONRender()
-		} else {
+			return nil
-			if problemsFilter && table.NumLines() == 0 {
-				logrus.Info("all servers wired up correctly 👏")
-			} else {
-				table.Render()
-			}
 		}
 
+		table.Render()
+
 		return nil
 	},
 }

cli/server/prune.go

@@ -7,8 +7,8 @@ import (
 	"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/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -31,13 +31,12 @@ var volumesFilterFlag = &cli.BoolFlag{
 var serverPruneCommand = cli.Command{
 	Name:    "prune",
 	Aliases: []string{"p"},
-	Usage:   "Prune a managed server; Runs a docker system prune",
+	Usage:   "Prune resources on a server",
 	Description: `
 Prunes unused containers, networks, and dangling images.
 
-If passing "-v/--volumes" then volumes not connected to a deployed app will
+Use "-v/--volumes" to remove volumes that are not associated with a deployed
-also be removed. This can result in unwanted data loss if not used carefully.
+app. This can result in unwanted data loss if not used carefully.`,
-	`,
 	ArgsUsage: "[<server>]",
 	Flags: []cli.Flag{
 		allFilterFlag,
@@ -53,7 +52,7 @@ also be removed. This can result in unwanted data loss if not used carefully.
 
 		cl, err := client.New(serverName)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		var args filters.Args
@@ -61,41 +60,41 @@ also be removed. This can result in unwanted data loss if not used carefully.
 		ctx := context.Background()
 		cr, err := cl.ContainersPrune(ctx, args)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
-		logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
+		log.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
 
 		nr, err := cl.NetworksPrune(ctx, args)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted))
+		log.Infof("networks pruned: %d", len(nr.NetworksDeleted))
 
 		pruneFilters := filters.NewArgs()
 		if allFilter {
-			logrus.Debugf("removing all images, not only dangling ones")
+			log.Debugf("removing all images, not only dangling ones")
 			pruneFilters.Add("dangling", "false")
 		}
 
 		ir, err := cl.ImagesPrune(ctx, pruneFilters)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed)
-		logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
+		log.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
 
 		if volumesFilter {
 			vr, err := cl.VolumesPrune(ctx, args)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			volSpaceReclaimed := formatter.ByteCountSI(vr.SpaceReclaimed)
-			logrus.Infof("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed)
+			log.Infof("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed)
 		}
 
 		return nil

cli/server/remove.go

@@ -8,7 +8,7 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
-	"github.com/sirupsen/logrus"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/urfave/cli"
 )
 
@@ -17,12 +17,12 @@ var serverRemoveCommand = cli.Command{
 	Aliases:   []string{"rm"},
 	ArgsUsage: "<server>",
 	Usage:     "Remove a managed server",
-	Description: `Remove a managed server.
+	Description: `
+Remove a managed server.
 
 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.
+rain.`,
-`,
 	Flags: []cli.Flag{
 		internal.DebugFlag,
 		internal.NoInputFlag,
@@ -34,14 +34,14 @@ rain.
 		serverName := internal.ValidateServer(c)
 
 		if err := client.DeleteContext(serverName); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if err := os.RemoveAll(filepath.Join(config.SERVERS_DIR, serverName)); err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
-		logrus.Infof("server at %s has been lost in time, like tears in rain", serverName)
+		log.Infof("%s is now lost in time, like tears in rain", serverName)
 
 		return nil
 	},

cli/updater/updater.go

@@ -8,19 +8,21 @@ import (
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/envfile"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/abra/pkg/upstream/convert"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
+	charmLog "github.com/charmbracelet/log"
 	composetypes "github.com/docker/cli/cli/compose/types"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	dockerclient "github.com/docker/docker/client"
 
-	"github.com/sirupsen/logrus"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/urfave/cli"
 )
 
@@ -52,32 +54,34 @@ var Notify = cli.Command{
 	},
 	Before: internal.SubCommandBefore,
 	Description: `
-It reads the deployed app versions and looks for new versions in the recipe
+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
+catalogue.
-printed. To include major versions use the --major flag.
+
-`,
+If a new patch/minor version is available, a notification is printed.
+
+Use "--major" to include new major versions.`,
 	Action: func(c *cli.Context) error {
 		cl, err := client.New("default")
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		stacks, err := stack.GetStacks(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, stackInfo := range stacks {
 			stackName := stackInfo.Name
 			recipeName, err := getLabel(cl, stackName, "recipe")
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			if recipeName != "" {
 				_, err = getLatestUpgrade(cl, stackName, recipeName)
 				if err != nil {
-					logrus.Fatal(err)
+					log.Fatal(err)
 				}
 			}
 		}
@@ -101,18 +105,21 @@ var UpgradeApp = cli.Command{
 	},
 	Before: internal.SubCommandBefore,
 	Description: `
-Upgrade an app by specifying its stack name and recipe. By passing "--all"
+Upgrade an app by specifying stack name and recipe. 
-instead, every deployed app is upgraded. For each apps with enabled auto
+
-updates the deployed version is compared with the current recipe catalogue
+Use "--all" to upgrade every deployed app.
-version. If a new patch/minor version is available, the app is upgraded. To
+
-include major versions use the "--major" flag. Don't do that, it will probably
+For each app with auto updates enabled, the deployed version is compared with
-break things. Only apps that are not deployed with "--chaos" are upgraded, to
+the current recipe catalogue version. If a new patch/minor version is
-update chaos deployments use the "--chaos" flag. Use it with care.
+available, the app is upgraded.
-`,
+
+To include major versions use the "--major" flag. You probably don't want that
+as it will break things. Only apps that are not deployed with "--chaos" are
+upgraded, to update chaos deployments use the "--chaos" flag. Use it with care.`,
 	Action: func(c *cli.Context) error {
 		cl, err := client.New("default")
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		if !updateAll {
@@ -120,7 +127,7 @@ update chaos deployments use the "--chaos" flag. Use it with care.
 			recipeName := c.Args().Get(1)
 			err = tryUpgrade(cl, stackName, recipeName)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			return nil
@@ -128,19 +135,19 @@ update chaos deployments use the "--chaos" flag. Use it with care.
 
 		stacks, err := stack.GetStacks(cl)
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatal(err)
 		}
 
 		for _, stackInfo := range stacks {
 			stackName := stackInfo.Name
 			recipeName, err := getLabel(cl, stackName, "recipe")
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 
 			err = tryUpgrade(cl, stackName, recipeName)
 			if err != nil {
-				logrus.Fatal(err)
+				log.Fatal(err)
 			}
 		}
 
@@ -165,7 +172,7 @@ func getLabel(cl *dockerclient.Client, stackName string, label string) (string,
 		}
 	}
 
-	logrus.Debugf("no %s label found for %s", label, stackName)
+	log.Debugf("no %s label found for %s", label, stackName)
 
 	return "", nil
 }
@@ -186,13 +193,13 @@ func getBoolLabel(cl *dockerclient.Client, stackName string, label string) (bool
 		return value, nil
 	}
 
-	logrus.Debugf("Boolean label %s could not be found for %s, set default to false.", label, stackName)
+	log.Debugf("boolean label %s could not be found for %s, set default to false.", label, stackName)
 
 	return false, nil
 }
 
 // getEnv reads env variables from docker services.
-func getEnv(cl *dockerclient.Client, stackName string) (config.AppEnv, error) {
+func getEnv(cl *dockerclient.Client, stackName string) (envfile.AppEnv, error) {
 	envMap := make(map[string]string)
 	filter := filters.NewArgs()
 	filter.Add("label", fmt.Sprintf("%s=%s", convert.LabelNamespace, stackName))
@@ -207,12 +214,12 @@ func getEnv(cl *dockerclient.Client, stackName string) (config.AppEnv, error) {
 		for _, envString := range envList {
 			splitString := strings.SplitN(envString, "=", 2)
 			if len(splitString) != 2 {
-				logrus.Debugf("can't separate key from value: %s (this variable is probably unset)", envString)
+				log.Debugf("can't separate key from value: %s (this variable is probably unset)", envString)
 				continue
 			}
 			k := splitString[0]
 			v := splitString[1]
-			logrus.Debugf("For %s read env %s with value: %s from docker service", stackName, k, v)
+			log.Debugf("for %s read env %s with value: %s from docker service", stackName, k, v)
 			envMap[k] = v
 		}
 	}
@@ -234,14 +241,14 @@ func getLatestUpgrade(cl *dockerclient.Client, stackName string, recipeName stri
 	}
 
 	if len(availableUpgrades) == 0 {
-		logrus.Debugf("no available upgrades for %s", stackName)
+		log.Debugf("no available upgrades for %s", stackName)
 		return "", nil
 	}
 
 	var chosenUpgrade string
 	if len(availableUpgrades) > 0 {
 		chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
-		logrus.Infof("%s (%s) can be upgraded from version %s to %s", stackName, recipeName, deployedVersion, chosenUpgrade)
+		log.Infof("%s (%s) can be upgraded from version %s to %s", stackName, recipeName, deployedVersion, chosenUpgrade)
 	}
 
 	return chosenUpgrade, nil
@@ -249,22 +256,22 @@ func getLatestUpgrade(cl *dockerclient.Client, stackName string, recipeName stri
 
 // getDeployedVersion returns the currently deployed version of an app.
 func getDeployedVersion(cl *dockerclient.Client, stackName string, recipeName string) (string, error) {
-	logrus.Debugf("Retrieve deployed version whether %s is already deployed", stackName)
+	log.Debugf("retrieve deployed version whether %s is already deployed", stackName)
 
-	isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
+	deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 	if err != nil {
 		return "", err
 	}
 
-	if !isDeployed {
+	if !deployMeta.IsDeployed {
 		return "", fmt.Errorf("%s is not deployed?", stackName)
 	}
 
-	if deployedVersion == "unknown" {
+	if deployMeta.Version == "unknown" {
 		return "", fmt.Errorf("failed to determine deployed version of %s", stackName)
 	}
 
-	return deployedVersion, nil
+	return deployMeta.Version, nil
 }
 
 // getAvailableUpgrades returns all available versions of an app that are newer
@@ -283,7 +290,7 @@ func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName
 	}
 
 	if len(versions) == 0 {
-		logrus.Warnf("no published releases for %s in the recipe catalogue?", recipeName)
+		log.Warnf("no published releases for %s in the recipe catalogue?", recipeName)
 		return nil, nil
 	}
 
@@ -309,29 +316,27 @@ func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName
 		}
 	}
 
-	logrus.Debugf("Available updates for %s: %s", stackName, availableUpgrades)
+	log.Debugf("available updates for %s: %s", stackName, availableUpgrades)
 
 	return availableUpgrades, nil
 }
 
 // processRecipeRepoVersion clones, pulls, checks out the version and lints the
 // recipe repository.
-func processRecipeRepoVersion(recipeName, version string) error {
+func processRecipeRepoVersion(r recipe.Recipe, version string) error {
-	if err := recipe.EnsureExists(recipeName); err != nil {
+	if err := r.EnsureExists(); err != nil {
 		return err
 	}
 
-	if err := recipe.EnsureUpToDate(recipeName); err != nil {
+	if err := r.EnsureUpToDate(); err != nil {
 		return err
 	}
 
-	if err := recipe.EnsureVersion(recipeName, version); err != nil {
+	if _, err := r.EnsureVersion(version); err != nil {
 		return err
 	}
 
-	if r, err := recipe.Get(recipeName, internal.Offline); err != nil {
+	if err := lint.LintForErrors(r); err != nil {
-		return err
-	} else if err := lint.LintForErrors(r); err != nil {
 		return err
 	}
 
@@ -339,15 +344,14 @@ func processRecipeRepoVersion(recipeName, version string) error {
 }
 
 // mergeAbraShEnv merges abra.sh env vars into the app env vars.
-func mergeAbraShEnv(recipeName string, env config.AppEnv) error {
+func mergeAbraShEnv(recipe recipe.Recipe, env envfile.AppEnv) error {
-	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, recipeName, "abra.sh")
+	abraShEnv, err := envfile.ReadAbraShEnvVars(recipe.AbraShPath)
-	abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
 	if err != nil {
 		return err
 	}
 
 	for k, v := range abraShEnv {
-		logrus.Debugf("read v:%s k: %s", v, k)
+		log.Debugf("read v:%s k: %s", v, k)
 		env[k] = v
 	}
 
@@ -355,32 +359,33 @@ func mergeAbraShEnv(recipeName string, env config.AppEnv) error {
 }
 
 // createDeployConfig merges and enriches the compose config for the deployment.
-func createDeployConfig(recipeName string, stackName string, env config.AppEnv) (*composetypes.Config, stack.Deploy, error) {
+func createDeployConfig(r recipe.Recipe, stackName string, env envfile.AppEnv) (*composetypes.Config, stack.Deploy, error) {
 	env["STACK_NAME"] = stackName
 
 	deployOpts := stack.Deploy{
 		Namespace:    stackName,
 		Prune:        false,
 		ResolveImage: stack.ResolveImageAlways,
+		Detach:       false,
 	}
 
-	composeFiles, err := config.GetComposeFiles(recipeName, env)
+	composeFiles, err := r.GetComposeFiles(env)
 	if err != nil {
 		return nil, deployOpts, err
 	}
 
 	deployOpts.Composefiles = composeFiles
-	compose, err := config.GetAppComposeConfig(stackName, deployOpts, env)
+	compose, err := appPkg.GetAppComposeConfig(stackName, deployOpts, env)
 	if err != nil {
 		return nil, deployOpts, err
 	}
 
-	config.ExposeAllEnv(stackName, compose, env)
+	appPkg.ExposeAllEnv(stackName, compose, env)
 
 	// after the upgrade the deployment won't be in chaos state anymore
-	config.SetChaosLabel(compose, stackName, false)
+	appPkg.SetChaosLabel(compose, stackName, false)
-	config.SetRecipeLabel(compose, stackName, recipeName)
+	appPkg.SetRecipeLabel(compose, stackName, r.Name)
-	config.SetUpdateLabel(compose, stackName, env)
+	appPkg.SetUpdateLabel(compose, stackName, env)
 
 	return compose, deployOpts, nil
 }
@@ -388,7 +393,7 @@ func createDeployConfig(recipeName string, stackName string, env config.AppEnv)
 // tryUpgrade performs the upgrade if all the requirements are fulfilled.
 func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error {
 	if recipeName == "" {
-		logrus.Debugf("don't update %s due to missing recipe name", stackName)
+		log.Debugf("don't update %s due to missing recipe name", stackName)
 		return nil
 	}
 
@@ -398,7 +403,7 @@ func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error {
 	}
 
 	if chaos && !internal.Chaos {
-		logrus.Debugf("don't update %s due to chaos deployment", stackName)
+		log.Debugf("don't update %s due to chaos deployment", stackName)
 		return nil
 	}
 
@@ -408,7 +413,7 @@ func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error {
 	}
 
 	if !updatesEnabled {
-		logrus.Debugf("don't update %s due to disabled auto updates or missing ENABLE_AUTO_UPDATE env", stackName)
+		log.Debugf("don't update %s due to disabled auto updates or missing ENABLE_AUTO_UPDATE env", stackName)
 		return nil
 	}
 
@@ -418,7 +423,7 @@ func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error {
 	}
 
 	if upgradeVersion == "" {
-		logrus.Debugf("don't update %s due to no new version", stackName)
+		log.Debugf("don't update %s due to no new version", stackName)
 		return nil
 	}
 
@@ -428,34 +433,35 @@ func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error {
 }
 
 // upgrade performs all necessary steps to upgrade an app.
-func upgrade(cl *dockerclient.Client, stackName, recipeName,
+func upgrade(cl *dockerclient.Client, stackName, recipeName, upgradeVersion string) error {
-	upgradeVersion string) error {
 	env, err := getEnv(cl, stackName)
 	if err != nil {
 		return err
 	}
 
-	app := config.App{
+	app := appPkg.App{
 		Name:   stackName,
-		Recipe: recipeName,
+		Recipe: recipe.Get(recipeName),
 		Server: SERVER,
 		Env:    env,
 	}
 
-	if err = processRecipeRepoVersion(recipeName, upgradeVersion); err != nil {
+	r := recipe.Get(recipeName)
+
+	if err = processRecipeRepoVersion(r, upgradeVersion); err != nil {
 		return err
 	}
 
-	if err = mergeAbraShEnv(recipeName, app.Env); err != nil {
+	if err = mergeAbraShEnv(app.Recipe, app.Env); err != nil {
 		return err
 	}
 
-	compose, deployOpts, err := createDeployConfig(recipeName, stackName, app.Env)
+	compose, deployOpts, err := createDeployConfig(r, stackName, app.Env)
 	if err != nil {
 		return err
 	}
 
-	logrus.Infof("upgrade %s (%s) to version %s", stackName, recipeName, upgradeVersion)
+	log.Infof("upgrade %s (%s) to version %s", stackName, recipeName, upgradeVersion)
 
 	err = stack.RunDeploy(cl, deployOpts, compose, stackName, true)
 
@@ -481,7 +487,8 @@ func newAbraApp(version, commit string) *cli.App {
 	}
 
 	app.Before = func(c *cli.Context) error {
-		logrus.Debugf("kadabra version %s, commit %s", version, commit)
+		charmLog.SetDefault(log.Logger)
+		log.Debugf("kadabra version %s, commit %s", version, commit)
 		return nil
 	}
 
@@ -493,6 +500,6 @@ func RunApp(version, commit string) {
 	app := newAbraApp(version, commit)
 
 	if err := app.Run(os.Args); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 }

go.mod

@@ -6,10 +6,10 @@ require (
 	coopcloud.tech/tagcmp v0.0.0-20230809071031-eb3e7758d4eb
 	git.coopcloud.tech/coop-cloud/godotenv v1.5.2-0.20231130100509-01bff8284355
 	github.com/AlecAivazis/survey/v2 v2.3.7
-	github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4
+	github.com/charmbracelet/log v0.4.0
-	github.com/distribution/distribution v2.8.3+incompatible
+	github.com/distribution/reference v0.6.0
-	github.com/docker/cli v26.1.4+incompatible
+	github.com/docker/cli v27.0.3+incompatible
-	github.com/docker/docker v26.1.4+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.12.0
 	github.com/google/go-cmp v0.6.0
@@ -18,7 +18,7 @@ require (
 	github.com/olekukonko/tablewriter v0.0.5
 	github.com/pkg/errors v0.9.1
 	github.com/schollz/progressbar/v3 v3.14.4
-	github.com/sirupsen/logrus v1.9.3
+	gopkg.in/yaml.v3 v3.0.1
 	gotest.tools/v3 v3.5.1
 )
 
@@ -28,16 +28,18 @@ require (
 	github.com/BurntSushi/toml v1.4.0 // indirect
 	github.com/Microsoft/go-winio v0.6.2 // 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/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.4 // indirect
 	github.com/cyphar/filepath-securejoin v0.2.5 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/distribution/reference v0.6.0 // indirect
+	github.com/docker/distribution v2.8.3+incompatible // indirect
-	github.com/docker/distribution v2.7.1+incompatible // indirect
 	github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c // indirect
 	github.com/docker/go-connections v0.5.0 // indirect
 	github.com/docker/go-metrics v0.0.1 // indirect
@@ -47,10 +49,13 @@ require (
 	github.com/ghodss/yaml v1.0.0 // indirect
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
 	github.com/go-git/go-billy/v5 v5.5.0 // indirect
+	github.com/go-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.0.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // 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.20.0 // indirect
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
@@ -58,6 +63,7 @@ require (
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/kevinburke/ssh_config v1.2.0 // indirect
 	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/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.15 // indirect
@@ -68,53 +74,54 @@ require (
 	github.com/moby/docker-image-spec v1.3.1 // 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/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.54.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.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/contrib/instrumentation/net/http/otelhttp v0.52.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 // indirect
-	go.opentelemetry.io/otel v1.27.0 // indirect
+	go.opentelemetry.io/otel v1.28.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.27.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.27.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 // indirect
-	go.opentelemetry.io/otel/metric v1.27.0 // indirect
+	go.opentelemetry.io/otel/metric v1.28.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.27.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.28.0 // indirect
-	go.opentelemetry.io/otel/sdk/metric v1.27.0 // indirect
+	go.opentelemetry.io/otel/sdk/metric v1.28.0 // indirect
-	go.opentelemetry.io/otel/trace v1.27.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.24.0 // indirect
+	golang.org/x/crypto v0.25.0 // indirect
-	golang.org/x/net v0.26.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.21.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-20240617180043-68d350f18fd4 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240617180043-68d350f18fd4 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect
-	google.golang.org/grpc v1.64.0 // 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
-	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
 require (
-	github.com/buger/goterm v1.0.4
+	github.com/containerd/containerd v1.7.19 // indirect
-	github.com/containerd/containerd v1.7.18 // indirect
 	github.com/containers/image v3.0.2+incompatible
 	github.com/containers/storage v1.38.2 // indirect
 	github.com/decentral1se/passgen v1.0.1
 	github.com/docker/docker-credential-helpers v0.8.2 // indirect
-	github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 // indirect
 	github.com/fvbommel/sortorder v1.1.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/gorilla/mux v1.8.1 // indirect
@@ -129,5 +136,5 @@ require (
 	github.com/theupdateframework/notary v0.7.0 // indirect
 	github.com/urfave/cli v1.22.15
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
-	golang.org/x/sys v0.21.0
+	golang.org/x/sys v0.22.0
 )

go.sum

@@ -53,8 +53,6 @@ github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbi
 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=
-github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4 h1:vdT7QwBhJJEVNFMBNhRSFDRCB6O16T28VhvqRgqFyn8=
-github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4/go.mod h1:SvXOG8ElV28oAiG9zv91SDe5+9PfIr7PPccpr8YyXNs=
 github.com/Microsoft/go-winio v0.4.11/go.mod h1:VhR8bwka0BXejwEJY73c50VrPtXAaKcyvVC4A4RozmA=
 github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA=
 github.com/Microsoft/go-winio v0.4.15-0.20190919025122-fc70bd9a86b5/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw=
@@ -76,8 +74,6 @@ github.com/Microsoft/hcsshim v0.8.15/go.mod h1:x38A4YbHbdxJtc0sF6oIz+RG0npwSCAvn
 github.com/Microsoft/hcsshim v0.8.16/go.mod h1:o5/SZqmR7x9JNKsW3pu+nqHm0MF8vbA+VxGOoXdC600=
 github.com/Microsoft/hcsshim v0.8.21/go.mod h1:+w2gRZ5ReXQhFOrvSQeNfhrYB/dg3oDwTOcER2fw4I4=
 github.com/Microsoft/hcsshim v0.9.2/go.mod h1:7pLA8lDk46WKDWlVsENo92gC0XFa8rbKfyFRBqxEbCc=
-github.com/Microsoft/hcsshim v0.11.5 h1:haEcLNpj9Ka1gd3B3tAEs9CpE0c+1IhoL59w/exYU38=
-github.com/Microsoft/hcsshim v0.11.5/go.mod h1:MV8xMfmECjl5HdO7U/3/hFVnkmSBjAjmA09d4bExKcU=
 github.com/Microsoft/hcsshim/test v0.0.0-20201218223536-d3e5debf77da/go.mod h1:5hlzMzRKMLyo42nCZ9oml8AdTlq/0cvIaBv6tK1RehU=
 github.com/Microsoft/hcsshim/test v0.0.0-20210227013316-43a75bb4edd3/go.mod h1:mw7qgWloBUl75W/gVH3cQszUg1+gUITj7D6NY7ywVnY=
 github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
@@ -106,6 +102,8 @@ github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPd
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
 github.com/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/beorn7/perks v0.0.0-20150223135152-b965b613227f/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v0.0.0-20160804104726-4c0e84591b9a/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
@@ -120,8 +118,6 @@ github.com/blang/semver v3.1.0+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnweb
 github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
 github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
 github.com/bshuster-repo/logrus-logstash-hook v0.4.1/go.mod h1:zsTqEiSzDgAa/8GZR7E1qaXrhYNDKBYy5/dWPTIflbk=
-github.com/buger/goterm v1.0.4 h1:Z9YvGmOih81P0FbVtEYTFF6YsSgxSUKEhf/f9bTMXbY=
-github.com/buger/goterm v1.0.4/go.mod h1:HiFWV3xnkolgrBV3mY8m0X0Pumt4zg4QhbdOzQtB8tE=
 github.com/buger/jsonparser v0.0.0-20180808090653-f4dd9f5a6b44/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s=
 github.com/bugsnag/bugsnag-go v0.0.0-20141110184014-b1d153021fcd/go.mod h1:2oa8nejYd4cQ/b0hMIopN0lCRxU0bueqREvZLWFrtK8=
 github.com/bugsnag/bugsnag-go v1.0.5-0.20150529004307-13fd6b8acda0 h1:s7+5BfS4WFJoVF9pnB8kBk03S7pZXRdKamnV0FOl5Sc=
@@ -139,6 +135,12 @@ github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghf
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/charmbracelet/lipgloss v0.11.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.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=
@@ -195,8 +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.18 h1:jqjZTQNfXGoEaZdW1WwPU0RqSn1Bm2Ay/KJPUuO8nao=
+github.com/containerd/containerd v1.7.19 h1:/xQ4XRJ0tamDkdzrrBAUy/LE5nCcxFKdBm4EcPrSMEE=
-github.com/containerd/containerd v1.7.18/go.mod h1:IYEk9/IO6wAPUz2bCMVUbsfXjzw5UNP5fLz4PsUygQ4=
+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=
@@ -297,21 +299,20 @@ github.com/denverdino/aliyungo v0.0.0-20190125010748-a747050bb1ba/go.mod h1:dV8l
 github.com/dgrijalva/jwt-go v0.0.0-20170104182250-a601269ab70c/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/distribution/distribution v2.8.3+incompatible h1:RlpEXBLq/WPXYvBYMDAmBX/SnhD67qwtvW/DzKc8pAo=
-github.com/distribution/distribution v2.8.3+incompatible/go.mod h1:EgLm2NgWtdKgzF9NpMzUKgzmR7AMmb0VQi2B+ZzDRjc=
 github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
 github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
 github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
 github.com/docker/cli v0.0.0-20191017083524-a8ff7f821017/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
-github.com/docker/cli v26.1.4+incompatible h1:I8PHdc0MtxEADqYJZvhBrW9bo8gawKwwenxRM7/rLu8=
+github.com/docker/cli v27.0.3+incompatible h1:usGs0/BoBW8MWxGeEtqPMkzOY56jZ6kYlSN5BLDioCQ=
-github.com/docker/cli v26.1.4+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+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 h1:a5mlkVzth6W5A4fOsS3D2EO5BUmsJpcB+cRlLU7cSug=
 github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
+github.com/docker/distribution v2.8.3+incompatible h1:AtKxIZ36LoNK51+Z6RpzLpddBirtxJnzDrHLEKxTAYk=
+github.com/docker/distribution v2.8.3+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/docker v1.4.2-0.20190924003213-a8608b5b67c7/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
-github.com/docker/docker v26.1.4+incompatible h1:vuTpXDuoga+Z38m1OZHzl7NKisKWaWlhjQk7IDPSLsU=
+github.com/docker/docker v27.0.3+incompatible h1:aBGI9TeQ4MPlhquTQKq9XbK79rKFVwXNUAYz9aXyEBE=
-github.com/docker/docker v26.1.4+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+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=
@@ -351,8 +352,6 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.m
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5/go.mod h1:a2zkGnVExMxdzMo3M0Hi/3sEU+cWnZpSni0O6/Yb/P0=
 github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
-github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 h1:JWuenKqqX8nojtoVVWjGfOF9635RETekkoH6Cc9SX0A=
-github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
 github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
@@ -389,6 +388,8 @@ github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
+github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
 github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
 github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
@@ -410,6 +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.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=
@@ -493,6 +496,8 @@ github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
 github.com/googleapis/gnostic v0.4.1/go.mod h1:LRhVm6pbyptWbWbuZ38d1eyptfvIytN3ir6b65WBswg=
@@ -596,6 +601,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 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=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/magiconair/properties v1.5.3/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
@@ -668,7 +675,10 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY
 github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
 github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
 github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ=
+github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo=
+github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8=
 github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
@@ -768,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.54.0 h1:ZlZy0BgJhTwVZUn7dLOkwCZHUkrAqd3WYtcFCWnM1D8=
+github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
-github.com/prometheus/common v0.54.0/go.mod h1:/TQgMJP5CuVYveyT7n/0Ix8yLNNXy9yRSkhnLTHPDIQ=
+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=
@@ -923,26 +933,26 @@ go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.52.0 h1:9l89oX4ba9kHbBol3Xin3leYJ+252h0zszDtBwyKe2A=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 h1:4K4tsIXefpVJtvA/8srF4V4y0akAoPHkIslgAkjixJA=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.52.0/go.mod h1:XLZfZboOJWHNKUv7eH0inh0E9VV6eWDFB/9yJyTLPp0=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0/go.mod h1:jjdQuTGVsXV4vSs+CJ2qYDeDPf9yIJV23qlIzBm73Vg=
-go.opentelemetry.io/otel v1.27.0 h1:9BZoF3yMK/O1AafMiQTVu0YDj5Ea4hPhxCs7sGva+cg=
+go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo=
-go.opentelemetry.io/otel v1.27.0/go.mod h1:DMpAK8fzYRzs+bi3rS5REupisuqTheUlSZJ1WnZaPAQ=
+go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.27.0 h1:bFgvUr3/O4PHj3VQcFEuYKvRZJX1SJDQ+11JXuSB3/w=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 h1:U2guen0GhqH8o/G2un8f/aG/y++OuW6MyCo6hT9prXk=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.27.0/go.mod h1:xJntEd2KL6Qdg5lwp97HMLQDVeAhrYxmzFseAMDPQ8I=
+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.27.0 h1:R9DE4kQ4k+YtfLI2ULwX82VtNQ2J8yZmA7ZIF/D+7Mc=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 h1:3Q/xZUyC1BBkualc9ROb4G8qkH90LXEIICcs5zv1OYY=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.27.0/go.mod h1:OQFyQVrDlbe+R7xrEyDr/2Wr67Ol0hRUgsfA+V5A95s=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0/go.mod h1:s75jGIWA9OfCMzF0xr+ZgfrB5FEbbV7UuYo32ahUiFI=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0 h1:qFffATk0X+HD+f1Z8lswGiOQYKHRlzfmdJm0wEaVrFA=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 h1:R3X6ZXmNPRR8ul6i3WgFURCHzaXjHdm0karRG/+dj3s=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0/go.mod h1:MOiCmryaYtc+V0Ei+Tx9o5S1ZjA7kzLucuVuyzBZloQ=
+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.27.0 h1:hvj3vdEKyeCi4YaYfNjv2NUje8FqKqUY8IlF0FxV/ik=
+go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bOeuA5Q=
-go.opentelemetry.io/otel/metric v1.27.0/go.mod h1:mVFgmRlhljgBiuk/MP/oKylr4hs85GZAylncepAX/ak=
+go.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s=
-go.opentelemetry.io/otel/sdk v1.27.0 h1:mlk+/Y1gLPLn84U4tI8d3GNJmGT/eXe3ZuOXN9kTWmI=
+go.opentelemetry.io/otel/sdk v1.28.0 h1:b9d7hIry8yZsgtbmM0DKyPWMMUMlK9NEKuIG4aBqWyE=
-go.opentelemetry.io/otel/sdk v1.27.0/go.mod h1:Ha9vbLwJE6W86YstIywK2xFfPjbWlCuwPtMkKdz/Y4A=
+go.opentelemetry.io/otel/sdk v1.28.0/go.mod h1:oYj7ClPUA7Iw3m+r7GeEjz0qckQRJK2B8zjcZEfu7Pg=
-go.opentelemetry.io/otel/sdk/metric v1.27.0 h1:5uGNOlpXi+Hbo/DRoI31BSb1v+OGcpv2NemcCrOL8gI=
+go.opentelemetry.io/otel/sdk/metric v1.28.0 h1:OkuaKgKrgAbYrrY0t92c+cC+2F6hsFNnCQArXCKlg08=
-go.opentelemetry.io/otel/sdk/metric v1.27.0/go.mod h1:we7jJVrYN2kh3mVBlswtPU22K0SA+769l93J6bsyvqw=
+go.opentelemetry.io/otel/sdk/metric v1.28.0/go.mod h1:cWPjykihLAPvXKi4iZc1dpER3Jdq2Z0YLse3moQUCpg=
-go.opentelemetry.io/otel/trace v1.27.0 h1:IqYb813p7cmbHk0a5y6pD5JPakbVfftRXABGt5/Rscw=
+go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+lkx9g=
-go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39SuvvstaLBl+l4=
+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.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0=
 go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8=
@@ -972,8 +982,8 @@ golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5y
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
 golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
-golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
+golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
+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=
@@ -984,6 +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-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=
@@ -1051,8 +1063,8 @@ golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug
 golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
-golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
+golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
+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=
@@ -1137,7 +1149,6 @@ golang.org/x/sys v0.0.0-20201202213521-69691e467435/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210331175145-43e1dd70ce54/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -1156,8 +1167,8 @@ golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+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=
@@ -1165,8 +1176,8 @@ golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
-golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
+golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk=
-golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
+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=
@@ -1282,10 +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-20240617180043-68d350f18fd4 h1:MuYw1wJzT+ZkybKfaOXKp5hJiZDn2iHaXRw0mRYdHSc=
+google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094 h1:0+ozOGcrp+Y8Aq8TLNN2Aliibms5LEzsq99ZZmAGYm0=
-google.golang.org/genproto/googleapis/api v0.0.0-20240617180043-68d350f18fd4/go.mod h1:px9SlOOZBg1wM1zdnr8jEL4CNGUBZ+ZKYtNPApNQc4c=
+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-20240617180043-68d350f18fd4 h1:Di6ANFilr+S60a4S61ZM00vLdw0IrQOSMS2/6mrnOU0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 h1:BwIjyKYGsK9dMCBOorzRri8MQwmi7mT9rGHsCEinZkA=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240617180043-68d350f18fd4/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
+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=
@@ -1305,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.64.0 h1:KH3VH9y/MgNQg1dE7b3XfVK0GsPSIzJwdF617gUSbvY=
+google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=
-google.golang.org/grpc v1.64.0/go.mod h1:oxjF8E3FBnjp+/gVFYdWacaLDx9na1aqy9oovLpxQYg=
+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=

pkg/app/app.go

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

pkg/app/app_test.go

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

pkg/app/compose.go

@@ -0,0 +1,88 @@
+package app
+
+import (
+	"fmt"
+	"strconv"
+
+	"coopcloud.tech/abra/pkg/envfile"
+	"coopcloud.tech/abra/pkg/log"
+	composetypes "github.com/docker/cli/cli/compose/types"
+)
+
+// SetRecipeLabel adds the label 'coop-cloud.${STACK_NAME}.recipe=${RECIPE}' to the app container
+// to signal which recipe is connected to the deployed app
+func SetRecipeLabel(compose *composetypes.Config, stackName string, recipe string) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			log.Debugf("set recipe label 'coop-cloud.%s.recipe' to %s for %s", stackName, recipe, stackName)
+			labelKey := fmt.Sprintf("coop-cloud.%s.recipe", stackName)
+			service.Deploy.Labels[labelKey] = recipe
+		}
+	}
+}
+
+// SetChaosLabel adds the label 'coop-cloud.${STACK_NAME}.chaos=true/false' to the app container
+// to signal if the app is deployed in chaos mode
+func SetChaosLabel(compose *composetypes.Config, stackName string, chaos bool) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			log.Debugf("set label 'coop-cloud.%s.chaos' to %v for %s", stackName, chaos, stackName)
+			labelKey := fmt.Sprintf("coop-cloud.%s.chaos", stackName)
+			service.Deploy.Labels[labelKey] = strconv.FormatBool(chaos)
+		}
+	}
+}
+
+// SetChaosVersionLabel adds the label 'coop-cloud.${STACK_NAME}.chaos-version=$(GIT_COMMIT)' to the app container
+func SetChaosVersionLabel(compose *composetypes.Config, stackName string, chaosVersion string) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			log.Debugf("set label 'coop-cloud.%s.chaos-version' to %v for %s", stackName, chaosVersion, stackName)
+			labelKey := fmt.Sprintf("coop-cloud.%s.chaos-version", stackName)
+			service.Deploy.Labels[labelKey] = chaosVersion
+		}
+	}
+}
+
+// SetUpdateLabel adds env ENABLE_AUTO_UPDATE as label to enable/disable the
+// auto update process for this app. The default if this variable is not set is to disable
+// the auto update process.
+func SetUpdateLabel(compose *composetypes.Config, stackName string, appEnv envfile.AppEnv) {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			enable_auto_update, exists := appEnv["ENABLE_AUTO_UPDATE"]
+			if !exists {
+				enable_auto_update = "false"
+			}
+			log.Debugf("set label 'coop-cloud.%s.autoupdate' to %s for %s", stackName, enable_auto_update, stackName)
+			labelKey := fmt.Sprintf("coop-cloud.%s.autoupdate", stackName)
+			service.Deploy.Labels[labelKey] = enable_auto_update
+		}
+	}
+}
+
+// GetLabel reads docker labels in the format of "coop-cloud.${STACK_NAME}.${LABEL}" from the local compose files
+func GetLabel(compose *composetypes.Config, stackName string, label string) string {
+	for _, service := range compose.Services {
+		if service.Name == "app" {
+			labelKey := fmt.Sprintf("coop-cloud.%s.%s", stackName, label)
+			log.Debugf("get label '%s'", labelKey)
+			if labelValue, ok := service.Deploy.Labels[labelKey]; ok {
+				return labelValue
+			}
+		}
+	}
+	log.Debugf("no %s label found for %s", label, stackName)
+	return ""
+}
+
+// GetTimeoutFromLabel reads the timeout value from docker label "coop-cloud.${STACK_NAME}.TIMEOUT" and returns 50 as default value
+func GetTimeoutFromLabel(compose *composetypes.Config, stackName string) (int, error) {
+	timeout := 50 // Default Timeout
+	var err error = nil
+	if timeoutLabel := GetLabel(compose, stackName, "timeout"); timeoutLabel != "" {
+		log.Debugf("timeout label: %s", timeoutLabel)
+		timeout, err = strconv.Atoi(timeoutLabel)
+	}
+	return timeout, err
+}

pkg/autocomplete/autocomplete.go

@@ -3,17 +3,17 @@ package autocomplete
 import (
 	"fmt"
 
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/app"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
 // AppNameComplete copletes app names.
 func AppNameComplete(c *cli.Context) {
-	appNames, err := config.GetAppNames()
+	appNames, err := app.GetAppNames()
 	if err != nil {
-		logrus.Warn(err)
+		log.Warn(err)
 	}
 
 	if c.NArg() > 0 {
@@ -26,7 +26,7 @@ func AppNameComplete(c *cli.Context) {
 }
 
 func ServiceNameComplete(appName string) {
-	serviceNames, err := config.GetAppServiceNames(appName)
+	serviceNames, err := app.GetAppServiceNames(appName)
 	if err != nil {
 		return
 	}
@@ -39,7 +39,7 @@ func ServiceNameComplete(appName string) {
 func RecipeNameComplete(c *cli.Context) {
 	catl, err := recipe.ReadRecipeCatalogue(false)
 	if err != nil {
-		logrus.Warn(err)
+		log.Warn(err)
 	}
 
 	if c.NArg() > 0 {
@@ -55,7 +55,7 @@ func RecipeNameComplete(c *cli.Context) {
 func RecipeVersionComplete(recipeName string) {
 	catl, err := recipe.ReadRecipeCatalogue(false)
 	if err != nil {
-		logrus.Warn(err)
+		log.Warn(err)
 	}
 
 	for _, v := range catl[recipeName].Versions {
@@ -67,9 +67,9 @@ func RecipeVersionComplete(recipeName string) {
 
 // ServerNameComplete completes server names.
 func ServerNameComplete(c *cli.Context) {
-	files, err := config.LoadAppFiles("")
+	files, err := app.LoadAppFiles("")
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	if c.NArg() > 0 {

pkg/catalogue/catalogue.go

@@ -8,21 +8,21 @@ import (
 
 	"coopcloud.tech/abra/pkg/config"
 	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
 )
 
 // EnsureCatalogue ensures that the catalogue is cloned locally & present.
 func EnsureCatalogue() error {
 	catalogueDir := path.Join(config.ABRA_DIR, "catalogue")
 	if _, err := os.Stat(catalogueDir); err != nil && os.IsNotExist(err) {
-		logrus.Warnf("local recipe catalogue is missing, retrieving now")
+		log.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
 		}
 
-		logrus.Debugf("cloned catalogue repository to %s", catalogueDir)
+		log.Debugf("cloned catalogue repository to %s", catalogueDir)
 	}
 
 	return nil
@@ -57,7 +57,7 @@ func EnsureUpToDate() error {
 
 	if len(remotes) == 0 {
 		msg := "cannot ensure %s is up-to-date, no git remotes configured"
-		logrus.Debugf(msg, config.CATALOGUE_DIR)
+		log.Debugf(msg, config.CATALOGUE_DIR)
 		return nil
 	}
 
@@ -82,7 +82,7 @@ func EnsureUpToDate() error {
 		}
 	}
 
-	logrus.Debugf("fetched latest git changes for %s", config.CATALOGUE_DIR)
+	log.Debugf("fetched latest git changes for %s", config.CATALOGUE_DIR)
 
 	return nil
 }

pkg/client/client.go

@@ -10,17 +10,32 @@ import (
 	"time"
 
 	contextPkg "coopcloud.tech/abra/pkg/context"
+	"coopcloud.tech/abra/pkg/log"
 	sshPkg "coopcloud.tech/abra/pkg/ssh"
 	commandconnPkg "coopcloud.tech/abra/pkg/upstream/commandconn"
 	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
+// Conf is a Docker client configuration.
+type Conf struct {
+	Timeout int
+}
+
+// Opt is a Docker client option.
+type Opt func(c *Conf)
+
+// WithTimeout specifies a timeout for a Docker client.
+func WithTimeout(timeout int) Opt {
+	return func(c *Conf) {
+		c.Timeout = timeout
+	}
+}
+
 // New initiates a new Docker client. New client connections are validated so
 // that we ensure connections via SSH to the daemon can succeed. It takes into
 // account that you may only want the local client and not communicate via SSH.
 // For this use-case, please pass "default" as the contextName.
-func New(serverName string) (*client.Client, error) {
+func New(serverName string, opts ...Opt) (*client.Client, error) {
 	var clientOpts []client.Opt
 
 	if serverName != "default" {
@@ -34,7 +49,12 @@ func New(serverName string) (*client.Client, error) {
 			return nil, err
 		}
 
-		helper, err := commandconnPkg.NewConnectionHelper(ctxEndpoint)
+		conf := &Conf{}
+		for _, opt := range opts {
+			opt(conf)
+		}
+
+		helper, err := commandconnPkg.NewConnectionHelper(ctxEndpoint, conf.Timeout)
 		if err != nil {
 			return nil, err
 		}
@@ -65,7 +85,7 @@ func New(serverName string) (*client.Client, error) {
 		return nil, err
 	}
 
-	logrus.Debugf("created client for %s", serverName)
+	log.Debugf("created client for %s", serverName)
 
 	info, err := cl.Info(context.Background())
 	if err != nil {
@@ -75,9 +95,9 @@ func New(serverName string) (*client.Client, error) {
 	if info.Swarm.LocalNodeState == "inactive" {
 		if serverName != "default" {
 			return cl, fmt.Errorf("swarm mode not enabled on %s?", serverName)
-		} else {
-			return cl, errors.New("swarm mode not enabled on local server?")
 		}
+
+		return cl, errors.New("swarm mode not enabled on local server?")
 	}
 
 	return cl, nil

pkg/client/context.go

@@ -5,11 +5,11 @@ import (
 	"fmt"
 
 	"coopcloud.tech/abra/pkg/context"
+	"coopcloud.tech/abra/pkg/log"
 	commandconnPkg "coopcloud.tech/abra/pkg/upstream/commandconn"
 	dConfig "github.com/docker/cli/cli/config"
 	"github.com/docker/cli/cli/context/docker"
 	contextStore "github.com/docker/cli/cli/context/store"
-	"github.com/sirupsen/logrus"
 )
 
 type Context = contextStore.Metadata
@@ -22,7 +22,7 @@ func CreateContext(contextName string) error {
 		return err
 	}
 
-	logrus.Debugf("created the %s context", contextName)
+	log.Debugf("created the %s context", contextName)
 
 	return nil
 }

pkg/client/volumes.go

@@ -5,10 +5,10 @@ import (
 	"fmt"
 	"time"
 
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/volume"
 	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
 func GetVolumes(cl *client.Client, ctx context.Context, server string, fs filters.Args) ([]*volume.Volume, error) {
@@ -54,7 +54,7 @@ func retryFunc(retries int, fn func() error) error {
 		}
 		if i+1 < retries {
 			sleep := time.Duration(i+1) * time.Duration(i+1)
-			logrus.Infof("%s: waiting %d seconds before next retry", err, sleep)
+			log.Infof("%s: waiting %d seconds before next retry", err, sleep)
 			time.Sleep(sleep * time.Second)
 		}
 	}

pkg/compose/compose.go

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

pkg/config/abra.go

@@ -0,0 +1,110 @@
+package config
+
+import (
+	"os"
+	"path"
+	"path/filepath"
+
+	"coopcloud.tech/abra/pkg/log"
+	"gopkg.in/yaml.v3"
+)
+
+// LoadAbraConfig returns the abra configuration. It tries to find a abra
+// configuration file (see findAbraConfig for lookup logic). When no
+// configuration was found it returns the default config.
+func LoadAbraConfig() Abra {
+	wd, _ := os.Getwd()
+	configFile := findAbraConfig(wd)
+	if configFile == "" {
+		log.Debugf("no config file found")
+		return Abra{}
+	}
+	data, err := os.ReadFile(configFile)
+	if err != nil {
+		// Do nothing, when an error occurs
+		log.Debugf("error reading config file: %s", err)
+		return Abra{}
+	}
+
+	config := Abra{}
+	err = yaml.Unmarshal(data, &config)
+	if err != nil {
+		// Do nothing, when an error occurs
+		log.Debugf("error loading config file: %s", err)
+		return Abra{}
+	}
+	log.Debugf("config file loaded from: %s", configFile)
+	config.configPath = filepath.Dir(configFile)
+	return config
+}
+
+// findAbraConfig recursively looks for a abra.y(a)ml file in the given directory.
+// When the file was not found it calls the function again with the parent
+// directory until the home directory is hit. When no abra config was found it
+// returns an empty string.
+func findAbraConfig(dir string) string {
+	dir, err := filepath.Abs(dir)
+	if err != nil {
+		return ""
+	}
+	if dir == os.ExpandEnv("$HOME") || dir == "/" {
+		return ""
+	}
+	p := path.Join(dir, "abra.yaml")
+	if _, err := os.Stat(p); err == nil {
+		return p
+	}
+	p = path.Join(dir, "abra.yml")
+	if _, err := os.Stat(p); err == nil {
+		return p
+	}
+	return findAbraConfig(filepath.Dir(dir))
+}
+
+// Abra defines the configuration file for abra.
+type Abra struct {
+	configPath string
+	AbraDir    string `yaml:"abraDir"`
+}
+
+// GetAbraDir returns the abra dir. It has the following logic:
+// 1. check if $ABRA_DIR is set
+// 2. check if abraDir was set in a config file
+// 3. use $HOME/.abra when above two options failed
+func (a Abra) GetAbraDir() string {
+	if dir, exists := os.LookupEnv("ABRA_DIR"); exists && dir != "" {
+		log.Debug("read abra dir from $ABRA_DIR")
+		return dir
+	}
+	if a.AbraDir != "" {
+		log.Debug("read abra dir from config file")
+		if path.IsAbs(a.AbraDir) {
+			return a.AbraDir
+		}
+		// Make the path absolute
+		return path.Join(a.configPath, a.AbraDir)
+	}
+	log.Debug("using default abra dir")
+	return os.ExpandEnv("$HOME/.abra")
+}
+
+func (a Abra) GetServersDir() string   { return path.Join(a.GetAbraDir(), "servers") }
+func (a Abra) GetRecipesDir() string   { return path.Join(a.GetAbraDir(), "recipes") }
+func (a Abra) GetVendorDir() string    { return path.Join(a.GetAbraDir(), "vendor") }
+func (a Abra) GetBackupDir() string    { return path.Join(a.GetAbraDir(), "backups") }
+func (a Abra) GetCatalogueDir() string { return path.Join(a.GetAbraDir(), "catalogue") }
+
+var config = LoadAbraConfig()
+
+var (
+	ABRA_DIR                 = config.GetAbraDir()
+	SERVERS_DIR              = config.GetServersDir()
+	RECIPES_DIR              = config.GetRecipesDir()
+	VENDOR_DIR               = config.GetVendorDir()
+	BACKUP_DIR               = config.GetBackupDir()
+	CATALOGUE_DIR            = config.GetCatalogueDir()
+	RECIPES_JSON             = path.Join(config.GetCatalogueDir(), "recipes.json")
+	REPOS_BASE_URL           = "https://git.coopcloud.tech/coop-cloud"
+	CATALOGUE_JSON_REPO_NAME = "recipes-catalogue-json"
+	SSH_URL_TEMPLATE         = "ssh://git@git.coopcloud.tech:2222/coop-cloud/%s.git"
+)

pkg/config/abra_test.go

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

pkg/config/app.go

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

pkg/config/env.go

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

pkg/config/testdata/abraconfig1/abra.yaml

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

pkg/container/container.go

@@ -6,12 +6,12 @@ import (
 	"strings"
 
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/docker/api/types"
 	containerTypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
 // GetContainer retrieves a container. If noInput is false and the retrievd
@@ -43,7 +43,7 @@ func GetContainer(c context.Context, cl *client.Client, filters filters.Args, no
 			return types.Container{}, err
 		}
 
-		logrus.Warnf("ambiguous container list received, prompting for input")
+		log.Warnf("ambiguous container list received, prompting for input")
 
 		var response string
 		prompt := &survey.Select{
@@ -64,7 +64,7 @@ func GetContainer(c context.Context, cl *client.Client, filters filters.Args, no
 			}
 		}
 
-		logrus.Panic("failed to match chosen container")
+		log.Fatal("failed to match chosen container")
 	}
 
 	return containers[0], nil

pkg/dns/dns.go

@@ -9,7 +9,7 @@ import (
 func EnsureIPv4(domainName string) (string, error) {
 	ipv4, err := net.ResolveIPAddr("ip4", domainName)
 	if err != nil {
-		return "", 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

pkg/envfile/envfile.go

@@ -0,0 +1,97 @@
+package envfile
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"coopcloud.tech/abra/pkg/log"
+	"git.coopcloud.tech/coop-cloud/godotenv"
+)
+
+// envVarModifiers is a list of env var modifier strings. These are added to
+// env vars as comments and modify their processing by Abra, e.g. determining
+// how long secrets should be.
+var envVarModifiers = []string{"length"}
+
+// AppEnv is a map of the values in an apps env config
+type AppEnv = map[string]string
+
+// AppModifiers is a map of modifiers in an apps env config
+type AppModifiers = map[string]map[string]string
+
+// ReadEnv loads an app envivornment into a map.
+func ReadEnv(filePath string) (AppEnv, error) {
+	var envVars AppEnv
+
+	envVars, _, err := godotenv.Read(filePath)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Debugf("read %s from %s", envVars, filePath)
+
+	return envVars, nil
+}
+
+// ReadEnv loads an app envivornment and their modifiers in two different maps.
+func ReadEnvWithModifiers(filePath string) (AppEnv, AppModifiers, error) {
+	var envVars AppEnv
+
+	envVars, mods, err := godotenv.Read(filePath)
+	if err != nil {
+		return nil, mods, err
+	}
+
+	log.Debugf("read %s from %s", envVars, filePath)
+
+	return envVars, mods, nil
+}
+
+// ReadAbraShEnvVars reads env vars from an abra.sh recipe file.
+func ReadAbraShEnvVars(abraSh string) (map[string]string, error) {
+	envVars := make(map[string]string)
+
+	file, err := os.Open(abraSh)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return envVars, nil
+		}
+		return envVars, err
+	}
+	defer file.Close()
+
+	exportRegex, err := regexp.Compile(`^export\s+(\w+=\w+)`)
+	if err != nil {
+		return envVars, err
+	}
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		txt := scanner.Text()
+		if exportRegex.MatchString(txt) {
+			splitVals := strings.Split(txt, "export ")
+			envVarDef := splitVals[len(splitVals)-1]
+			keyVal := strings.Split(envVarDef, "=")
+			if len(keyVal) != 2 {
+				return envVars, fmt.Errorf("couldn't parse %s", txt)
+			}
+			envVars[keyVal[0]] = keyVal[1]
+		}
+	}
+
+	if len(envVars) > 0 {
+		log.Debugf("read %s from %s", envVars, abraSh)
+	} else {
+		log.Debugf("read 0 env var exports from %s", abraSh)
+	}
+
+	return envVars, nil
+}
+
+type EnvVar struct {
+	Name    string
+	Present bool
+}

pkg/envfile/envfile_test.go

@@ -1,69 +1,30 @@
-package config_test
+package envfile_test
 
 import (
-	"fmt"
-	"os"
-	"path"
 	"reflect"
 	"slices"
 	"strings"
 	"testing"
 
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/envfile"
 	"coopcloud.tech/abra/pkg/recipe"
+	testPkg "coopcloud.tech/abra/pkg/test"
 )
 
-var (
-	TestFolder    = os.ExpandEnv("$PWD/../../tests/resources/test_folder")
-	ValidAbraConf = os.ExpandEnv("$PWD/../../tests/resources/valid_abra_config")
-)
-
-// make sure these are in alphabetical order
-var (
-	TFolders = []string{"folder1", "folder2"}
-	TFiles   = []string{"bar.env", "foo.env"}
-)
-
-var (
-	AppName    = "ecloud"
-	ServerName = "evil.corp"
-)
-
-var ExpectedAppEnv = config.AppEnv{
-	"DOMAIN": "ecloud.evil.corp",
-	"RECIPE": "ecloud",
-}
-
-var ExpectedApp = config.App{
-	Name:   AppName,
-	Recipe: ExpectedAppEnv["RECIPE"],
-	Domain: ExpectedAppEnv["DOMAIN"],
-	Env:    ExpectedAppEnv,
-	Path:   ExpectedAppFile.Path,
-	Server: ExpectedAppFile.Server,
-}
-
-var ExpectedAppFile = config.AppFile{
-	Path:   path.Join(ValidAbraConf, "servers", ServerName, AppName+".env"),
-	Server: ServerName,
-}
-
-var ExpectedAppFiles = map[string]config.AppFile{
-	AppName: ExpectedAppFile,
-}
-
 func TestGetAllFoldersInDirectory(t *testing.T) {
-	folders, err := config.GetAllFoldersInDirectory(TestFolder)
+	folders, err := config.GetAllFoldersInDirectory(testPkg.TestFolder)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(folders, TFolders) {
+	if !reflect.DeepEqual(folders, testPkg.TFolders) {
-		t.Fatalf("did not get expected folders. Expected: (%s), Got: (%s)", strings.Join(TFolders, ","), strings.Join(folders, ","))
+		t.Fatalf("did not get expected folders. Expected: (%s), Got: (%s)", strings.Join(testPkg.TFolders, ","), strings.Join(folders, ","))
 	}
 }
 
 func TestGetAllFilesInDirectory(t *testing.T) {
-	files, err := config.GetAllFilesInDirectory(TestFolder)
+	files, err := config.GetAllFilesInDirectory(testPkg.TestFolder)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -71,21 +32,21 @@ func TestGetAllFilesInDirectory(t *testing.T) {
 	for _, file := range files {
 		fileNames = append(fileNames, file.Name())
 	}
-	if !reflect.DeepEqual(fileNames, TFiles) {
+	if !reflect.DeepEqual(fileNames, testPkg.TFiles) {
-		t.Fatalf("did not get expected files. Expected: (%s), Got: (%s)", strings.Join(TFiles, ","), strings.Join(fileNames, ","))
+		t.Fatalf("did not get expected files. Expected: (%s), Got: (%s)", strings.Join(testPkg.TFiles, ","), strings.Join(fileNames, ","))
 	}
 }
 
 func TestReadEnv(t *testing.T) {
-	env, err := config.ReadEnv(ExpectedAppFile.Path)
+	env, err := envfile.ReadEnv(testPkg.ExpectedAppFile.Path)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(env, ExpectedAppEnv) {
+	if !reflect.DeepEqual(env, testPkg.ExpectedAppEnv) {
 		t.Fatalf(
 			"did not get expected application settings. Expected: DOMAIN=%s RECIPE=%s; Got: DOMAIN=%s RECIPE=%s",
-			ExpectedAppEnv["DOMAIN"],
+			testPkg.ExpectedAppEnv["DOMAIN"],
-			ExpectedAppEnv["RECIPE"],
+			testPkg.ExpectedAppEnv["RECIPE"],
 			env["DOMAIN"],
 			env["RECIPE"],
 		)
@@ -93,14 +54,13 @@ func TestReadEnv(t *testing.T) {
 }
 
 func TestReadAbraShEnvVars(t *testing.T) {
-	offline := true
+	r := recipe.Get("abra-test-recipe")
-	r, err := recipe.Get("abra-test-recipe", offline)
+	err := r.EnsureExists()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, r.Name, "abra.sh")
+	abraShEnv, err := envfile.ReadAbraShEnvVars(r.AbraShPath)
-	abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -123,14 +83,13 @@ func TestReadAbraShEnvVars(t *testing.T) {
 }
 
 func TestReadAbraShCmdNames(t *testing.T) {
-	offline := true
+	r := recipe.Get("abra-test-recipe")
-	r, err := recipe.Get("abra-test-recipe", offline)
+	err := r.EnsureExists()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, r.Name, "abra.sh")
+	cmdNames, err := appPkg.ReadAbraShCmdNames(r.AbraShPath)
-	cmdNames, err := config.ReadAbraShCmdNames(abraShPath)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -142,34 +101,33 @@ func TestReadAbraShCmdNames(t *testing.T) {
 	expectedCmdNames := []string{"test_cmd", "test_cmd_args"}
 	for _, cmdName := range expectedCmdNames {
 		if !slices.Contains(cmdNames, cmdName) {
-			t.Fatalf("%s should have been found in %s", cmdName, abraShPath)
+			t.Fatalf("%s should have been found in %s", cmdName, r.AbraShPath)
 		}
 	}
 }
 
 func TestCheckEnv(t *testing.T) {
-	offline := true
+	r := recipe.Get("abra-test-recipe")
-	r, err := recipe.Get("abra-test-recipe", offline)
+	err := r.EnsureExists()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	envSamplePath := path.Join(config.RECIPES_DIR, r.Name, ".env.sample")
+	envSample, err := r.SampleEnv()
-	envSample, err := config.ReadEnv(envSamplePath)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	app := config.App{
+	app := appPkg.App{
 		Name:   "test-app",
-		Recipe: r.Name,
+		Recipe: recipe.Get(r.Name),
 		Domain: "example.com",
 		Env:    envSample,
 		Path:   "example.com.env",
 		Server: "example.com",
 	}
 
-	envVars, err := config.CheckEnv(app)
+	envVars, err := appPkg.CheckEnv(app)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -182,30 +140,29 @@ func TestCheckEnv(t *testing.T) {
 }
 
 func TestCheckEnvError(t *testing.T) {
-	offline := true
+	r := recipe.Get("abra-test-recipe")
-	r, err := recipe.Get("abra-test-recipe", offline)
+	err := r.EnsureExists()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	envSamplePath := path.Join(config.RECIPES_DIR, r.Name, ".env.sample")
+	envSample, err := r.SampleEnv()
-	envSample, err := config.ReadEnv(envSamplePath)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	delete(envSample, "DOMAIN")
 
-	app := config.App{
+	app := appPkg.App{
 		Name:   "test-app",
-		Recipe: r.Name,
+		Recipe: recipe.Get(r.Name),
 		Domain: "example.com",
 		Env:    envSample,
 		Path:   "example.com.env",
 		Server: "example.com",
 	}
 
-	envVars, err := config.CheckEnv(app)
+	envVars, err := appPkg.CheckEnv(app)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -218,14 +175,13 @@ func TestCheckEnvError(t *testing.T) {
 }
 
 func TestEnvVarCommentsRemoved(t *testing.T) {
-	offline := true
+	r := recipe.Get("abra-test-recipe")
-	r, err := recipe.Get("abra-test-recipe", offline)
+	err := r.EnsureExists()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	envSamplePath := path.Join(config.RECIPES_DIR, r.Name, ".env.sample")
+	envSample, err := r.SampleEnv()
-	envSample, err := config.ReadEnv(envSamplePath)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -250,14 +206,13 @@ func TestEnvVarCommentsRemoved(t *testing.T) {
 }
 
 func TestEnvVarModifiersIncluded(t *testing.T) {
-	offline := true
+	r := recipe.Get("abra-test-recipe")
-	r, err := recipe.Get("abra-test-recipe", offline)
+	err := r.EnsureExists()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	envSamplePath := path.Join(config.RECIPES_DIR, r.Name, ".env.sample")
+	envSample, modifiers, err := envfile.ReadEnvWithModifiers(r.SampleEnvPath)
-	envSample, modifiers, err := config.ReadEnvWithModifiers(envSamplePath)
 	if err != nil {
 		t.Fatal(err)
 	}

pkg/formatter/formatter.go

@@ -9,8 +9,8 @@ import (
 	"github.com/docker/go-units"
 	// "github.com/olekukonko/tablewriter"
 	"coopcloud.tech/abra/pkg/jsontable"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/schollz/progressbar/v3"
-	"github.com/sirupsen/logrus"
 )
 
 func ShortenID(str string) string {
@@ -66,7 +66,7 @@ func StripTagMeta(image string) string {
 	}
 
 	if originalImage != image {
-		logrus.Debugf("stripped %s to %s for parsing", originalImage, image)
+		log.Debugf("stripped %s to %s for parsing", originalImage, image)
 	}
 
 	return image

pkg/git/add.go

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

pkg/git/branch.go

@@ -3,9 +3,9 @@ package git
 import (
 	"fmt"
 
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/sirupsen/logrus"
 )
 
 // Check if a branch exists in a repo. Use this and not repository.Branch(),
@@ -90,11 +90,11 @@ func CheckoutDefaultBranch(repo *git.Repository, repoPath string) (plumbing.Refe
 	}
 
 	if err := worktree.Checkout(checkOutOpts); err != nil {
-		logrus.Debugf("failed to check out %s in %s", branch, repoPath)
+		log.Debugf("failed to check out %s in %s", branch, repoPath)
 		return branch, err
 	}
 
-	logrus.Debugf("successfully checked out %v in %s", branch, repoPath)
+	log.Debugf("successfully checked out %v in %s", branch, repoPath)
 
 	return branch, nil
 }

pkg/git/clone.go

@@ -6,15 +6,15 @@ import (
 	"path/filepath"
 	"strings"
 
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/sirupsen/logrus"
 )
 
 // 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) {
-		logrus.Debugf("%s does not exist, attempting to git clone from %s", dir, url)
+		log.Debugf("%s does not exist, attempting to git clone from %s", dir, url)
 
 		_, err := git.PlainClone(dir, false, &git.CloneOptions{
 			URL:           url,
@@ -23,7 +23,7 @@ func Clone(dir, url string) error {
 			SingleBranch:  true,
 		})
 		if err != nil {
-			logrus.Debugf("cloning %s default branch failed, attempting from main branch", url)
+			log.Debugf("cloning %s default branch failed, attempting from main branch", url)
 
 			_, err := git.PlainClone(dir, false, &git.CloneOptions{
 				URL:           url,
@@ -41,9 +41,9 @@ func Clone(dir, url string) error {
 			}
 		}
 
-		logrus.Debugf("%s has been git cloned successfully", dir)
+		log.Debugf("%s has been git cloned successfully", dir)
 	} else {
-		logrus.Debugf("%s already exists", dir)
+		log.Debugf("%s already exists", dir)
 	}
 
 	return nil

pkg/git/commit.go

@@ -3,8 +3,8 @@ package git
 import (
 	"fmt"
 
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
 )
 
 // Commit runs a git commit
@@ -38,9 +38,9 @@ func Commit(repoPath, commitMessage string, dryRun bool) error {
 		if err != nil {
 			return err
 		}
-		logrus.Debug("git changes commited")
+		log.Debug("git changes commited")
 	} else {
-		logrus.Debug("dry run: no changes commited")
+		log.Debug("dry run: no changes commited")
 	}
 
 	return nil

pkg/git/diff.go

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

pkg/git/init.go

@@ -1,37 +1,43 @@
 package git
 
 import (
+	"fmt"
+
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
-	gitPkg "github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing/object"
-	"github.com/sirupsen/logrus"
 )
 
 // Init inits a new repo and commits all the stuff if you want
-func Init(repoPath string, commit bool) error {
+func Init(repoPath string, commit bool, gitName, gitEmail string) error {
-	if _, err := gitPkg.PlainInit(repoPath, false); err != nil {
+	if _, err := git.PlainInit(repoPath, false); err != nil {
-		logrus.Fatal(err)
+		return fmt.Errorf("git init: %s", err)
 	}
-	logrus.Debugf("initialised new git repo in %s", repoPath)
+	log.Debugf("initialised new git repo in %s", repoPath)
 
 	if commit {
 		commitRepo, err := git.PlainOpen(repoPath)
 		if err != nil {
-			logrus.Fatal(err)
+			return fmt.Errorf("git open: %s", err)
 		}
 
 		commitWorktree, err := commitRepo.Worktree()
 		if err != nil {
-			logrus.Fatal(err)
+			return fmt.Errorf("git worktree: %s", err)
 		}
 
 		if err := commitWorktree.AddWithOptions(&git.AddOptions{All: true}); err != nil {
-			return err
+			return fmt.Errorf("git add: %s", err)
 		}
 
-		if _, err = commitWorktree.Commit("init", &git.CommitOptions{}); err != nil {
+		var author *object.Signature
-			return err
+		if gitName != "" && gitEmail != "" {
+			author = &object.Signature{Name: gitName, Email: gitEmail}
 		}
-		logrus.Debugf("init committed all files for new git repo in %s", repoPath)
+		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

pkg/git/push.go

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

pkg/git/read.go

@@ -9,11 +9,11 @@ import (
 	"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"
-	"github.com/sirupsen/logrus"
 )
 
 // GetRecipeHead retrieves latest HEAD metadata.
@@ -60,9 +60,9 @@ func IsClean(repoPath string) (bool, error) {
 	}
 
 	if status.String() != "" {
-		logrus.Debugf("discovered git status in %s: %s", repoPath, status.String())
+		log.Debugf("discovered git status in %s: %s", repoPath, status.String())
 	} else {
-		logrus.Debugf("discovered clean git status in %s", repoPath)
+		log.Debugf("discovered clean git status in %s", repoPath)
 	}
 
 	return status.IsClean(), nil
@@ -98,7 +98,7 @@ func parseGitConfig() (*gitConfigPkg.Config, error) {
 	globalGitConfig := filepath.Join(usr.HomeDir, ".gitconfig")
 	if _, err := os.Stat(globalGitConfig); err != nil {
 		if os.IsNotExist(err) {
-			logrus.Debugf("no %s exists, not reading any global gitignore config", globalGitConfig)
+			log.Debugf("no %s exists, not reading any global gitignore config", globalGitConfig)
 			return cfg, nil
 		}
 		return cfg, err
@@ -140,7 +140,7 @@ func parseExcludesFile(excludesfile string) ([]gitignore.Pattern, error) {
 
 	if _, err := os.Stat(excludesfile); err != nil {
 		if os.IsNotExist(err) {
-			logrus.Debugf("no %s exists, skipping reading gitignore paths", excludesfile)
+			log.Debugf("no %s exists, skipping reading gitignore paths", excludesfile)
 			return ps, nil
 		}
 		return ps, err
@@ -159,7 +159,7 @@ func parseExcludesFile(excludesfile string) ([]gitignore.Pattern, error) {
 		}
 	}
 
-	logrus.Debugf("read global ignore paths: %s", strings.Join(pathsRaw, " "))
+	log.Debugf("read global ignore paths: %s", strings.Join(pathsRaw, " "))
 
 	return ps, nil
 }

pkg/git/remote.go

@@ -3,15 +3,15 @@ package git
 import (
 	"strings"
 
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/config"
-	"github.com/sirupsen/logrus"
 )
 
 // CreateRemote creates a new git remote in a repository
 func CreateRemote(repo *git.Repository, name, url string, dryRun bool) error {
 	if dryRun {
-		logrus.Debugf("dry run: remote %s (%s) not created", name, url)
+		log.Debugf("dry run: remote %s (%s) not created", name, url)
 		return nil
 	}
 

pkg/lint/recipe.go

@@ -6,14 +6,13 @@ import (
 	"os"
 	"path"
 
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/recipe"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/tagcmp"
 	"github.com/distribution/reference"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/sirupsen/logrus"
 )
 
 var Warn = "warn"
@@ -46,10 +45,10 @@ func (l LintRule) Skip(recipe recipe.Recipe) bool {
 	if l.SkipCondition != nil {
 		ok, err := l.SkipCondition(recipe)
 		if err != nil {
-			logrus.Debugf("%s: skip condition: %s", l.Ref, err)
+			log.Debugf("%s: skip condition: %s", l.Ref, err)
 		}
 		if ok {
-			logrus.Debugf("skipping %s based on skip condition", l.Ref)
+			log.Debugf("skipping %s based on skip condition", l.Ref)
 			return true
 		}
 	}
@@ -174,7 +173,7 @@ var LintRules = map[string][]LintRule{
 // used in code paths such as "app deploy" to avoid nasty surprises but not for
 // the typical linting commands, which do handle other levels.
 func LintForErrors(recipe recipe.Recipe) error {
-	logrus.Debugf("linting for critical errors in %s configs", recipe.Name)
+	log.Debugf("linting for critical errors in %s configs", recipe.Name)
 
 	for level := range LintRules {
 		if level != "error" {
@@ -196,22 +195,25 @@ func LintForErrors(recipe recipe.Recipe) error {
 		}
 	}
 
-	logrus.Debugf("linting successful, %s is well configured", recipe.Name)
+	log.Debugf("linting successful, %s is well configured", recipe.Name)
 
 	return nil
 }
 
 func LintComposeVersion(recipe recipe.Recipe) (bool, error) {
-	if recipe.Config.Version == "3.8" {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	if config.Version == "3.8" {
 		return true, nil
 	}
 
 	return true, nil
 }
 
-func LintEnvConfigPresent(recipe recipe.Recipe) (bool, error) {
+func LintEnvConfigPresent(r recipe.Recipe) (bool, error) {
-	envSample := fmt.Sprintf("%s/%s/.env.sample", config.RECIPES_DIR, recipe.Name)
+	if _, err := os.Stat(r.SampleEnvPath); !os.IsNotExist(err) {
-	if _, err := os.Stat(envSample); !os.IsNotExist(err) {
 		return true, nil
 	}
 
@@ -219,7 +221,11 @@ func LintEnvConfigPresent(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintAppService(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	for _, service := range config.Services {
 		if service.Name == "app" {
 			return true, nil
 		}
@@ -232,11 +238,10 @@ func LintAppService(recipe recipe.Recipe) (bool, error) {
 // confirms that there is no "DOMAIN=..." in the .env.sample configuration of
 // the recipe. This typically means that no domain is required to deploy and
 // therefore no matching traefik deploy label will be present.
-func LintTraefikEnabledSkipCondition(recipe recipe.Recipe) (bool, error) {
+func LintTraefikEnabledSkipCondition(r recipe.Recipe) (bool, error) {
-	envSamplePath := path.Join(config.RECIPES_DIR, recipe.Name, ".env.sample")
+	sampleEnv, err := r.SampleEnv()
-	sampleEnv, err := config.ReadEnv(envSamplePath)
 	if err != nil {
-		return false, fmt.Errorf("Unable to discover .env.sample for %s", recipe.Name)
+		return false, fmt.Errorf("Unable to discover .env.sample for %s", r.Name)
 	}
 
 	if _, ok := sampleEnv["DOMAIN"]; !ok {
@@ -247,7 +252,11 @@ func LintTraefikEnabledSkipCondition(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintTraefikEnabled(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	for _, service := range config.Services {
 		for label := range service.Deploy.Labels {
 			if label == "traefik.enable" {
 				if service.Deploy.Labels[label] == "true" {
@@ -261,7 +270,11 @@ func LintTraefikEnabled(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintHealthchecks(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	for _, service := range config.Services {
 		if service.HealthCheck == nil {
 			return false, nil
 		}
@@ -271,7 +284,11 @@ func LintHealthchecks(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintAllImagesTagged(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	for _, service := range config.Services {
 		img, err := reference.ParseNormalizedNamed(service.Image)
 		if err != nil {
 			return false, err
@@ -285,7 +302,11 @@ func LintAllImagesTagged(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintNoUnstableTags(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	for _, service := range config.Services {
 		img, err := reference.ParseNormalizedNamed(service.Image)
 		if err != nil {
 			return false, err
@@ -308,7 +329,11 @@ func LintNoUnstableTags(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintSemverLikeTags(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	for _, service := range config.Services {
 		img, err := reference.ParseNormalizedNamed(service.Image)
 		if err != nil {
 			return false, err
@@ -331,7 +356,11 @@ func LintSemverLikeTags(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintImagePresent(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	for _, service := range config.Services {
 		if service.Image == "" {
 			return false, nil
 		}
@@ -342,12 +371,12 @@ func LintImagePresent(recipe recipe.Recipe) (bool, error) {
 func LintHasPublishedVersion(recipe recipe.Recipe) (bool, error) {
 	catl, err := recipePkg.ReadRecipeCatalogue(false)
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	versions, err := recipePkg.GetRecipeCatalogueVersions(recipe.Name, catl)
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	if len(versions) == 0 {
@@ -358,7 +387,7 @@ func LintHasPublishedVersion(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintMetadataFilledIn(r recipe.Recipe) (bool, error) {
-	features, category, err := recipe.GetRecipeFeaturesAndCategory(r.Name)
+	features, category, err := recipe.GetRecipeFeaturesAndCategory(r)
 	if err != nil {
 		return false, err
 	}
@@ -379,9 +408,13 @@ func LintMetadataFilledIn(r recipe.Recipe) (bool, error) {
 }
 
 func LintAbraShVendors(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	for _, service := range config.Services {
 		if len(service.Configs) > 0 {
-			abraSh := path.Join(config.RECIPES_DIR, recipe.Name, "abra.sh")
+			abraSh := path.Join(recipe.Dir, "abra.sh")
 			if _, err := os.Stat(abraSh); err != nil {
 				if os.IsNotExist(err) {
 					return false, err
@@ -394,9 +427,7 @@ func LintAbraShVendors(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintHasRecipeRepo(recipe recipe.Recipe) (bool, error) {
-	url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, recipe.Name)
+	res, err := http.Get(recipe.GitURL)
-
-	res, err := http.Get(url)
 	if err != nil {
 		return false, err
 	}
@@ -409,7 +440,11 @@ func LintHasRecipeRepo(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintSecretLengths(recipe recipe.Recipe) (bool, error) {
-	for name := range recipe.Config.Secrets {
+	config, err := recipe.GetComposeConfig(nil)
+	if err != nil {
+		return false, err
+	}
+	for name := range config.Secrets {
 		if len(name) > 12 {
 			return false, fmt.Errorf("secret %s is longer than 12 characters", name)
 		}
@@ -419,16 +454,14 @@ func LintSecretLengths(recipe recipe.Recipe) (bool, error) {
 }
 
 func LintValidTags(recipe recipe.Recipe) (bool, error) {
-	recipeDir := path.Join(config.RECIPES_DIR, recipe.Name)
+	repo, err := git.PlainOpen(recipe.Dir)
-
-	repo, err := git.PlainOpen(recipeDir)
 	if err != nil {
-		return false, fmt.Errorf("unable to open %s: %s", recipeDir, err)
+		return false, fmt.Errorf("unable to open %s: %s", recipe.Dir, err)
 	}
 
 	iter, err := repo.Tags()
 	if err != nil {
-		logrus.Fatalf("unable to list local tags for %s", recipe.Name)
+		log.Fatalf("unable to list local tags for %s", recipe.Name)
 	}
 
 	if err := iter.ForEach(func(ref *plumbing.Reference) error {

pkg/log/log.go

@@ -0,0 +1,34 @@
+// Package log defines the core logging functionality for Abra.
+package log
+
+import (
+	"os"
+
+	charmLog "github.com/charmbracelet/log"
+)
+
+// Logger is the central logging interface.
+var Logger = charmLog.NewWithOptions(os.Stdout, charmLog.Options{
+	ReportCaller:    false,
+	ReportTimestamp: false,
+})
+
+var Fatal = Logger.Fatal
+var Fatalf = Logger.Fatalf
+
+var Debug = Logger.Debug
+var Debugf = Logger.Debugf
+
+var Info = Logger.Info
+var Infof = Logger.Infof
+
+var Warn = Logger.Warn
+var Warnf = Logger.Warnf
+
+var Error = Logger.Error
+var Errorf = Logger.Errorf
+
+var SetLevel = Logger.SetLevel
+var DebugLevel = charmLog.DebugLevel
+var SetOutput = charmLog.SetOutput
+var SetReportCaller = charmLog.SetReportCaller

pkg/recipe/compose.go

@@ -0,0 +1,252 @@
+package recipe
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/upstream/stack"
+	loader "coopcloud.tech/abra/pkg/upstream/stack"
+	"github.com/distribution/reference"
+	composetypes "github.com/docker/cli/cli/compose/types"
+)
+
+// GetComposeFiles gets the list of compose files for an app (or recipe if you
+// don't already have an app) which should be merged into a composetypes.Config
+// while respecting the COMPOSE_FILE env var.
+func (r Recipe) GetComposeFiles(appEnv map[string]string) ([]string, error) {
+	composeFileEnvVar, ok := appEnv["COMPOSE_FILE"]
+	if !ok {
+		if err := ensurePathExists(r.ComposePath); err != nil {
+			return []string{}, err
+		}
+		log.Debugf("no COMPOSE_FILE detected, loading default: %s", r.ComposePath)
+		return []string{r.ComposePath}, nil
+	}
+
+	if !strings.Contains(composeFileEnvVar, ":") {
+		path := fmt.Sprintf("%s/%s", r.Dir, composeFileEnvVar)
+		if err := ensurePathExists(path); err != nil {
+			return []string{}, err
+		}
+		log.Debugf("COMPOSE_FILE detected, loading %s", path)
+		return []string{path}, nil
+	}
+
+	var composeFiles []string
+
+	numComposeFiles := strings.Count(composeFileEnvVar, ":") + 1
+	envVars := strings.SplitN(composeFileEnvVar, ":", numComposeFiles)
+	if len(envVars) != numComposeFiles {
+		return composeFiles, fmt.Errorf("COMPOSE_FILE (=\"%s\") parsing failed?", composeFileEnvVar)
+	}
+
+	for _, file := range envVars {
+		path := fmt.Sprintf("%s/%s", r.Dir, file)
+		if err := ensurePathExists(path); err != nil {
+			return composeFiles, err
+		}
+		composeFiles = append(composeFiles, path)
+	}
+
+	log.Debugf("COMPOSE_FILE detected (%s), loading %s", composeFileEnvVar, strings.Join(envVars, ", "))
+	log.Debugf("retrieved %s configs for %s", strings.Join(composeFiles, ", "), r.Name)
+
+	return composeFiles, nil
+}
+
+func (r Recipe) GetComposeConfig(env map[string]string) (*composetypes.Config, error) {
+	pattern := fmt.Sprintf("%s/compose**yml", r.Dir)
+	composeFiles, err := filepath.Glob(pattern)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(composeFiles) == 0 {
+		return nil, fmt.Errorf("%s is missing a compose.yml or compose.*.yml file?", r.Name)
+	}
+
+	if env == nil {
+		env, err = r.SampleEnv()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	opts := stack.Deploy{Composefiles: composeFiles}
+	config, err := loader.LoadComposefile(opts, env)
+	if err != nil {
+		return nil, err
+	}
+	return config, nil
+}
+
+// GetVersionLabelLocal retrieves the version label on the local recipe config
+func (r Recipe) GetVersionLabelLocal() (string, error) {
+	var label string
+	config, err := r.GetComposeConfig(nil)
+	if err != nil {
+		return "", err
+	}
+
+	for _, service := range config.Services {
+		for label, value := range service.Deploy.Labels {
+			if strings.HasPrefix(label, "coop-cloud") && strings.Contains(label, "version") {
+				return value, nil
+			}
+		}
+	}
+
+	if label == "" {
+		return label, fmt.Errorf("%s has no version label? try running \"abra recipe sync %s\" first?", r.Name, r.Name)
+	}
+
+	return label, nil
+}
+
+// UpdateTag updates an image tag in-place on file system local compose files.
+func (r Recipe) UpdateTag(image, tag string) (bool, error) {
+	fullPattern := fmt.Sprintf("%s/compose**yml", r.Dir)
+	image = formatter.StripTagMeta(image)
+
+	composeFiles, err := filepath.Glob(fullPattern)
+	if err != nil {
+		return false, err
+	}
+
+	log.Debugf("considering %s config(s) for tag update", strings.Join(composeFiles, ", "))
+
+	for _, composeFile := range composeFiles {
+		opts := stack.Deploy{Composefiles: []string{composeFile}}
+
+		sampleEnv, err := r.SampleEnv()
+		if err != nil {
+			return false, err
+		}
+
+		compose, err := loader.LoadComposefile(opts, sampleEnv)
+		if err != nil {
+			return false, err
+		}
+
+		for _, service := range compose.Services {
+			if service.Image == "" {
+				continue // may be a compose.$optional.yml file
+			}
+
+			img, _ := reference.ParseNormalizedNamed(service.Image)
+			if err != nil {
+				return false, err
+			}
+
+			var composeTag string
+			switch img.(type) {
+			case reference.NamedTagged:
+				composeTag = img.(reference.NamedTagged).Tag()
+			default:
+				log.Debugf("unable to parse %s, skipping", img)
+				continue
+			}
+
+			composeImage := formatter.StripTagMeta(reference.Path(img))
+
+			log.Debugf("parsed %s from %s", composeTag, service.Image)
+
+			if image == composeImage {
+				bytes, err := ioutil.ReadFile(composeFile)
+				if err != nil {
+					return false, err
+				}
+
+				old := fmt.Sprintf("%s:%s", composeImage, composeTag)
+				new := fmt.Sprintf("%s:%s", composeImage, tag)
+				replacedBytes := strings.Replace(string(bytes), old, new, -1)
+
+				log.Debugf("updating %s to %s in %s", old, new, compose.Filename)
+
+				if err := os.WriteFile(compose.Filename, []byte(replacedBytes), 0o764); err != nil {
+					return false, err
+				}
+			}
+		}
+	}
+
+	return false, nil
+}
+
+// UpdateLabel updates a label in-place on file system local compose files.
+func (r Recipe) UpdateLabel(pattern, serviceName, label string) error {
+	fullPattern := fmt.Sprintf("%s/%s", r.Dir, pattern)
+	composeFiles, err := filepath.Glob(fullPattern)
+	if err != nil {
+		return err
+	}
+
+	log.Debugf("considering %s config(s) for label update", strings.Join(composeFiles, ", "))
+
+	for _, composeFile := range composeFiles {
+		opts := stack.Deploy{Composefiles: []string{composeFile}}
+
+		sampleEnv, err := r.SampleEnv()
+		if err != nil {
+			return err
+		}
+
+		compose, err := loader.LoadComposefile(opts, sampleEnv)
+		if err != nil {
+			return err
+		}
+
+		serviceExists := false
+		var service composetypes.ServiceConfig
+		for _, s := range compose.Services {
+			if s.Name == serviceName {
+				service = s
+				serviceExists = true
+			}
+		}
+
+		if !serviceExists {
+			continue
+		}
+
+		discovered := false
+		for oldLabel, value := range service.Deploy.Labels {
+			if strings.HasPrefix(oldLabel, "coop-cloud") && strings.Contains(oldLabel, "version") {
+				discovered = true
+
+				bytes, err := ioutil.ReadFile(composeFile)
+				if err != nil {
+					return err
+				}
+
+				old := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", value)
+				replacedBytes := strings.Replace(string(bytes), old, label, -1)
+
+				if old == label {
+					log.Warnf("%s is already set, nothing to do?", label)
+					return nil
+				}
+
+				log.Debugf("updating %s to %s in %s", old, label, compose.Filename)
+
+				if err := ioutil.WriteFile(compose.Filename, []byte(replacedBytes), 0o764); err != nil {
+					return err
+				}
+
+				log.Infof("synced label %s to service %s", label, serviceName)
+			}
+		}
+
+		if !discovered {
+			log.Warn("no existing label found, automagic insertion not supported yet")
+			log.Fatalf("add '- \"%s\"' manually to the 'app' service in %s", label, composeFile)
+		}
+	}
+
+	return nil
+}

pkg/recipe/files.go

@@ -0,0 +1,37 @@
+package recipe
+
+import (
+	"fmt"
+	"os"
+	"path"
+
+	"coopcloud.tech/abra/pkg/envfile"
+)
+
+func (r Recipe) SampleEnv() (map[string]string, error) {
+	sampleEnv, err := envfile.ReadEnv(r.SampleEnvPath)
+	if err != nil {
+		return sampleEnv, fmt.Errorf("unable to discover .env.sample for %s", r.Name)
+	}
+	return sampleEnv, nil
+}
+
+// GetReleaseNotes prints release notes for the recipe version
+func (r Recipe) GetReleaseNotes(version string) (string, error) {
+	if version == "" {
+		return "", nil
+	}
+
+	fpath := path.Join(r.Dir, "release", version)
+
+	if _, err := os.Stat(fpath); !os.IsNotExist(err) {
+		releaseNotes, err := os.ReadFile(fpath)
+		if err != nil {
+			return "", err
+		}
+		withTitle := fmt.Sprintf("%s release notes:\n%s", version, string(releaseNotes))
+		return withTitle, nil
+	}
+
+	return "", nil
+}

pkg/recipe/git.go

@@ -0,0 +1,388 @@
+package recipe
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"strings"
+
+	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/formatter"
+	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/log"
+	"github.com/distribution/reference"
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
+)
+
+// 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 chaos {
+		return nil
+	}
+
+	if err := r.EnsureIsClean(); err != nil {
+		return err
+	}
+	if !offline {
+		if err := r.EnsureUpToDate(); err != nil {
+			log.Fatal(err)
+		}
+	}
+	if r.Version != "" {
+		if _, err := r.EnsureVersion(r.Version); err != nil {
+			return err
+		}
+	} 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
+		}
+	}
+
+	if err := gitPkg.EnsureGitRepo(r.Dir); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// EnsureVersion checks whether a specific version exists for a recipe.
+func (r Recipe) EnsureVersion(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 parsedTags []string
+	var tagRef plumbing.ReferenceName
+	if err := tags.ForEach(func(ref *plumbing.Reference) (err error) {
+		parsedTags = append(parsedTags, ref.Name().Short())
+		if ref.Name().Short() == version {
+			tagRef = ref.Name()
+		}
+		return nil
+	}); err != nil {
+		return isChaosCommit, err
+	}
+
+	joinedTags := strings.Join(parsedTags, ", ")
+	if joinedTags != "" {
+		log.Debugf("read %s as tags for recipe %s", joinedTags, r.Name)
+	}
+
+	var opts *git.CheckoutOptions
+	if tagRef.String() == "" {
+		log.Debugf("attempting to checkout '%s' as chaos commit", version)
+
+		hash, err := repo.ResolveRevision(plumbing.Revision(version))
+		if err != nil {
+			log.Fatalf("unable to resolve '%s': %s", version, err)
+		}
+
+		opts = &git.CheckoutOptions{Hash: *hash, Create: false, Force: true}
+		isChaosCommit = true
+	} else {
+		opts = &git.CheckoutOptions{Branch: tagRef, Create: false, Force: true}
+	}
+
+	worktree, err := repo.Worktree()
+	if err != nil {
+		return isChaosCommit, nil
+	}
+
+	if err := worktree.Checkout(opts); err != nil {
+		return isChaosCommit, nil
+	}
+
+	log.Debugf("successfully checked %s out to %s in %s", r.Name, tagRef.Short(), r.Dir)
+
+	return isChaosCommit, nil
+}
+
+// EnsureIsClean makes sure that the recipe repository has no unstaged changes.
+func (r Recipe) EnsureIsClean() error {
+	isClean, err := gitPkg.IsClean(r.Dir)
+	if err != nil {
+		return fmt.Errorf("unable to check git clean status in %s: %s", r.Dir, err)
+	}
+
+	if !isClean {
+		msg := "%s (%s) has locally unstaged changes? please commit/remove your changes before proceeding"
+		return fmt.Errorf(msg, r.Name, r.Dir)
+	}
+
+	return nil
+}
+
+// EnsureLatest makes sure the latest commit is checked out for the local recipe repository
+func (r Recipe) EnsureLatest() error {
+	recipeDir := path.Join(config.RECIPES_DIR, r.Name)
+
+	if err := gitPkg.EnsureGitRepo(recipeDir); err != nil {
+		return err
+	}
+
+	repo, err := git.PlainOpen(recipeDir)
+	if err != nil {
+		return err
+	}
+
+	worktree, err := repo.Worktree()
+	if err != nil {
+		return err
+	}
+
+	branch, err := gitPkg.GetDefaultBranch(repo, recipeDir)
+	if err != nil {
+		return err
+	}
+
+	checkOutOpts := &git.CheckoutOptions{
+		Create: false,
+		Force:  true,
+		Branch: plumbing.ReferenceName(branch),
+	}
+
+	if err := worktree.Checkout(checkOutOpts); err != nil {
+		log.Debugf("failed to check out %s in %s", branch, recipeDir)
+		return err
+	}
+
+	return nil
+}
+
+// EnsureUpToDate ensures that the local repo is synced to the remote
+func (r Recipe) EnsureUpToDate() error {
+	recipeDir := path.Join(config.RECIPES_DIR, r.Name)
+
+	repo, err := git.PlainOpen(recipeDir)
+	if err != nil {
+		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", recipeDir, err)
+	}
+
+	if len(remotes) == 0 {
+		log.Debugf("cannot ensure %s is up-to-date, no git remotes configured", r.Name)
+		return nil
+	}
+
+	worktree, err := repo.Worktree()
+	if err != nil {
+		return fmt.Errorf("unable to open git work tree in %s: %s", recipeDir, err)
+	}
+
+	branch, err := gitPkg.CheckoutDefaultBranch(repo, recipeDir)
+	if err != nil {
+		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", recipeDir, err)
+		}
+	}
+
+	opts := &git.PullOptions{
+		Force:         true,
+		ReferenceName: branch,
+		SingleBranch:  true,
+	}
+
+	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", recipeDir, err)
+		}
+	}
+
+	log.Debugf("fetched latest git changes for %s", r.Name)
+
+	return nil
+}
+
+// ChaosVersion constructs a chaos mode recipe version.
+func (r Recipe) ChaosVersion() (string, error) {
+	var version string
+
+	head, err := gitPkg.GetRecipeHead(r.Name)
+	if err != nil {
+		return version, err
+	}
+
+	version = formatter.SmallSHA(head.String())
+
+	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
+}
+
+// Push pushes the latest changes to a SSH URL remote. You need to have your
+// local SSH configuration for git.coopcloud.tech working for this to work
+func (r Recipe) Push(dryRun bool) error {
+	repo, err := git.PlainOpen(r.Dir)
+	if err != nil {
+		return err
+	}
+
+	if err := gitPkg.CreateRemote(repo, "origin-ssh", r.SSHURL, dryRun); err != nil {
+		return err
+	}
+
+	if err := gitPkg.Push(r.Dir, "origin-ssh", true, dryRun); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Tags list the recipe tags
+func (r Recipe) Tags() ([]string, error) {
+	var tags []string
+
+	repo, err := git.PlainOpen(r.Dir)
+	if err != nil {
+		return tags, err
+	}
+
+	gitTags, err := repo.Tags()
+	if err != nil {
+		return tags, err
+	}
+
+	if err := gitTags.ForEach(func(ref *plumbing.Reference) (err error) {
+		tags = append(tags, strings.TrimPrefix(string(ref.Name()), "refs/tags/"))
+		return nil
+	}); err != nil {
+		return tags, err
+	}
+
+	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, error) {
+	versions := RecipeVersions{}
+	log.Debugf("attempting to open git repository in %s", r.Dir)
+
+	repo, err := git.PlainOpen(r.Dir)
+	if err != nil {
+		return versions, err
+	}
+
+	worktree, err := repo.Worktree()
+	if err != nil {
+		return versions, err
+	}
+
+	gitTags, err := repo.Tags()
+	if err != nil {
+		return versions, err
+	}
+
+	if err := gitTags.ForEach(func(ref *plumbing.Reference) (err error) {
+		tag := strings.TrimPrefix(string(ref.Name()), "refs/tags/")
+
+		log.Debugf("processing %s for %s", tag, r.Name)
+
+		checkOutOpts := &git.CheckoutOptions{
+			Create: false,
+			Force:  true,
+			Branch: plumbing.ReferenceName(ref.Name()),
+		}
+		if err := worktree.Checkout(checkOutOpts); err != nil {
+			log.Debugf("failed to check out %s in %s", tag, r.Dir)
+			return err
+		}
+
+		log.Debugf("successfully checked out %s in %s", ref.Name(), r.Dir)
+
+		config, err := r.GetComposeConfig(nil)
+		if err != nil {
+			return err
+		}
+
+		versionMeta := make(map[string]ServiceMeta)
+		for _, service := range config.Services {
+
+			img, err := reference.ParseNormalizedNamed(service.Image)
+			if err != nil {
+				return err
+			}
+
+			path := reference.Path(img)
+
+			path = formatter.StripTagMeta(path)
+
+			var tag string
+			switch img.(type) {
+			case reference.NamedTagged:
+				tag = img.(reference.NamedTagged).Tag()
+			case reference.Named:
+				log.Warnf("%s service is missing image tag?", path)
+				continue
+			}
+
+			versionMeta[service.Name] = ServiceMeta{
+				Image: path,
+				Tag:   tag,
+			}
+		}
+
+		versions = append(versions, map[string]map[string]ServiceMeta{tag: versionMeta})
+
+		return nil
+	}); err != nil {
+		return versions, err
+	}
+
+	_, err = gitPkg.CheckoutDefaultBranch(repo, r.Dir)
+	if err != nil {
+		return versions, err
+	}
+
+	sortRecipeVersions(versions)
+
+	log.Debugf("collected %s for %s", versions, r.Dir)
+
+	return versions, nil
+}

pkg/recipe/recipe.go

@@ -4,29 +4,22 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"net/url"
 	"os"
 	"path"
-	"path/filepath"
 	"slices"
 	"sort"
 	"strconv"
 	"strings"
 
 	"coopcloud.tech/abra/pkg/catalogue"
-	"coopcloud.tech/abra/pkg/compose"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/limit"
-	"coopcloud.tech/abra/pkg/upstream/stack"
+	"coopcloud.tech/abra/pkg/log"
-	loader "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/abra/pkg/web"
 	"coopcloud.tech/tagcmp"
-	"github.com/distribution/reference"
-	composetypes "github.com/docker/cli/cli/compose/types"
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/sirupsen/logrus"
 )
 
 // RecipeCatalogueURL is the only current recipe catalogue available.
@@ -80,7 +73,7 @@ func (r RecipeMeta) LatestVersion() string {
 		version = tag
 	}
 
-	logrus.Debugf("choosing %s as latest version of %s", version, r.Name)
+	log.Debugf("choosing %s as latest version of %s", version, r.Name)
 
 	return version
 }
@@ -130,307 +123,62 @@ type Features struct {
 	SSO         string `json:"sso"`
 }
 
-// Recipe represents a recipe.
+func Get(name string) Recipe {
-type Recipe struct {
+	version := ""
-	Name   string
+	if strings.Contains(name, ":") {
-	Config *composetypes.Config
+		split := strings.Split(name, ":")
-	Meta   RecipeMeta
+		name = split[0]
-}
+		version = split[1]
-
-// Push pushes the latest changes to a SSH URL remote. You need to have your
-// local SSH configuration for git.coopcloud.tech working for this to work
-func (r Recipe) Push(dryRun bool) error {
-	repo, err := git.PlainOpen(r.Dir())
-	if err != nil {
-		return err
 	}
 
-	if err := gitPkg.CreateRemote(repo, "origin-ssh", r.Meta.SSHURL, dryRun); err != nil {
+	gitURL := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, name)
-		return err
+	sshURL := fmt.Sprintf(config.SSH_URL_TEMPLATE, name)
-	}
+	if strings.Contains(name, "/") {
-
+		u, err := url.Parse(name)
-	if err := gitPkg.Push(r.Dir(), "origin-ssh", true, dryRun); err != nil {
+		if err != nil {
-		return err
+			log.Fatalf("invalid recipe: %s", err)
-	}
-
-	return nil
-}
-
-// Dir retrieves the recipe repository path
-func (r Recipe) Dir() string {
-	return path.Join(config.RECIPES_DIR, r.Name)
-}
-
-// UpdateLabel updates a recipe label
-func (r Recipe) UpdateLabel(pattern, serviceName, label string) error {
-	fullPattern := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, r.Name, pattern)
-	if err := compose.UpdateLabel(fullPattern, serviceName, label, r.Name); err != nil {
-		return err
-	}
-	return nil
-}
-
-// UpdateTag updates a recipe tag
-func (r Recipe) UpdateTag(image, tag string) (bool, error) {
-	pattern := fmt.Sprintf("%s/%s/compose**yml", config.RECIPES_DIR, r.Name)
-
-	image = formatter.StripTagMeta(image)
-
-	ok, err := compose.UpdateTag(pattern, image, tag, r.Name)
-	if err != nil {
-		return false, err
-	}
-
-	return ok, nil
-}
-
-// Tags list the recipe tags
-func (r Recipe) Tags() ([]string, error) {
-	var tags []string
-
-	repo, err := git.PlainOpen(r.Dir())
-	if err != nil {
-		return tags, err
-	}
-
-	gitTags, err := repo.Tags()
-	if err != nil {
-		return tags, err
-	}
-
-	if err := gitTags.ForEach(func(ref *plumbing.Reference) (err error) {
-		tags = append(tags, strings.TrimPrefix(string(ref.Name()), "refs/tags/"))
-		return nil
-	}); err != nil {
-		return tags, err
-	}
-
-	logrus.Debugf("detected %s as tags for recipe %s", strings.Join(tags, ", "), r.Name)
-
-	return tags, nil
-}
-
-// Get retrieves a recipe.
-func Get(recipeName string, offline bool) (Recipe, error) {
-	if err := EnsureExists(recipeName); err != nil {
-		return Recipe{}, err
-	}
-
-	pattern := fmt.Sprintf("%s/%s/compose**yml", config.RECIPES_DIR, recipeName)
-	composeFiles, err := filepath.Glob(pattern)
-	if err != nil {
-		return Recipe{}, err
-	}
-
-	if len(composeFiles) == 0 {
-		return Recipe{}, fmt.Errorf("%s is missing a compose.yml or compose.*.yml file?", recipeName)
-	}
-
-	envSamplePath := path.Join(config.RECIPES_DIR, recipeName, ".env.sample")
-	sampleEnv, err := config.ReadEnv(envSamplePath)
-	if err != nil {
-		return Recipe{}, err
-	}
-
-	opts := stack.Deploy{Composefiles: composeFiles}
-	config, err := loader.LoadComposefile(opts, sampleEnv)
-	if err != nil {
-		return Recipe{}, err
-	}
-
-	meta, err := GetRecipeMeta(recipeName, offline)
-	if err != nil {
-		switch err.(type) {
-		case RecipeMissingFromCatalogue:
-			meta = RecipeMeta{}
-		default:
-			return Recipe{}, err
 		}
+		u.Scheme = "https"
+		gitURL = u.String() + ".git"
+
+		u.Scheme = "ssh"
+		u.User = url.User("git")
+		sshURL = u.String() + ".git"
 	}
 
+	dir := path.Join(config.RECIPES_DIR, escapeRecipeName(name))
+
 	return Recipe{
-		Name:   recipeName,
+		Name:    name,
-		Config: config,
+		Version: version,
-		Meta:   meta,
+		Dir:     dir,
-	}, nil
+		GitURL:  gitURL,
+		SSHURL:  sshURL,
+
+		ComposePath:   path.Join(dir, "compose.yml"),
+		ReadmePath:    path.Join(dir, "README.md"),
+		SampleEnvPath: path.Join(dir, ".env.sample"),
+		AbraShPath:    path.Join(dir, "abra.sh"),
+	}
 }
 
-func (r Recipe) SampleEnv() (map[string]string, error) {
+type Recipe struct {
-	envSamplePath := path.Join(config.RECIPES_DIR, r.Name, ".env.sample")
+	Name    string
-	sampleEnv, err := config.ReadEnv(envSamplePath)
+	Version string
-	if err != nil {
+	Dir     string
-		return sampleEnv, fmt.Errorf("unable to discover .env.sample for %s", r.Name)
+	GitURL  string
-	}
+	SSHURL  string
-	return sampleEnv, nil
+
+	ComposePath   string
+	ReadmePath    string
+	SampleEnvPath string
+	AbraShPath    string
 }
 
-// Ensure makes sure the recipe exists, is up to date and has the latest version checked out.
+func escapeRecipeName(recipeName string) string {
-func Ensure(recipeName string) error {
+	recipeName = strings.ReplaceAll(recipeName, "/", "_")
-	if err := EnsureExists(recipeName); err != nil {
+	recipeName = strings.ReplaceAll(recipeName, ".", "_")
-		return err
+	return recipeName
-	}
-	if err := EnsureUpToDate(recipeName); err != nil {
-		return err
-	}
-	if err := EnsureLatest(recipeName); err != nil {
-		return err
-	}
-	return nil
-}
-
-// EnsureExists ensures that a recipe is locally cloned
-func EnsureExists(recipeName string) error {
-	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-
-	if _, err := os.Stat(recipeDir); os.IsNotExist(err) {
-		logrus.Debugf("%s does not exist, attemmpting to clone", recipeDir)
-		url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, recipeName)
-		if err := gitPkg.Clone(recipeDir, url); err != nil {
-			return err
-		}
-	}
-
-	if err := gitPkg.EnsureGitRepo(recipeDir); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// EnsureVersion checks whether a specific version exists for a recipe.
-func EnsureVersion(recipeName, version string) error {
-	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-
-	if err := gitPkg.EnsureGitRepo(recipeDir); err != nil {
-		return err
-	}
-
-	repo, err := git.PlainOpen(recipeDir)
-	if err != nil {
-		return err
-	}
-
-	tags, err := repo.Tags()
-	if err != nil {
-		return nil
-	}
-
-	var parsedTags []string
-	var tagRef plumbing.ReferenceName
-	if err := tags.ForEach(func(ref *plumbing.Reference) (err error) {
-		parsedTags = append(parsedTags, ref.Name().Short())
-		if ref.Name().Short() == version {
-			tagRef = ref.Name()
-		}
-		return nil
-	}); err != nil {
-		return err
-	}
-
-	joinedTags := strings.Join(parsedTags, ", ")
-	if joinedTags != "" {
-		logrus.Debugf("read %s as tags for recipe %s", joinedTags, recipeName)
-	}
-
-	if tagRef.String() == "" {
-		return fmt.Errorf("the local copy of %s doesn't seem to have version %s available?", recipeName, version)
-	}
-
-	worktree, err := repo.Worktree()
-	if err != nil {
-		return err
-	}
-
-	opts := &git.CheckoutOptions{
-		Branch: tagRef,
-		Create: false,
-		Force:  true,
-	}
-	if err := worktree.Checkout(opts); err != nil {
-		return err
-	}
-
-	logrus.Debugf("successfully checked %s out to %s in %s", recipeName, tagRef.Short(), recipeDir)
-
-	return nil
-}
-
-// EnsureIsClean makes sure that the recipe repository has no unstaged changes.
-func EnsureIsClean(recipeName string) error {
-	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-
-	isClean, err := gitPkg.IsClean(recipeDir)
-	if err != nil {
-		return fmt.Errorf("unable to check git clean status in %s: %s", recipeDir, err)
-	}
-
-	if !isClean {
-		msg := "%s (%s) has locally unstaged changes? please commit/remove your changes before proceeding"
-		return fmt.Errorf(msg, recipeName, recipeDir)
-	}
-
-	return nil
-}
-
-// EnsureLatest makes sure the latest commit is checked out for a local recipe repository
-func EnsureLatest(recipeName string) error {
-	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-
-	if err := gitPkg.EnsureGitRepo(recipeDir); err != nil {
-		return err
-	}
-
-	repo, err := git.PlainOpen(recipeDir)
-	if err != nil {
-		return err
-	}
-
-	worktree, err := repo.Worktree()
-	if err != nil {
-		return err
-	}
-
-	branch, err := gitPkg.GetDefaultBranch(repo, recipeDir)
-	if err != nil {
-		return err
-	}
-
-	checkOutOpts := &git.CheckoutOptions{
-		Create: false,
-		Force:  true,
-		Branch: plumbing.ReferenceName(branch),
-	}
-
-	if err := worktree.Checkout(checkOutOpts); err != nil {
-		logrus.Debugf("failed to check out %s in %s", branch, recipeDir)
-		return err
-	}
-
-	return nil
-}
-
-// ChaosVersion constructs a chaos mode recipe version.
-func ChaosVersion(recipeName string) (string, error) {
-	var version string
-
-	head, err := gitPkg.GetRecipeHead(recipeName)
-	if err != nil {
-		return version, err
-	}
-
-	version = formatter.SmallSHA(head.String())
-
-	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-	isClean, err := gitPkg.IsClean(recipeDir)
-	if err != nil {
-		return version, err
-	}
-
-	if !isClean {
-		version = fmt.Sprintf("%s + unstaged changes", version)
-	}
-
-	return version, nil
 }
 
 // GetRecipesLocal retrieves all local recipe directories
@@ -445,41 +193,20 @@ func GetRecipesLocal() ([]string, error) {
 	return recipes, nil
 }
 
-// GetVersionLabelLocal retrieves the version label on the local recipe config
+func GetRecipeFeaturesAndCategory(r Recipe) (Features, string, error) {
-func GetVersionLabelLocal(recipe Recipe) (string, error) {
-	var label string
-
-	for _, service := range recipe.Config.Services {
-		for label, value := range service.Deploy.Labels {
-			if strings.HasPrefix(label, "coop-cloud") && strings.Contains(label, "version") {
-				return value, nil
-			}
-		}
-	}
-
-	if label == "" {
-		return label, fmt.Errorf("%s has no version label? try running \"abra recipe sync %s\" first?", recipe.Name, recipe.Name)
-	}
-
-	return label, nil
-}
-
-func GetRecipeFeaturesAndCategory(recipeName string) (Features, string, error) {
 	feat := Features{}
 
 	var category string
 
-	readmePath := path.Join(config.RECIPES_DIR, recipeName, "README.md")
+	log.Debugf("attempting to open %s for recipe metadata parsing", r.ReadmePath)
 
-	logrus.Debugf("attempting to open %s for recipe metadata parsing", readmePath)
+	readmeFS, err := ioutil.ReadFile(r.ReadmePath)
-
-	readmeFS, err := ioutil.ReadFile(readmePath)
 	if err != nil {
 		return feat, category, err
 	}
 
 	readmeMetadata, err := GetStringInBetween( // Find text between delimiters
-		recipeName,
+		r.Name,
 		string(readmeFS),
 		"<!-- metadata -->", "<!-- endmetadata -->",
 	)
@@ -530,7 +257,7 @@ func GetRecipeFeaturesAndCategory(recipeName string) (Features, string, error) {
 		if strings.Contains(val, "**Image**") {
 			imageMetadata, err := GetImageMetadata(strings.TrimSpace(
 				strings.TrimPrefix(val, "* **Image**:"),
-			), recipeName)
+			), r.Name)
 			if err != nil {
 				continue
 			}
@@ -552,9 +279,9 @@ func GetImageMetadata(imageRowString, recipeName string) (Image, error) {
 
 	if len(imgFields) < 3 {
 		if imageRowString != "" {
-			logrus.Warnf("%s image meta has incorrect format: %s", recipeName, imageRowString)
+			log.Warnf("%s image meta has incorrect format: %s", recipeName, imageRowString)
 		} else {
-			logrus.Warnf("%s image meta is empty?", recipeName)
+			log.Warnf("%s image meta is empty?", recipeName)
 		}
 		return img, nil
 	}
@@ -566,13 +293,13 @@ func GetImageMetadata(imageRowString, recipeName string) (Image, error) {
 
 	imageName, err := GetStringInBetween(recipeName, imgString, "[", "]")
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 	img.Image = strings.ReplaceAll(imageName, "`", "")
 
 	imageURL, err := GetStringInBetween(recipeName, imgString, "(", ")")
 	if err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 	img.URL = imageURL
 
@@ -596,59 +323,6 @@ func GetStringInBetween(recipeName, str, start, end string) (result string, err
 	return str[s : s+e], nil
 }
 
-// EnsureUpToDate ensures that the local repo is synced to the remote
-func EnsureUpToDate(recipeName string) error {
-	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-
-	repo, err := git.PlainOpen(recipeDir)
-	if err != nil {
-		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", recipeDir, err)
-	}
-
-	if len(remotes) == 0 {
-		logrus.Debugf("cannot ensure %s is up-to-date, no git remotes configured", recipeName)
-		return nil
-	}
-
-	worktree, err := repo.Worktree()
-	if err != nil {
-		return fmt.Errorf("unable to open git work tree in %s: %s", recipeDir, err)
-	}
-
-	branch, err := gitPkg.CheckoutDefaultBranch(repo, recipeDir)
-	if err != nil {
-		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", recipeDir, err)
-		}
-	}
-
-	opts := &git.PullOptions{
-		Force:         true,
-		ReferenceName: branch,
-		SingleBranch:  true,
-	}
-
-	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", recipeDir, err)
-		}
-	}
-
-	logrus.Debugf("fetched latest git changes for %s", recipeName)
-
-	return nil
-}
-
 // ReadRecipeCatalogue reads the recipe catalogue.
 func ReadRecipeCatalogue(offline bool) (RecipeCatalogue, error) {
 	recipes := make(RecipeCatalogue)
@@ -681,7 +355,7 @@ func readRecipeCatalogueFS(target interface{}) error {
 		return err
 	}
 
-	logrus.Debugf("read recipe catalogue from file system cache in %s", config.RECIPES_JSON)
+	log.Debugf("read recipe catalogue from file system cache in %s", config.RECIPES_JSON)
 
 	return nil
 }
@@ -710,7 +384,7 @@ func VersionsOfService(recipe, serviceName string, offline bool) ([]string, erro
 		}
 	}
 
-	logrus.Debugf("detected versions %s for %s", strings.Join(versions, ", "), recipe)
+	log.Debugf("detected versions %s for %s", strings.Join(versions, ", "), recipe)
 
 	return versions, nil
 }
@@ -737,7 +411,7 @@ func GetRecipeMeta(recipeName string, offline bool) (RecipeMeta, error) {
 		}
 	}
 
-	logrus.Debugf("recipe metadata retrieved for %s", recipeName)
+	log.Debugf("recipe metadata retrieved for %s", recipeName)
 
 	return recipeMeta, nil
 }
@@ -830,7 +504,7 @@ func ReadReposMetadata() (RepoCatalogue, error) {
 
 		pagedURL := fmt.Sprintf("%s?page=%v", ReposMetadataURL, pageIdx)
 
-		logrus.Debugf("fetching repo metadata from %s", pagedURL)
+		log.Debugf("fetching repo metadata from %s", pagedURL)
 
 		if err := web.ReadJSON(pagedURL, &reposList); err != nil {
 			return reposMeta, err
@@ -863,96 +537,6 @@ func ReadReposMetadata() (RepoCatalogue, error) {
 	return reposMeta, nil
 }
 
-// GetRecipeVersions retrieves all recipe versions.
-func GetRecipeVersions(recipeName string, offline bool) (RecipeVersions, error) {
-	versions := RecipeVersions{}
-	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-
-	logrus.Debugf("attempting to open git repository in %s", recipeDir)
-
-	repo, err := git.PlainOpen(recipeDir)
-	if err != nil {
-		return versions, err
-	}
-
-	worktree, err := repo.Worktree()
-	if err != nil {
-		return versions, err
-	}
-
-	gitTags, err := repo.Tags()
-	if err != nil {
-		return versions, err
-	}
-
-	if err := gitTags.ForEach(func(ref *plumbing.Reference) (err error) {
-		tag := strings.TrimPrefix(string(ref.Name()), "refs/tags/")
-
-		logrus.Debugf("processing %s for %s", tag, recipeName)
-
-		checkOutOpts := &git.CheckoutOptions{
-			Create: false,
-			Force:  true,
-			Branch: plumbing.ReferenceName(ref.Name()),
-		}
-		if err := worktree.Checkout(checkOutOpts); err != nil {
-			logrus.Debugf("failed to check out %s in %s", tag, recipeDir)
-			return err
-		}
-
-		logrus.Debugf("successfully checked out %s in %s", ref.Name(), recipeDir)
-
-		recipe, err := Get(recipeName, offline)
-		if err != nil {
-			return err
-		}
-
-		versionMeta := make(map[string]ServiceMeta)
-		for _, service := range recipe.Config.Services {
-
-			img, err := reference.ParseNormalizedNamed(service.Image)
-			if err != nil {
-				return err
-			}
-
-			path := reference.Path(img)
-
-			path = formatter.StripTagMeta(path)
-
-			var tag string
-			switch img.(type) {
-			case reference.NamedTagged:
-				tag = img.(reference.NamedTagged).Tag()
-			case reference.Named:
-				logrus.Warnf("%s service is missing image tag?", path)
-				continue
-			}
-
-			versionMeta[service.Name] = ServiceMeta{
-				Image: path,
-				Tag:   tag,
-			}
-		}
-
-		versions = append(versions, map[string]map[string]ServiceMeta{tag: versionMeta})
-
-		return nil
-	}); err != nil {
-		return versions, err
-	}
-
-	_, err = gitPkg.CheckoutDefaultBranch(repo, recipeDir)
-	if err != nil {
-		return versions, err
-	}
-
-	sortRecipeVersions(versions)
-
-	logrus.Debugf("collected %s for %s", versions, recipeName)
-
-	return versions, nil
-}
-
 // sortRecipeVersions sorts the recipe semver versions
 func sortRecipeVersions(versions RecipeVersions) {
 	sort.Slice(versions, func(i, j int) bool {
@@ -1033,9 +617,8 @@ func UpdateRepositories(repos RepoCatalogue, recipeName string) error {
 				return
 			}
 
-			recipeDir := path.Join(config.RECIPES_DIR, rm.Name)
+			if err := gitPkg.Clone(Get(rm.Name).Dir, rm.CloneURL); err != nil {
-			if err := gitPkg.Clone(recipeDir, rm.CloneURL); err != nil {
+				log.Fatal(err)
-				logrus.Fatal(err)
 			}
 
 			ch <- rm.Name
@@ -1054,3 +637,11 @@ func UpdateRepositories(repos RepoCatalogue, recipeName string) error {
 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.
+func ensurePathExists(path string) error {
+	if _, err := os.Stat(path); err != nil && os.IsNotExist(err) {
+		return err
+	}
+	return nil
+}

pkg/recipe/recipe_test.go

@@ -1,20 +1,96 @@
 package recipe
 
 import (
+	"path"
 	"testing"
 
+	"coopcloud.tech/abra/pkg/config"
+
+	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/assert"
 )
 
+func TestGet(t *testing.T) {
+	cfg := config.LoadAbraConfig()
+	testcases := []struct {
+		name   string
+		recipe Recipe
+	}{
+		{
+			name: "foo",
+			recipe: Recipe{
+				Name:          "foo",
+				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",
+				ComposePath:   path.Join(cfg.GetAbraDir(), "recipes/foo/compose.yml"),
+				ReadmePath:    path.Join(cfg.GetAbraDir(), "recipes/foo/README.md"),
+				SampleEnvPath: path.Join(cfg.GetAbraDir(), "recipes/foo/.env.sample"),
+				AbraShPath:    path.Join(cfg.GetAbraDir(), "recipes/foo/abra.sh"),
+			},
+		},
+		{
+			name: "foo:1.2.3",
+			recipe: Recipe{
+				Name:          "foo",
+				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",
+				ComposePath:   path.Join(cfg.GetAbraDir(), "recipes/foo/compose.yml"),
+				ReadmePath:    path.Join(cfg.GetAbraDir(), "recipes/foo/README.md"),
+				SampleEnvPath: path.Join(cfg.GetAbraDir(), "recipes/foo/.env.sample"),
+				AbraShPath:    path.Join(cfg.GetAbraDir(), "recipes/foo/abra.sh"),
+			},
+		},
+		{
+			name: "mygit.org/myorg/cool-recipe",
+			recipe: Recipe{
+				Name:          "mygit.org/myorg/cool-recipe",
+				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",
+				ComposePath:   path.Join(cfg.GetAbraDir(), "recipes/mygit_org_myorg_cool-recipe/compose.yml"),
+				ReadmePath:    path.Join(cfg.GetAbraDir(), "recipes/mygit_org_myorg_cool-recipe/README.md"),
+				SampleEnvPath: path.Join(cfg.GetAbraDir(), "recipes/mygit_org_myorg_cool-recipe/.env.sample"),
+				AbraShPath:    path.Join(cfg.GetAbraDir(), "recipes/mygit_org_myorg_cool-recipe/abra.sh"),
+			},
+		},
+		{
+			name: "mygit.org/myorg/cool-recipe:1.2.4",
+			recipe: Recipe{
+				Name:          "mygit.org/myorg/cool-recipe",
+				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",
+				ComposePath:   path.Join(cfg.GetAbraDir(), "recipes/mygit_org_myorg_cool-recipe/compose.yml"),
+				ReadmePath:    path.Join(cfg.GetAbraDir(), "recipes/mygit_org_myorg_cool-recipe/README.md"),
+				SampleEnvPath: path.Join(cfg.GetAbraDir(), "recipes/mygit_org_myorg_cool-recipe/.env.sample"),
+				AbraShPath:    path.Join(cfg.GetAbraDir(), "recipes/mygit_org_myorg_cool-recipe/abra.sh"),
+			},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Setenv("ABRA_DIR", "<abraDir>")
+			recipe := Get(tc.name)
+			if diff := cmp.Diff(tc.recipe, recipe); diff != "" {
+				t.Errorf("Recipe mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
 func TestGetVersionLabelLocalDoesNotUseTimeoutLabel(t *testing.T) {
-	offline := true
+	r := Get("traefik")
-	recipe, err := Get("traefik", offline)
+	if err := r.EnsureExists(); err != nil {
-	if err != nil {
 		t.Fatal(err)
 	}
 
-	for i := 1; i < 1000; i++ {
+	for i := 1; i < 50; i++ {
-		label, err := GetVersionLabelLocal(recipe)
+		label, err := r.GetVersionLabelLocal()
 		if err != nil {
 			t.Fatal(err)
 		}

pkg/secret/pass.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"os/exec"
 
-	"github.com/sirupsen/logrus"
+	"coopcloud.tech/abra/pkg/log"
 )
 
 // PassInsertSecret inserts a secret into a pass store.
@@ -19,13 +19,13 @@ func PassInsertSecret(secretValue, secretName, appName, server string) error {
 		secretValue, server, appName, secretName,
 	)
 
-	logrus.Debugf("attempting to run %s", cmd)
+	log.Debugf("attempting to run %s", cmd)
 
 	if err := exec.Command("bash", "-c", cmd).Run(); err != nil {
 		return err
 	}
 
-	logrus.Infof("%s inserted into pass store", secretName)
+	log.Infof("%s inserted into pass store", secretName)
 
 	return nil
 }
@@ -41,13 +41,13 @@ func PassRmSecret(secretName, appName, server string) error {
 		server, appName, secretName,
 	)
 
-	logrus.Debugf("attempting to run %s", cmd)
+	log.Debugf("attempting to run %s", cmd)
 
 	if err := exec.Command("bash", "-c", cmd).Run(); err != nil {
 		return err
 	}
 
-	logrus.Infof("%s removed from pass store", secretName)
+	log.Infof("%s removed from pass store", secretName)
 
 	return nil
 }

pkg/secret/secret.go

@@ -11,14 +11,16 @@ import (
 	"strings"
 	"sync"
 
+	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/envfile"
+	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	loader "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/decentral1se/passgen"
 	"github.com/docker/docker/api/types"
 	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
 // Secret represents a secret.
@@ -52,7 +54,7 @@ func GeneratePasswords(count, length uint) ([]string, error) {
 		return nil, err
 	}
 
-	logrus.Debugf("generated %s", strings.Join(passwords, ", "))
+	log.Debugf("generated %s", strings.Join(passwords, ", "))
 
 	return passwords, nil
 }
@@ -70,7 +72,7 @@ func GeneratePassphrases(count uint) ([]string, error) {
 		return nil, err
 	}
 
-	logrus.Debugf("generated %s", strings.Join(passphrases, ", "))
+	log.Debugf("generated %s", strings.Join(passphrases, ", "))
 
 	return passphrases, nil
 }
@@ -81,7 +83,7 @@ func GeneratePassphrases(count uint) ([]string, error) {
 // "app new" case where we pass in the .env.sample and the "secret generate"
 // case where the app is created.
 func ReadSecretsConfig(appEnvPath string, composeFiles []string, stackName string) (map[string]Secret, error) {
-	appEnv, appModifiers, err := config.ReadEnvWithModifiers(appEnvPath)
+	appEnv, appModifiers, err := envfile.ReadEnvWithModifiers(appEnvPath)
 	if err != nil {
 		return nil, err
 	}
@@ -107,7 +109,7 @@ func ReadSecretsConfig(appEnvPath string, composeFiles []string, stackName strin
 	}
 
 	if len(enabledSecrets) == 0 {
-		logrus.Debugf("not generating app secrets, none enabled in recipe config")
+		log.Debugf("not generating app secrets, none enabled in recipe config")
 		return nil, nil
 	}
 
@@ -118,7 +120,7 @@ func ReadSecretsConfig(appEnvPath string, composeFiles []string, stackName strin
 		}
 
 		if !(slices.Contains(enabledSecrets, secretId)) {
-			logrus.Warnf("%s not enabled in recipe config, skipping", secretId)
+			log.Warnf("%s not enabled in recipe config, skipping", secretId)
 			continue
 		}
 
@@ -168,7 +170,7 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server
 		go func(secretName string, secret Secret) {
 			defer wg.Done()
 
-			logrus.Debugf("attempting to generate and store %s on %s", secret.RemoteName, server)
+			log.Debugf("attempting to generate and store %s on %s", secret.RemoteName, server)
 
 			if secret.Length > 0 {
 				passwords, err := GeneratePasswords(1, uint(secret.Length))
@@ -179,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") {
-						logrus.Warnf("%s already exists, moving on...", secret.RemoteName)
+						log.Warnf("%s already exists, moving on...", secret.RemoteName)
 						ch <- nil
 					} else {
 						ch <- err
@@ -199,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") {
-						logrus.Warnf("%s already exists, moving on...", secret.RemoteName)
+						log.Warnf("%s already exists, moving on...", secret.RemoteName)
 						ch <- nil
 					} else {
 						ch <- err
@@ -224,7 +226,7 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server
 		}
 	}
 
-	logrus.Debugf("generated and stored %v on %s", secrets, server)
+	log.Debugf("generated and stored %v on %s", secrets, server)
 
 	return secretsGenerated, nil
 }
@@ -240,10 +242,10 @@ type secretStatuses []secretStatus
 
 // PollSecretsStatus checks status of secrets by comparing the local recipe
 // config and deploymend server state.
-func PollSecretsStatus(cl *dockerClient.Client, app config.App) (secretStatuses, error) {
+func PollSecretsStatus(cl *dockerClient.Client, app appPkg.App) (secretStatuses, error) {
 	var secStats secretStatuses
 
-	composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
+	composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
 	if err != nil {
 		return secStats, err
 	}

pkg/server/server.go

@@ -5,7 +5,7 @@ import (
 	"path"
 
 	"coopcloud.tech/abra/pkg/config"
-	"github.com/sirupsen/logrus"
+	"coopcloud.tech/abra/pkg/log"
 )
 
 // CreateServerDir creates a server directory under ~/.abra.
@@ -17,11 +17,11 @@ func CreateServerDir(serverName string) error {
 			return err
 		}
 
-		logrus.Infof("%s already exists", serverPath)
+		log.Debugf("%s already exists", serverPath)
 		return nil
 	}
 
-	logrus.Infof("successfully created %s", serverPath)
+	log.Debugf("successfully created %s", serverPath)
 
 	return nil
 }

pkg/service/service.go

@@ -6,12 +6,12 @@ import (
 	"strings"
 
 	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
 // GetService retrieves a service container based on a label. If prompt is true
@@ -52,7 +52,7 @@ func GetServiceByLabel(c context.Context, cl *client.Client, label string, promp
 			return swarm.Service{}, err
 		}
 
-		logrus.Warnf("ambiguous service list received, prompting for input")
+		log.Warnf("ambiguous service list received, prompting for input")
 
 		var response string
 		prompt := &survey.Select{
@@ -72,7 +72,7 @@ func GetServiceByLabel(c context.Context, cl *client.Client, label string, promp
 			}
 		}
 
-		logrus.Panic("failed to match chosen service")
+		log.Fatal("failed to match chosen service")
 	}
 
 	return matchingServices[0], nil
@@ -106,7 +106,7 @@ func GetService(c context.Context, cl *client.Client, filters filters.Args, prom
 			return swarm.Service{}, err
 		}
 
-		logrus.Warnf("ambiguous service list received, prompting for input")
+		log.Warnf("ambiguous service list received, prompting for input")
 
 		var response string
 		prompt := &survey.Select{
@@ -126,7 +126,7 @@ func GetService(c context.Context, cl *client.Client, filters filters.Args, prom
 			}
 		}
 
-		logrus.Panic("failed to match chosen service")
+		log.Fatal("failed to match chosen service")
 	}
 
 	return services[0], nil

pkg/ssh/ssh.go

@@ -19,7 +19,7 @@ func Fatal(hostname string, err error) error {
 	} else if strings.Contains(out, "Permission denied") {
 		return fmt.Errorf("ssh auth: permission denied for %s", hostname)
 	} else if strings.Contains(out, "Network is unreachable") {
-		return fmt.Errorf("unable to connect to %s, network is unreachable?", hostname)
+		return fmt.Errorf("unable to connect to %s, please check your SSH config", hostname)
 	}
 
 	return err

pkg/test/test.go

@@ -1,22 +1,64 @@
 package test
 
 import (
-	"log"
 	"os"
+	"path"
 
-	"github.com/sirupsen/logrus"
+	appPkg "coopcloud.tech/abra/pkg/app"
+	"coopcloud.tech/abra/pkg/envfile"
+	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/recipe"
 )
 
+var (
+	TestFolder    = os.ExpandEnv("$PWD/../../tests/resources/test_folder")
+	ValidAbraConf = os.ExpandEnv("$PWD/../../tests/resources/valid_abra_config")
+)
+
+// make sure these are in alphabetical order
+var (
+	TFolders = []string{"folder1", "folder2"}
+	TFiles   = []string{"bar.env", "foo.env"}
+)
+
+var (
+	AppName    = "ecloud"
+	ServerName = "evil.corp"
+)
+
+var ExpectedAppEnv = envfile.AppEnv{
+	"DOMAIN": "ecloud.evil.corp",
+	"RECIPE": "ecloud",
+}
+
+var ExpectedApp = appPkg.App{
+	Name:   AppName,
+	Recipe: recipe.Get(ExpectedAppEnv["RECIPE"]),
+	Domain: ExpectedAppEnv["DOMAIN"],
+	Env:    ExpectedAppEnv,
+	Path:   ExpectedAppFile.Path,
+	Server: ExpectedAppFile.Server,
+}
+
+var ExpectedAppFile = appPkg.AppFile{
+	Path:   path.Join(ValidAbraConf, "servers", ServerName, AppName+".env"),
+	Server: ServerName,
+}
+
+var ExpectedAppFiles = map[string]appPkg.AppFile{
+	AppName: ExpectedAppFile,
+}
+
 // RmServerAppRecipe deletes the test server / app / recipe.
 func RmServerAppRecipe() {
 	testAppLink := os.ExpandEnv("$HOME/.abra/servers/foo.com")
 	if err := os.Remove(testAppLink); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 
 	testRecipeLink := os.ExpandEnv("$HOME/.abra/recipes/test")
 	if err := os.Remove(testRecipeLink); err != nil {
-		logrus.Fatal(err)
+		log.Fatal(err)
 	}
 }
 

pkg/upstream/commandconn/commandconn.go

@@ -27,8 +27,8 @@ import (
 	"syscall"
 	"time"
 
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	exec "golang.org/x/sys/execabs"
 )
 
@@ -46,7 +46,7 @@ func New(ctx context.Context, cmd string, args ...string) (net.Conn, error) {
 	)
 	c.cmd = exec.CommandContext(ctx, cmd, args...)
 	// we assume that args never contains sensitive information
-	logrus.Debugf("commandconn: starting %s with %v", cmd, args)
+	log.Debugf("commandconn: starting %s with %v", cmd, args)
 	c.cmd.Env = os.Environ()
 	c.cmd.SysProcAttr = &syscall.SysProcAttr{}
 	setPdeathsig(c.cmd)
@@ -189,14 +189,14 @@ func (c *commandConn) CloseRead() error {
 	// NOTE: maybe already closed here
 	if err := c.stdout.Close(); err != nil && !ignorableCloseError(err) {
 		// muted because https://github.com/docker/compose/issues/8544
-		// logrus.Warnf("commandConn.CloseRead: %v", err)
+		// log.Warnf("commandConn.CloseRead: %v", err)
 	}
 	c.stdioClosedMu.Lock()
 	c.stdoutClosed = true
 	c.stdioClosedMu.Unlock()
 	if err := c.killIfStdioClosed(); err != nil {
 		// muted because https://github.com/docker/compose/issues/8544
-		// logrus.Warnf("commandConn.CloseRead: %v", err)
+		// log.Warnf("commandConn.CloseRead: %v", err)
 	}
 	return nil
 }
@@ -213,14 +213,14 @@ func (c *commandConn) CloseWrite() error {
 	// NOTE: maybe already closed here
 	if err := c.stdin.Close(); err != nil && !ignorableCloseError(err) {
 		// muted because https://github.com/docker/compose/issues/8544
-		// logrus.Warnf("commandConn.CloseWrite: %v", err)
+		// log.Warnf("commandConn.CloseWrite: %v", err)
 	}
 	c.stdioClosedMu.Lock()
 	c.stdinClosed = true
 	c.stdioClosedMu.Unlock()
 	if err := c.killIfStdioClosed(); err != nil {
 		// muted because https://github.com/docker/compose/issues/8544
-		// logrus.Warnf("commandConn.CloseWrite: %v", err)
+		// log.Warnf("commandConn.CloseWrite: %v", err)
 	}
 	return nil
 }
@@ -236,11 +236,11 @@ func (c *commandConn) Write(p []byte) (int, error) {
 func (c *commandConn) Close() error {
 	var err error
 	if err = c.CloseRead(); err != nil {
-		logrus.Warnf("commandConn.Close: CloseRead: %v", err)
+		log.Warnf("commandConn.Close: CloseRead: %v", err)
 	}
 	if err = c.CloseWrite(); err != nil {
 		// muted because https://github.com/docker/compose/issues/8544
-		// logrus.Warnf("commandConn.Close: CloseWrite: %v", err)
+		// log.Warnf("commandConn.Close: CloseWrite: %v", err)
 	}
 	return err
 }
@@ -252,15 +252,15 @@ func (c *commandConn) RemoteAddr() net.Addr {
 	return c.remoteAddr
 }
 func (c *commandConn) SetDeadline(t time.Time) error {
-	logrus.Debugf("unimplemented call: SetDeadline(%v)", t)
+	log.Debugf("unimplemented call: SetDeadline(%v)", t)
 	return nil
 }
 func (c *commandConn) SetReadDeadline(t time.Time) error {
-	logrus.Debugf("unimplemented call: SetReadDeadline(%v)", t)
+	log.Debugf("unimplemented call: SetReadDeadline(%v)", t)
 	return nil
 }
 func (c *commandConn) SetWriteDeadline(t time.Time) error {
-	logrus.Debugf("unimplemented call: SetWriteDeadline(%v)", t)
+	log.Debugf("unimplemented call: SetWriteDeadline(%v)", t)
 	return nil
 }
 
@@ -284,7 +284,7 @@ type stderrWriter struct {
 }
 
 func (w *stderrWriter) Write(p []byte) (int, error) {
-	logrus.Debugf("%s%s", w.debugPrefix, string(p))
+	log.Debugf("%s%s", w.debugPrefix, string(p))
 	w.stderrMu.Lock()
 	if w.stderr.Len() > 4096 {
 		w.stderr.Reset()

pkg/upstream/commandconn/connection.go

@@ -2,6 +2,7 @@ package commandconn
 
 import (
 	"context"
+	"fmt"
 	"net"
 	"net/url"
 
@@ -14,14 +15,17 @@ import (
 )
 
 // GetConnectionHelper returns Docker-specific connection helper for the given URL.
-// GetConnectionHelper returns nil without error when no helper is registered for the scheme.
+func GetConnectionHelper(daemonURL string, timeout int) (*connhelper.ConnectionHelper, error) {
-//
+	if timeout != 0 {
-// ssh://<host> URL requires Docker 18.09 or later on the remote host.
+		return getConnectionHelper(daemonURL, []string{fmt.Sprintf("-o ConnectTimeout=%v", timeout)})
-func GetConnectionHelper(daemonURL string) (*connhelper.ConnectionHelper, error) {
+	}
-	return getConnectionHelper(daemonURL)
+
+	return getConnectionHelper(daemonURL, []string{})
 }
 
-func getConnectionHelper(daemonURL string) (*connhelper.ConnectionHelper, error) {
+// getConnectionHelper generates a connection helper from the underlying Docker
+// libraries.
+func getConnectionHelper(daemonURL string, sshFlags []string) (*connhelper.ConnectionHelper, error) {
 	url, err := url.Parse(daemonURL)
 	if err != nil {
 		return nil, err
@@ -35,7 +39,7 @@ func getConnectionHelper(daemonURL string) (*connhelper.ConnectionHelper, error)
 
 		return &connhelper.ConnectionHelper{
 			Dialer: func(ctx context.Context, network, addr string) (net.Conn, error) {
-				return New(ctx, "ssh", ctxConnDetails.Args("docker", "system", "dial-stdio")...)
+				return New(ctx, "ssh", append(sshFlags, ctxConnDetails.Args("docker", "system", "dial-stdio")...)...)
 			},
 			Host: "http://docker.example.com",
 		}, nil
@@ -46,8 +50,8 @@ func getConnectionHelper(daemonURL string) (*connhelper.ConnectionHelper, error)
 }
 
 // NewConnectionHelper creates new connection helper for a remote docker daemon.
-func NewConnectionHelper(daemonURL string) (*connhelper.ConnectionHelper, error) {
+func NewConnectionHelper(daemonURL string, timeout int) (*connhelper.ConnectionHelper, error) {
-	helper, err := GetConnectionHelper(daemonURL)
+	helper, err := GetConnectionHelper(daemonURL, timeout)
 	if err != nil {
 		return nil, err
 	}

pkg/upstream/container/exec.go

@@ -6,11 +6,11 @@ import (
 	"fmt"
 	"io"
 
+	"coopcloud.tech/abra/pkg/log"
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
 	apiclient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
 )
 
 // RunExec runs a command on a remote container. io.Writer corresponds to the
@@ -109,7 +109,7 @@ func interactiveExec(ctx context.Context, dockerCli command.Cli, client *apiclie
 	}
 
 	if err := <-errCh; err != nil {
-		logrus.Debugf("Error hijack: %s", err)
+		log.Debugf("Error hijack: %s", err)
 		return out, err
 	}