Fixed typo in abra ac bash output

See coop-cloud/organising#280.
See coop-cloud/organising#273.

cli/app/app.go

@@ -35,5 +35,6 @@ to scaling apps up and spinning them down.
 		appSecretCommand,
 		appVolumeCommand,
 		appVersionCommand,
+		appErrorsCommand,
 	},
 }

cli/app/backup.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
@@ -72,16 +73,5 @@ var appBackupCommand = &cli.Command{
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/check.go

@@ -1,12 +1,12 @@
 package app
 
 import (
-	"fmt"
 	"os"
 	"path"
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
@@ -49,16 +49,5 @@ var appCheckCommand = &cli.Command{
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/config.go

@@ -2,11 +2,11 @@ package app
 
 import (
 	"errors"
-	"fmt"
 	"os"
 	"os/exec"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
@@ -55,16 +55,5 @@ var appConfigCommand = &cli.Command{
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/cp.go

@@ -1,12 +1,11 @@
 package app
 
 import (
-	"fmt"
 	"os"
 	"strings"
 
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
@@ -83,16 +82,5 @@ And if you want to copy that file back to your current working directory locally
 		return nil
 
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/deploy.go

@@ -1,11 +1,8 @@
 package app
 
 import (
-	"fmt"
-
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/autocomplete"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
@@ -16,6 +13,7 @@ var appDeployCommand = &cli.Command{
 	Flags: []cli.Flag{
 		internal.ForceFlag,
 		internal.ChaosFlag,
+		internal.NoDomainChecksFlag,
 	},
 	Description: `
 This command deploys a new instance of an app. It does not support changing the
@@ -29,17 +27,6 @@ Chas mode ("--chaos") will deploy your local checkout of a recipe as-is,
 including unstaged changes and can be useful for live hacking and testing new
 recipes.
 `,
-	Action: internal.DeployAction,
+	Action:       internal.DeployAction,
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/errors.go

@@ -0,0 +1,27 @@
+package app
+
+import (
+	"coopcloud.tech/abra/pkg/autocomplete"
+	"github.com/urfave/cli/v2"
+)
+
+var appErrorsCommand = &cli.Command{
+	Name:  "errors",
+	Usage: "List errors for a deployed app",
+	Description: `
+This command will 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 is best accompanied
+by "abra app logs <app>".
+`,
+	Aliases:      []string{"e"},
+	Flags:        []cli.Flag{},
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		// TODO: entrypoint error
+		// TODO: ps --no-trunc errors
+		// TODO: failing healthcheck
+		return nil
+	},
+}

cli/app/list.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	abraFormatter "coopcloud.tech/abra/cli/formatter"
+	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/catalogue"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/ssh"
@@ -41,6 +42,25 @@ var listAppServerFlag = &cli.StringFlag{
 	Destination: &listAppServer,
 }
 
+type appStatus struct {
+	server  string
+	recipe  string
+	appName string
+	domain  string
+	status  string
+	version string
+	upgrade string
+}
+
+type serverStatus struct {
+	apps             []appStatus
+	appCount         int
+	versionCount     int
+	unversionedCount int
+	latestCount      int
+	upgradeCount     int
+}
+
 var appListCommand = &cli.Command{
 	Name:  "list",
 	Usage: "List all managed apps",
@@ -68,39 +88,50 @@ can take some time.
 		if err != nil {
 			logrus.Fatal(err)
 		}
+
 		sort.Sort(config.ByServerAndType(apps))
 
-		for _, app := range apps {
+		statuses := make(map[string]map[string]string)
-			if err := ssh.EnsureHostKey(app.Server); err != nil {
+		var catl catalogue.RecipeCatalogue
+		if status {
+			alreadySeen := make(map[string]bool)
+			for _, app := range apps {
+				if _, ok := alreadySeen[app.Server]; !ok {
+					if err := ssh.EnsureHostKey(app.Server); err != nil {
+						logrus.Fatal(fmt.Sprintf(internal.SSHFailMsg, app.Server))
+					}
+					alreadySeen[app.Server] = true
+				}
+			}
+
+			statuses, err = config.GetAppStatuses(appFiles)
+			if err != nil {
 				logrus.Fatal(err)
 			}
-		}
 
-		statuses := make(map[string]map[string]string)
+			var err error
-		tableCol := []string{"Server", "Type", "Domain"}
+			catl, err = catalogue.ReadRecipeCatalogue()
-		if status {
-			tableCol = append(tableCol, "Status", "Version", "Updates")
-			statuses, err = config.GetAppStatuses(appFiles)
 			if err != nil {
 				logrus.Fatal(err)
 			}
 		}
 
-		table := abraFormatter.CreateTable(tableCol)
+		var totalServersCount int
-		table.SetAutoMergeCellsByColumnIndex([]int{0})
+		var totalAppsCount int
-
+		allStats := make(map[string]serverStatus)
-		var (
-			versionedAppsCount   int
-			unversionedAppsCount int
-			onLatestCount        int
-			canUpgradeCount      int
-		)
-
 		for _, app := range apps {
-			var tableRow []string
+			var stats serverStatus
+			var ok bool
+			if stats, ok = allStats[app.Server]; !ok {
+				stats = serverStatus{}
+				totalServersCount++
+			}
+
 			if app.Type == appType || appType == "" {
-				// If type flag is set, check for it, if not, Type == ""
+				appStats := appStatus{}
-				tableRow = []string{app.Server, app.Type, app.Domain}
+				stats.appCount++
+				totalAppsCount++
+
 				if status {
 					stackName := app.StackName()
 					status := "unknown"
@@ -112,16 +143,17 @@ can take some time.
 						if statusMeta["status"] != "" {
 							status = statusMeta["status"]
 						}
-						tableRow = append(tableRow, status, version)
+						stats.versionCount++
-						versionedAppsCount++
 					} else {
-						tableRow = append(tableRow, status, version)
+						stats.unversionedCount++
-						unversionedAppsCount++
 					}
 
+					appStats.status = status
+					appStats.version = version
+
 					var newUpdates []string
 					if version != "unknown" {
-						updates, err := catalogue.GetRecipeCatalogueVersions(app.Type)
+						updates, err := catalogue.GetRecipeCatalogueVersions(app.Type, catl)
 						if err != nil {
 							logrus.Fatal(err)
 						}
@@ -145,35 +177,72 @@ can take some time.
 
 					if len(newUpdates) == 0 {
 						if version == "unknown" {
-							tableRow = append(tableRow, "unknown")
+							appStats.upgrade = "unknown"
 						} else {
-							tableRow = append(tableRow, "on latest")
+							appStats.upgrade = "latest"
-							onLatestCount++
+							stats.latestCount++
 						}
 					} else {
 						// FIXME: jeezus golang why do you not have a list reverse function
 						for i, j := 0, len(newUpdates)-1; i < j; i, j = i+1, j-1 {
 							newUpdates[i], newUpdates[j] = newUpdates[j], newUpdates[i]
 						}
-						tableRow = append(tableRow, strings.Join(newUpdates, "\n"))
+						appStats.upgrade = strings.Join(newUpdates, "\n")
-						canUpgradeCount++
+						stats.upgradeCount++
 					}
 				}
+
+				appStats.server = app.Server
+				appStats.recipe = app.Type
+				appStats.appName = app.StackName()
+				appStats.domain = app.Domain
+
+				stats.apps = append(stats.apps, appStats)
 			}
-			table.Append(tableRow)
+
+			allStats[app.Server] = stats
 		}
 
-		stats := fmt.Sprintf(
+		for serverName, serverStat := range allStats {
-			"Total apps: %v | Versioned: %v | Unversioned: %v | On latest: %v | Can upgrade: %v",
+			tableCol := []string{"recipe", "app name", "domain"}
-			len(apps),
+			if status {
-			versionedAppsCount,
+				tableCol = append(tableCol, []string{"status", "version", "upgrade"}...)
-			unversionedAppsCount,
+			}
-			onLatestCount,
-			canUpgradeCount,
-		)
 
-		table.SetCaption(true, stats)
+			table := abraFormatter.CreateTable(tableCol)
-		table.Render()
+
+			for _, appStat := range serverStat.apps {
+				tableRow := []string{appStat.recipe, appStat.appName, appStat.domain}
+				if status {
+					tableRow = append(tableRow, []string{appStat.status, appStat.version, appStat.upgrade}...)
+				}
+				table.Append(tableRow)
+			}
+
+			table.Render()
+
+			if status {
+				fmt.Println(fmt.Sprintf(
+					"server: %s | total apps: %v | versioned: %v | unversioned: %v | latest: %v | upgrade: %v",
+					serverName,
+					serverStat.appCount,
+					serverStat.versionCount,
+					serverStat.unversionedCount,
+					serverStat.latestCount,
+					serverStat.upgradeCount,
+				))
+			} else {
+				fmt.Println(fmt.Sprintf("server: %s | total apps: %v", serverName, serverStat.appCount))
+			}
+
+			if len(allStats) > 1 {
+				fmt.Println() // newline separator for multiple servers
+			}
+		}
+
+		if len(allStats) > 1 {
+			fmt.Println(fmt.Sprintf("total servers: %v | total apps: %v ", totalServersCount, totalAppsCount))
+		}
 
 		return nil
 	},

cli/app/logs.go

@@ -7,6 +7,7 @@ import (
 	"sync"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	"github.com/docker/docker/api/types"
@@ -16,6 +17,15 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
+var logOpts = types.ContainerLogsOptions{
+	Details:    false,
+	Follow:     true,
+	ShowStderr: true,
+	ShowStdout: true,
+	Tail:       "20",
+	Timestamps: true,
+}
+
 // stackLogs lists logs for all stack services
 func stackLogs(c *cli.Context, stackName string, client *dockerClient.Client) {
 	filters := filters.NewArgs()
@@ -30,14 +40,10 @@ func stackLogs(c *cli.Context, stackName string, client *dockerClient.Client) {
 	for _, service := range services {
 		wg.Add(1)
 		go func(s string) {
-			logOpts := types.ContainerLogsOptions{
+			if internal.StdErrOnly {
-				Details:    true,
+				logOpts.ShowStdout = false
-				Follow:     true,
-				ShowStderr: true,
-				ShowStdout: true,
-				Tail:       "20",
-				Timestamps: true,
 			}
+
 			logs, err := client.ServiceLogs(c.Context, s, logOpts)
 			if err != nil {
 				logrus.Fatal(err)
@@ -60,6 +66,10 @@ var appLogsCommand = &cli.Command{
 	Aliases:   []string{"l"},
 	ArgsUsage: "[<service>]",
 	Usage:     "Tail app logs",
+	Flags: []cli.Flag{
+		internal.StdErrOnlyFlag,
+	},
+	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
@@ -70,55 +80,47 @@ var appLogsCommand = &cli.Command{
 
 		serviceName := c.Args().Get(1)
 		if serviceName == "" {
-			logrus.Debug("tailing logs for all app services")
+			logrus.Debugf("tailing logs for all %s services", app.Type)
 			stackLogs(c, app.StackName(), cl)
-		}
+		} else {
-		logrus.Debugf("tailing logs for '%s'", serviceName)
+			logrus.Debugf("tailing logs for %s", serviceName)
-
+			if err := tailServiceLogs(c, cl, app, serviceName); err != nil {
-		service := fmt.Sprintf("%s_%s", app.StackName(), serviceName)
+				logrus.Fatal(err)
-		filters := filters.NewArgs()
+			}
-		filters.Add("name", service)
-		serviceOpts := types.ServiceListOptions{Filters: filters}
-		services, err := cl.ServiceList(c.Context, serviceOpts)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		if len(services) != 1 {
-			logrus.Fatalf("expected 1 service but got %v", len(services))
-		}
-
-		logOpts := types.ContainerLogsOptions{
-			Details:    true,
-			Follow:     true,
-			ShowStderr: true,
-			ShowStdout: true,
-			Tail:       "20",
-			Timestamps: true,
-		}
-		logs, err := cl.ServiceLogs(c.Context, services[0].ID, logOpts)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		// defer after err check as any err returns a nil io.ReadCloser
-		defer logs.Close()
-
-		_, err = io.Copy(os.Stdout, logs)
-		if err != nil && err != io.EOF {
-			logrus.Fatal(err)
 		}
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+}
-		appNames, err := config.GetAppNames()
+
-		if err != nil {
+func tailServiceLogs(c *cli.Context, cl *dockerClient.Client, app config.App, serviceName string) error {
-			logrus.Warn(err)
+	service := fmt.Sprintf("%s_%s", app.StackName(), serviceName)
-		}
+	filters := filters.NewArgs()
-		if c.NArg() > 0 {
+	filters.Add("name", service)
-			return
+	serviceOpts := types.ServiceListOptions{Filters: filters}
-		}
+	services, err := cl.ServiceList(c.Context, serviceOpts)
-		for _, a := range appNames {
+	if err != nil {
-			fmt.Println(a)
+		logrus.Fatal(err)
-		}
+	}
-	},
+	if len(services) != 1 {
+		logrus.Fatalf("expected 1 service but got %v", len(services))
+	}
+
+	if internal.StdErrOnly {
+		logOpts.ShowStdout = false
+	}
+
+	logs, err := cl.ServiceLogs(c.Context, services[0].ID, logOpts)
+	if err != nil {
+		logrus.Fatal(err)
+	}
+	// defer after err check as any err returns a nil io.ReadCloser
+	defer logs.Close()
+
+	_, err = io.Copy(os.Stdout, logs)
+	if err != nil && err != io.EOF {
+		logrus.Fatal(err)
+	}
+
+	return nil
 }

cli/app/new.go

@@ -1,11 +1,8 @@
 package app
 
 import (
-	"fmt"
-
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/catalogue"
+	"coopcloud.tech/abra/pkg/autocomplete"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
@@ -41,18 +38,7 @@ var appNewCommand = &cli.Command{
 		internal.PassFlag,
 		internal.SecretsFlag,
 	},
-	ArgsUsage: "<recipe>",
+	ArgsUsage:    "<recipe>",
-	Action:    internal.NewAction,
+	Action:       internal.NewAction,
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.RecipeNameComplete,
-		catl, err := catalogue.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for name := range catl {
-			fmt.Println(name)
-		}
-	},
 }

cli/app/ps.go

@@ -1,14 +1,13 @@
 package app
 
 import (
-	"fmt"
 	"strings"
 	"time"
 
 	abraFormatter "coopcloud.tech/abra/cli/formatter"
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"github.com/docker/cli/cli/command/formatter"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
@@ -26,12 +25,14 @@ var watchFlag = &cli.BoolFlag{
 }
 
 var appPsCommand = &cli.Command{
-	Name:    "ps",
+	Name:        "ps",
-	Usage:   "Check app status",
+	Usage:       "Check app status",
-	Aliases: []string{"p"},
+	Description: "This command shows a more detailed status output of a specific deployed app.",
+	Aliases:     []string{"p"},
 	Flags: []cli.Flag{
 		watchFlag,
 	},
+	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		if !watch {
 			showPSOutput(c)
@@ -44,18 +45,6 @@ var appPsCommand = &cli.Command{
 			time.Sleep(2 * time.Second)
 		}
 	},
-	BashComplete: func(c *cli.Context) {
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }
 
 // showPSOutput renders ps output.
@@ -75,7 +64,7 @@ func showPSOutput(c *cli.Context) {
 		logrus.Fatal(err)
 	}
 
-	tableCol := []string{"image", "created", "status", "ports", "names"}
+	tableCol := []string{"image", "created", "status", "ports"}
 	table := abraFormatter.CreateTable(tableCol)
 
 	for _, container := range containers {
@@ -90,7 +79,6 @@ func showPSOutput(c *cli.Context) {
 			abraFormatter.HumanDuration(container.Created),
 			container.Status,
 			formatter.DisplayablePorts(container.Ports),
-			strings.Join(containerNames, "\n"),
 		}
 		table.Append(tableRow)
 	}

cli/app/remove.go

@@ -5,8 +5,9 @@ import (
 	"os"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
+	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
@@ -48,23 +49,18 @@ var appRemoveCommand = &cli.Command{
 			}
 		}
 
-		appFiles, err := config.LoadAppFiles("")
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
 		cl, err := client.New(app.Server)
 		if err != nil {
 			logrus.Fatal(err)
 		}
+
 		if !internal.Force {
-			// FIXME: only query for app we are interested in, not all of them!
+			isDeployed, _, err := stack.IsDeployed(c.Context, cl, app.StackName())
-			statuses, err := config.GetAppStatuses(appFiles)
 			if err != nil {
 				logrus.Fatal(err)
 			}
-			if statuses[app.Name]["status"] == "deployed" {
+			if isDeployed {
-				logrus.Fatalf("'%s' is still deployed. Run \"abra app %s undeploy\" or pass --force", app.Name, app.Name)
+				logrus.Fatalf("'%s' is still deployed. Run \"abra app undeploy %s \" or pass --force", app.Name, app.Name)
 			}
 		}
 
@@ -88,6 +84,8 @@ var appRemoveCommand = &cli.Command{
 			if !internal.Force {
 				secretsPrompt := &survey.MultiSelect{
 					Message: "which secrets do you want to remove?",
+					Help:    "'x' indicates selected, enter / return to confirm, ctrl-c to exit, vim mode is enabled",
+					VimMode: true,
 					Options: secretNames,
 					Default: secretNames,
 				}
@@ -124,6 +122,8 @@ var appRemoveCommand = &cli.Command{
 				if !internal.Force {
 					volumesPrompt := &survey.MultiSelect{
 						Message: "which volumes do you want to remove?",
+						Help:    "'x' indicates selected, enter / return to confirm, ctrl-c to exit, vim mode is enabled",
+						VimMode: true,
 						Options: vols,
 						Default: vols,
 					}
@@ -153,16 +153,5 @@ var appRemoveCommand = &cli.Command{
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/restart.go

@@ -6,9 +6,9 @@ import (
 	"time"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
+	containerPkg "coopcloud.tech/abra/pkg/container"
-	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
@@ -37,19 +37,16 @@ var appRestartCommand = &cli.Command{
 		serviceFilter := fmt.Sprintf("%s_%s", app.StackName(), serviceName)
 		filters := filters.NewArgs()
 		filters.Add("name", serviceFilter)
-		containerOpts := types.ContainerListOptions{Filters: filters}
+
-		containers, err := cl.ContainerList(c.Context, containerOpts)
+		targetContainer, err := containerPkg.GetContainer(c.Context, cl, filters, true)
 		if err != nil {
 			logrus.Fatal(err)
 		}
-		if len(containers) != 1 {
-			logrus.Fatalf("expected 1 service but got %v", len(containers))
-		}
 
 		logrus.Debugf("attempting to restart %s", serviceFilter)
 
 		timeout := 30 * time.Second
-		if err := cl.ContainerRestart(c.Context, containers[0].ID, &timeout); err != nil {
+		if err := cl.ContainerRestart(c.Context, targetContainer.ID, &timeout); err != nil {
 			logrus.Fatal(err)
 		}
 
@@ -57,16 +54,5 @@ var appRestartCommand = &cli.Command{
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/rollback.go

@@ -3,6 +3,7 @@ package app
 import (
 	"fmt"
 
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/catalogue"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/recipe"
@@ -38,18 +39,7 @@ Chas mode ("--chaos") will deploy your local checkout of a recipe as-is,
 including unstaged changes and can be useful for live hacking and testing new
 recipes.
 `,
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 		stackName := app.StackName()
@@ -70,7 +60,12 @@ recipes.
 			logrus.Fatalf("'%s' is not deployed?", app.Name)
 		}
 
-		versions, err := catalogue.GetRecipeCatalogueVersions(app.Type)
+		catl, err := catalogue.ReadRecipeCatalogue()
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		versions, err := catalogue.GetRecipeCatalogueVersions(app.Type, catl)
 		if err != nil {
 			logrus.Fatal(err)
 		}
@@ -98,7 +93,8 @@ recipes.
 			}
 
 			if len(availableDowngrades) == 0 {
-				logrus.Fatal("no available downgrades, you're on latest")
+				logrus.Info("no available downgrades, you're on oldest ✌️")
+				return nil
 			}
 		}
 
@@ -168,7 +164,7 @@ recipes.
 			}
 		}
 
-		if err := stack.RunDeploy(cl, deployOpts, compose); err != nil {
+		if err := stack.RunDeploy(cl, deployOpts, compose, app.Type); err != nil {
 			logrus.Fatal(err)
 		}
 

cli/app/run.go

@@ -7,6 +7,7 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
+	containerPkg "coopcloud.tech/abra/pkg/container"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
@@ -59,18 +60,11 @@ var appRunCommand = &cli.Command{
 		filters := filters.NewArgs()
 		filters.Add("name", stackAndServiceName)
 
-		containers, err := cl.ContainerList(c.Context, types.ContainerListOptions{Filters: filters})
+		targetContainer, err := containerPkg.GetContainer(c.Context, cl, filters, true)
 		if err != nil {
 			logrus.Fatal(err)
 		}
 
-		if len(containers) == 0 {
-			logrus.Fatalf("no containers matching '%s' found?", stackAndServiceName)
-		}
-		if len(containers) > 1 {
-			logrus.Fatalf("expected 1 container matching '%s' but got %d", stackAndServiceName, len(containers))
-		}
-
 		cmd := c.Args().Slice()[2:]
 		execCreateOpts := types.ExecConfig{
 			AttachStderr: true,
@@ -98,7 +92,7 @@ var appRunCommand = &cli.Command{
 			logrus.Fatal(err)
 		}
 
-		if err := container.RunExec(dcli, cl, containers[0].ID, &execCreateOpts); err != nil {
+		if err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
 			logrus.Fatal(err)
 		}
 

cli/app/secret.go

@@ -8,8 +8,8 @@ import (
 
 	abraFormatter "coopcloud.tech/abra/cli/formatter"
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/secret"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
@@ -252,18 +252,7 @@ var appSecretLsCommand = &cli.Command{
 		table.Render()
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }
 
 var appSecretCommand = &cli.Command{

cli/app/undeploy.go

@@ -1,11 +1,9 @@
 package app
 
 import (
-	"fmt"
-
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
@@ -51,16 +49,5 @@ volumes as eligiblef or pruning once undeployed.
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/upgrade.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/catalogue"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
@@ -23,6 +24,7 @@ var appUpgradeCommand = &cli.Command{
 	Flags: []cli.Flag{
 		internal.ForceFlag,
 		internal.ChaosFlag,
+		internal.NoDomainChecksFlag,
 	},
 	Description: `
 This command supports upgrading an app. You can use it to choose and roll out a
@@ -51,7 +53,7 @@ recipes.
 			logrus.Fatal(err)
 		}
 
-		logrus.Debugf("checking whether '%s' is already deployed", stackName)
+		logrus.Debugf("checking whether %s is already deployed", stackName)
 
 		isDeployed, deployedVersion, err := stack.IsDeployed(c.Context, cl, stackName)
 		if err != nil {
@@ -59,23 +61,28 @@ recipes.
 		}
 
 		if !isDeployed {
-			logrus.Fatalf("'%s' is not deployed?", app.Name)
+			logrus.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		versions, err := catalogue.GetRecipeCatalogueVersions(app.Type)
+		catl, err := catalogue.ReadRecipeCatalogue()
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		versions, err := catalogue.GetRecipeCatalogueVersions(app.Type, catl)
 		if err != nil {
 			logrus.Fatal(err)
 		}
 
 		if len(versions) == 0 && !internal.Chaos {
-			logrus.Fatalf("no versions available '%s' in recipe catalogue?", app.Type)
+			logrus.Fatalf("no published releases for %s in the recipe catalogue?", app.Type)
 		}
 
 		var availableUpgrades []string
 		if deployedVersion == "" {
 			deployedVersion = "unknown"
 			availableUpgrades = versions
-			logrus.Warnf("failed to determine version of deployed '%s'", app.Name)
+			logrus.Warnf("failed to determine version of deployed %s", app.Name)
 		}
 
 		if deployedVersion != "unknown" && !internal.Chaos {
@@ -94,8 +101,8 @@ recipes.
 			}
 
 			if len(availableUpgrades) == 0 && !internal.Force {
-				logrus.Fatal("no available upgrades, you're on latest")
+				logrus.Info("no available upgrades, you're on latest ✌️")
-				availableUpgrades = versions
+				return nil
 			}
 		}
 
@@ -103,10 +110,10 @@ recipes.
 		if len(availableUpgrades) > 0 && !internal.Chaos {
 			if internal.Force {
 				chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
-				logrus.Debugf("choosing '%s' as version to upgrade to", chosenUpgrade)
+				logrus.Debugf("choosing %s as version to upgrade to", chosenUpgrade)
 			} else {
 				prompt := &survey.Select{
-					Message: fmt.Sprintf("Please select an upgrade (current version: '%s'):", deployedVersion),
+					Message: fmt.Sprintf("Please select an upgrade (current version: %s):", deployedVersion),
 					Options: availableUpgrades,
 				}
 				if err := survey.AskOne(prompt, &chosenUpgrade); err != nil {
@@ -158,22 +165,11 @@ recipes.
 			logrus.Fatal(err)
 		}
 
-		if err := stack.RunDeploy(cl, deployOpts, compose); err != nil {
+		if err := stack.RunDeploy(cl, deployOpts, compose, app.Type); err != nil {
 			logrus.Fatal(err)
 		}
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/version.go

@@ -1,14 +1,13 @@
 package app
 
 import (
-	"fmt"
 	"strings"
 
 	abraFormatter "coopcloud.tech/abra/cli/formatter"
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/catalogue"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/docker/distribution/reference"
 	"github.com/sirupsen/logrus"
@@ -21,11 +20,14 @@ func getImagePath(image string) (string, error) {
 	if err != nil {
 		return "", err
 	}
+
 	path := reference.Path(img)
 	if strings.Contains(path, "library") {
 		path = strings.Split(path, "/")[1]
 	}
-	logrus.Debugf("parsed '%s' from '%s'", path, image)
+
+	logrus.Debugf("parsed %s from %s", path, image)
+
 	return path, nil
 }
 
@@ -47,7 +49,7 @@ Cloud recipe version.
 			logrus.Fatal(err)
 		}
 
-		logrus.Debugf("checking whether '%s' is already deployed", stackName)
+		logrus.Debugf("checking whether %s is already deployed", stackName)
 
 		isDeployed, deployedVersion, err := stack.IsDeployed(c.Context, cl, stackName)
 		if err != nil {
@@ -55,11 +57,11 @@ Cloud recipe version.
 		}
 
 		if deployedVersion == "" {
-			logrus.Fatalf("failed to determine version of deployed '%s'", app.Name)
+			logrus.Fatalf("failed to determine version of deployed %s", app.Name)
 		}
 
 		if !isDeployed {
-			logrus.Fatalf("'%s' is not deployed?", app.Name)
+			logrus.Fatalf("%s is not deployed?", app.Name)
 		}
 
 		recipeMeta, err := catalogue.GetRecipeMeta(app.Type)
@@ -75,30 +77,20 @@ Cloud recipe version.
 		}
 
 		if len(versionsMeta) == 0 {
-			logrus.Fatalf("PANIC: could not retrieve deployed version ('%s') from recipe catalogue?", deployedVersion)
+			logrus.Fatalf("could not retrieve deployed version (%s) from recipe catalogue?", deployedVersion)
 		}
 
-		tableCol := []string{"name", "image", "version", "tag", "digest"}
+		tableCol := []string{"version", "service", "image", "digest"}
 		table := abraFormatter.CreateTable(tableCol)
+		table.SetAutoMergeCellsByColumnIndex([]int{0})
 
 		for serviceName, versionMeta := range versionsMeta {
-			table.Append([]string{serviceName, versionMeta.Image, deployedVersion, versionMeta.Tag, versionMeta.Digest})
+			table.Append([]string{deployedVersion, serviceName, versionMeta.Image, versionMeta.Digest})
 		}
 
 		table.Render()
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }

cli/app/volume.go

@@ -1,21 +1,20 @@
 package app
 
 import (
-	"fmt"
-
 	abraFormatter "coopcloud.tech/abra/cli/formatter"
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
 var appVolumeListCommand = &cli.Command{
-	Name:    "list",
+	Name:         "list",
-	Usage:   "List volumes associated with an app",
+	Usage:        "List volumes associated with an app",
-	Aliases: []string{"ls"},
+	Aliases:      []string{"ls"},
+	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
@@ -42,8 +41,19 @@ var appVolumeListCommand = &cli.Command{
 }
 
 var appVolumeRemoveCommand = &cli.Command{
-	Name:    "remove",
+	Name:  "remove",
-	Usage:   "Remove volume(s) associated with an app",
+	Usage: "Remove volume(s) associated with an app",
+	Description: `
+This command supports removing volumes associated with an app. The app in
+question must be undeployed before you try to remove volumes. See "abra app
+undeploy <app>" for more.
+
+The command is interactive and will show a multiple select input which allows
+you to make a seclection. Use the "?" key to see more help on navigating this
+interface.
+
+Passing "--force" will select all volumes for removal. Be careful.
+`,
 	Aliases: []string{"rm"},
 	Flags: []cli.Flag{
 		internal.ForceFlag,
@@ -61,6 +71,8 @@ var appVolumeRemoveCommand = &cli.Command{
 		if !internal.Force {
 			volumesPrompt := &survey.MultiSelect{
 				Message: "which volumes do you want to remove?",
+				Help:    "'x' indicates selected, enter / return to confirm, ctrl-c to exit, vim mode is enabled",
+				VimMode: true,
 				Options: volumeNames,
 				Default: volumeNames,
 			}
@@ -80,18 +92,7 @@ var appVolumeRemoveCommand = &cli.Command{
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.AppNameComplete,
-		appNames, err := config.GetAppNames()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for _, a := range appNames {
-			fmt.Println(a)
-		}
-	},
 }
 
 var appVolumeCommand = &cli.Command{

cli/autocomplete.go

@@ -3,43 +3,16 @@ package cli
 import (
 	"errors"
 	"fmt"
-	"io"
-	"net/http"
 	"os"
 	"path"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/web"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
-// downloadFile downloads a file brah
-func downloadFile(filepath string, url string) (err error) {
-	out, err := os.Create(filepath)
-	if err != nil {
-		return err
-	}
-	defer out.Close()
-
-	resp, err := http.Get(url)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("bad status: %s", resp.Status)
-	}
-
-	_, err = io.Copy(out, resp.Body)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
 // AutoCompleteCommand helps people set up auto-complete in their shells
 var AutoCompleteCommand = &cli.Command{
 	Name:    "autocomplete",
@@ -56,9 +29,10 @@ Example:
 
 Supported shells are as follows:
 
-		fish
+		fizsh
 		zsh
     bash
+
 `,
 	ArgsUsage: "<shell>",
 	Action: func(c *cli.Context) error {
@@ -69,32 +43,32 @@ Supported shells are as follows:
 		}
 
 		supportedShells := map[string]bool{
-			"bash": true,
+			"bash":  true,
-			"zsh":  true,
+			"zsh":   true,
-			"fish": true,
+			"fizsh": true,
 		}
 
 		if _, ok := supportedShells[shellType]; !ok {
 			logrus.Fatalf("%s is not a supported shell right now, sorry", shellType)
 		}
 
-		if shellType == "fish" {
+		if shellType == "fizsh" {
 			shellType = "zsh" // handled the same on the autocompletion side
 		}
 
 		autocompletionDir := path.Join(config.ABRA_DIR, "autocompletion")
-		if err := os.Mkdir(autocompletionDir, 0755); err != nil {
+		if err := os.Mkdir(autocompletionDir, 0764); err != nil {
 			if !os.IsExist(err) {
 				logrus.Fatal(err)
 			}
-			logrus.Debugf("'%s' already created, moving on...", autocompletionDir)
+			logrus.Debugf("%s already created", autocompletionDir)
 		}
 
 		autocompletionFile := path.Join(config.ABRA_DIR, "autocompletion", shellType)
 		if _, err := os.Stat(autocompletionFile); err != nil && os.IsNotExist(err) {
 			url := fmt.Sprintf("https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/autocomplete/%s", shellType)
 			logrus.Infof("fetching %s", url)
-			if err := downloadFile(autocompletionFile, url); err != nil {
+			if err := web.GetFile(autocompletionFile, url); err != nil {
 				logrus.Fatal(err)
 			}
 		}
@@ -103,9 +77,10 @@ Supported shells are as follows:
 		case "bash":
 			fmt.Println(fmt.Sprintf(`
 # Run the following commands to install autocompletion
-sudo mkdir /etc/bash/completion.d/
+sudo mkdir /etc/bash_completion.d/
 sudo cp %s /etc/bash_completion.d/abra
-echo "source /etc/bash/completion.d/abra" >> ~/.bashrc
+echo "source /etc/bash_completion.d/abra" >> ~/.bashrc
+# And finally run "abra app ps <hit tab key>" to test things are working, you should see app names listed!
 `, autocompletionFile))
 		case "zsh":
 			fmt.Println(fmt.Sprintf(`
@@ -113,6 +88,7 @@ echo "source /etc/bash/completion.d/abra" >> ~/.bashrc
 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
+# And finally run "abra app ps <hit tab key>" to test things are working, you should see app names listed!
 `, autocompletionFile))
 		}
 

cli/catalogue/catalogue.go

@@ -1,13 +1,255 @@
 package catalogue
 
 import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+
+	"coopcloud.tech/abra/cli/formatter"
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
+	"coopcloud.tech/abra/pkg/catalogue"
+	"coopcloud.tech/abra/pkg/config"
+	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/limit"
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
+// CatalogueSkipList is all the repos that are not recipes.
+var CatalogueSkipList = map[string]bool{
+	"abra":                  true,
+	"abra-apps":             true,
+	"abra-aur":              true,
+	"abra-bash":             true,
+	"abra-capsul":           true,
+	"abra-gandi":            true,
+	"abra-hetzner":          true,
+	"apps":                  true,
+	"aur-abra-git":          true,
+	"auto-apps-json":        true,
+	"auto-mirror":           true,
+	"backup-bot":            true,
+	"backup-bot-two":        true,
+	"comrade-renovate-bot":  true,
+	"coopcloud.tech":        true,
+	"coturn":                true,
+	"docker-cp-deploy":      true,
+	"docker-dind-bats-kcov": true,
+	"docs.coopcloud.tech":   true,
+	"drone-abra":            true,
+	"example":               true,
+	"gardening":             true,
+	"go-abra":               true,
+	"organising":            true,
+	"outline-with-patch":    true,
+	"pyabra":                true,
+	"radicle-seed-node":     true,
+	"recipes":               true,
+	"stack-ssh-deploy":      true,
+	"swarm-cronjob":         true,
+	"tagcmp":                true,
+	"traefik-cert-dumper":   true,
+	"tyop":                  true,
+}
+
+var catalogueGenerateCommand = &cli.Command{
+	Name:    "generate",
+	Aliases: []string{"g"},
+	Usage:   "Generate a new copy of the catalogue",
+	Flags: []cli.Flag{
+		internal.PushFlag,
+		internal.CommitFlag,
+		internal.CommitMessageFlag,
+		internal.DryFlag,
+	},
+	Description: `
+This command generates a new copy of the recipe catalogue which can be found on:
+
+    https://recipes.coopcloud.tech
+
+It polls the entire git.coopcloud.tech/coop-cloud/... recipe repository
+listing, parses README and tags to produce recipe metadata and produces a
+apps.json file which is placed in your ~/.abra/catalogue/recipes.json.
+
+It is possible to generate new metadata for a single recipe by passing
+<recipe>. The existing local catalogue will be updated, not overwritten.
+
+A new catalogue copy can be published to the recipes repository by passing the
+"--commit" and "--push" flags. The recipes repository is available here:
+
+    https://git.coopcloud.tech/coop-cloud/recipes
+
+`,
+	ArgsUsage: "[<recipe>]",
+	Action: func(c *cli.Context) error {
+		recipeName := c.Args().First()
+		if recipeName != "" {
+			internal.ValidateRecipe(c)
+		}
+
+		catalogueDir := path.Join(config.ABRA_DIR, "catalogue")
+		url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, "recipes")
+		if err := gitPkg.Clone(catalogueDir, url); err != nil {
+			return err
+		}
+
+		repos, err := catalogue.ReadReposMetadata()
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		logrus.Debugf("ensuring '%v' recipe(s) are locally present and up-to-date", len(repos))
+
+		var barLength int
+		if recipeName != "" {
+			barLength = 1
+		} else {
+			barLength = len(repos)
+		}
+
+		cloneLimiter := limit.New(10)
+		retrieveBar := formatter.CreateProgressbar(len(repos), "retrieving recipes from recipes.coopcloud.tech...")
+		ch := make(chan string, barLength)
+		for _, repoMeta := range repos {
+			go func(rm catalogue.RepoMeta) {
+				cloneLimiter.Begin()
+				defer cloneLimiter.End()
+
+				if recipeName != "" && recipeName != rm.Name {
+					ch <- rm.Name
+					retrieveBar.Add(1)
+					return
+				}
+				if _, exists := CatalogueSkipList[rm.Name]; exists {
+					ch <- rm.Name
+					retrieveBar.Add(1)
+					return
+				}
+
+				recipeDir := path.Join(config.ABRA_DIR, "apps", rm.Name)
+
+				if err := gitPkg.Clone(recipeDir, rm.SSHURL); err != nil {
+					logrus.Fatal(err)
+				}
+
+				isClean, err := gitPkg.IsClean(rm.Name)
+				if err != nil {
+					logrus.Fatal(err)
+				}
+
+				if !isClean {
+					logrus.Fatalf("'%s' has locally unstaged changes", rm.Name)
+				}
+
+				if err := gitPkg.EnsureUpToDate(recipeDir); err != nil {
+					logrus.Fatal(err)
+				}
+
+				ch <- rm.Name
+				retrieveBar.Add(1)
+			}(repoMeta)
+		}
+
+		for range repos {
+			<-ch // wait for everything
+		}
+
+		catl := make(catalogue.RecipeCatalogue)
+		catlBar := formatter.CreateProgressbar(barLength, "generating catalogue metadata...")
+		for _, recipeMeta := range repos {
+			if recipeName != "" && recipeName != recipeMeta.Name {
+				catlBar.Add(1)
+				continue
+			}
+
+			if _, exists := CatalogueSkipList[recipeMeta.Name]; exists {
+				catlBar.Add(1)
+				continue
+			}
+
+			versions, err := catalogue.GetRecipeVersions(recipeMeta.Name)
+			if err != nil {
+				logrus.Fatal(err)
+			}
+
+			features, category, err := catalogue.GetRecipeFeaturesAndCategory(recipeMeta.Name)
+			if err != nil {
+				logrus.Warn(err)
+			}
+
+			catl[recipeMeta.Name] = catalogue.RecipeMeta{
+				Name:          recipeMeta.Name,
+				Repository:    recipeMeta.CloneURL,
+				Icon:          recipeMeta.AvatarURL,
+				DefaultBranch: recipeMeta.DefaultBranch,
+				Description:   recipeMeta.Description,
+				Website:       recipeMeta.Website,
+				Versions:      versions,
+				Category:      category,
+				Features:      features,
+			}
+			catlBar.Add(1)
+		}
+
+		recipesJSON, err := json.MarshalIndent(catl, "", "    ")
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		if _, err := os.Stat(config.APPS_JSON); err != nil && os.IsNotExist(err) {
+			if err := ioutil.WriteFile(config.APPS_JSON, recipesJSON, 0764); err != nil {
+				logrus.Fatal(err)
+			}
+		} else {
+			if recipeName != "" {
+				catlFS, err := catalogue.ReadRecipeCatalogue()
+				if err != nil {
+					logrus.Fatal(err)
+				}
+				catlFS[recipeName] = catl[recipeName]
+
+				updatedRecipesJSON, err := json.MarshalIndent(catlFS, "", "    ")
+				if err != nil {
+					logrus.Fatal(err)
+				}
+				if err := ioutil.WriteFile(config.APPS_JSON, updatedRecipesJSON, 0764); err != nil {
+					logrus.Fatal(err)
+				}
+			}
+		}
+
+		logrus.Infof("generated new recipe catalogue in %s", config.APPS_JSON)
+
+		if internal.Commit {
+			if internal.CommitMessage == "" && !internal.NoInput {
+				prompt := &survey.Input{
+					Message: "commit message",
+					Default: fmt.Sprintf("chore: publish catalogue changes"),
+				}
+				if err := survey.AskOne(prompt, &internal.CommitMessage); err != nil {
+					logrus.Fatal(err)
+				}
+			}
+
+			cataloguePath := path.Join(config.ABRA_DIR, "catalogue")
+			if err := gitPkg.Commit(cataloguePath, "**.json", internal.CommitMessage, internal.Dry, internal.Push); err != nil {
+				logrus.Fatal(err)
+			}
+		}
+
+		return nil
+	},
+	BashComplete: autocomplete.RecipeNameComplete,
+}
+
 // CatalogueCommand defines the `abra catalogue` command and sub-commands.
 var CatalogueCommand = &cli.Command{
 	Name:        "catalogue",
-	Usage:       "Manage the recipe catalogue (for maintainers)",
+	Usage:       "Manage the recipe catalogue",
 	Aliases:     []string{"c"},
 	ArgsUsage:   "<recipe>",
 	Description: "This command helps recipe packagers interact with the recipe catalogue",

cli/catalogue/generate.go

@@ -1,262 +0,0 @@
-package catalogue
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-
-	"coopcloud.tech/abra/cli/formatter"
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/catalogue"
-	"coopcloud.tech/abra/pkg/config"
-	gitPkg "coopcloud.tech/abra/pkg/git"
-	"coopcloud.tech/abra/pkg/limit"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli/v2"
-)
-
-// CatalogueSkipList is all the repos that are not recipes.
-var CatalogueSkipList = map[string]bool{
-	"abra":                  true,
-	"abra-apps":             true,
-	"abra-aur":              true,
-	"abra-bash":             true,
-	"abra-capsul":           true,
-	"abra-gandi":            true,
-	"abra-hetzner":          true,
-	"apps":                  true,
-	"aur-abra-git":          true,
-	"auto-apps-json":        true,
-	"auto-mirror":           true,
-	"backup-bot":            true,
-	"backup-bot-two":        true,
-	"comrade-renovate-bot":  true,
-	"coopcloud.tech":        true,
-	"coturn":                true,
-	"docker-cp-deploy":      true,
-	"docker-dind-bats-kcov": true,
-	"docs.coopcloud.tech":   true,
-	"example":               true,
-	"gardening":             true,
-	"go-abra":               true,
-	"organising":            true,
-	"pyabra":                true,
-	"radicle-seed-node":     true,
-	"stack-ssh-deploy":      true,
-	"swarm-cronjob":         true,
-	"tagcmp":                true,
-	"tyop":                  true,
-}
-
-var commit bool
-var commitFlag = &cli.BoolFlag{
-	Name:        "commit",
-	Usage:       "Commits new generated catalogue changes",
-	Value:       false,
-	Aliases:     []string{"c"},
-	Destination: &commit,
-}
-
-var catalogueGenerateCommand = &cli.Command{
-	Name:    "generate",
-	Aliases: []string{"g"},
-	Usage:   "Generate a new copy of the catalogue",
-	Flags: []cli.Flag{
-		internal.PushFlag,
-		commitFlag,
-		internal.CommitMessageFlag,
-	},
-	Description: `
-This command generates a new copy of the recipe catalogue which can be found on:
-
-    https://recipes.coopcloud.tech
-
-It polls the entire git.coopcloud.tech/coop-cloud/... recipe repository
-listing, parses README and tags to produce recipe metadata and produces a
-apps.json file which is placed in your ~/.abra/catalogue/recipes.json.
-
-It is possible to generate new metadata for a single recipe by passing
-<recipe>. The existing local catalogue will be updated, not overwritten.
-
-A new catalogue copy can be published to the recipes repository by passing the
-"--commit" and "--push" flags. The recipes repository is available here:
-
-    https://git.coopcloud.tech/coop-cloud/recipes
-
-`,
-	ArgsUsage: "[<recipe>]",
-	Action: func(c *cli.Context) error {
-		recipeName := c.Args().First()
-
-		catalogueDir := path.Join(config.ABRA_DIR, "catalogue")
-		url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, "recipes")
-		if err := gitPkg.Clone(catalogueDir, url); err != nil {
-			return err
-		}
-
-		repos, err := catalogue.ReadReposMetadata()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("ensuring '%v' recipe(s) are locally present and up-to-date", len(repos))
-
-		cloneLimiter := limit.New(10)
-		retrieveBar := formatter.CreateProgressbar(len(repos), "retrieving recipes...")
-		ch := make(chan string, len(repos))
-		for _, repoMeta := range repos {
-			go func(rm catalogue.RepoMeta) {
-				cloneLimiter.Begin()
-				defer cloneLimiter.End()
-
-				if recipeName != "" && recipeName != rm.Name {
-					ch <- rm.Name
-					retrieveBar.Add(1)
-					return
-				}
-				if _, exists := CatalogueSkipList[rm.Name]; exists {
-					ch <- rm.Name
-					retrieveBar.Add(1)
-					return
-				}
-
-				recipeDir := path.Join(config.ABRA_DIR, "apps", rm.Name)
-
-				if err := gitPkg.Clone(recipeDir, rm.SSHURL); err != nil {
-					logrus.Fatal(err)
-				}
-
-				if err := gitPkg.EnsureUpToDate(recipeDir); err != nil {
-					logrus.Fatal(err)
-				}
-
-				ch <- rm.Name
-				retrieveBar.Add(1)
-			}(repoMeta)
-		}
-
-		for range repos {
-			<-ch // wait for everything
-		}
-
-		catl := make(catalogue.RecipeCatalogue)
-		catlBar := formatter.CreateProgressbar(len(repos), "generating catalogue...")
-		for _, recipeMeta := range repos {
-			if recipeName != "" && recipeName != recipeMeta.Name {
-				catlBar.Add(1)
-				continue
-			}
-
-			if _, exists := CatalogueSkipList[recipeMeta.Name]; exists {
-				catlBar.Add(1)
-				continue
-			}
-
-			versions, err := catalogue.GetRecipeVersions(recipeMeta.Name)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			catl[recipeMeta.Name] = catalogue.RecipeMeta{
-				Name:          recipeMeta.Name,
-				Repository:    recipeMeta.CloneURL,
-				Icon:          recipeMeta.AvatarURL,
-				DefaultBranch: recipeMeta.DefaultBranch,
-				Description:   recipeMeta.Description,
-				Website:       recipeMeta.Website,
-				Versions:      versions,
-				// Category:      ..., // FIXME: parse & load
-				// Features:      ..., // FIXME: parse & load
-			}
-			catlBar.Add(1)
-		}
-
-		recipesJSON, err := json.MarshalIndent(catl, "", "    ")
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if _, err := os.Stat(config.APPS_JSON); err != nil && os.IsNotExist(err) {
-			if err := ioutil.WriteFile(config.APPS_JSON, recipesJSON, 0644); err != nil {
-				logrus.Fatal(err)
-			}
-		} else {
-			if recipeName != "" {
-				catlFS, err := catalogue.ReadRecipeCatalogue()
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				catlFS[recipeName] = catl[recipeName]
-
-				updatedRecipesJSON, err := json.MarshalIndent(catlFS, "", "    ")
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				if err := ioutil.WriteFile(config.APPS_JSON, updatedRecipesJSON, 0644); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-		}
-
-		cataloguePath := path.Join(config.ABRA_DIR, "catalogue", "recipes.json")
-		logrus.Infof("generated new recipe catalogue in %s", cataloguePath)
-
-		if commit {
-			repoPath := path.Join(config.ABRA_DIR, "catalogue")
-			commitRepo, err := git.PlainOpen(repoPath)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			commitWorktree, err := commitRepo.Worktree()
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if internal.CommitMessage == "" {
-				prompt := &survey.Input{
-					Message: "commit message",
-					Default: "chore: publish new catalogue changes",
-				}
-				if err := survey.AskOne(prompt, &internal.CommitMessage); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			err = commitWorktree.AddGlob("**.json")
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			logrus.Debug("staged **.json for commit")
-
-			_, err = commitWorktree.Commit(internal.CommitMessage, &git.CommitOptions{})
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			logrus.Info("changes commited")
-
-			if err := commitRepo.Push(&git.PushOptions{}); err != nil {
-				logrus.Fatal(err)
-			}
-			logrus.Info("changes pushed")
-		}
-
-		return nil
-	},
-	BashComplete: func(c *cli.Context) {
-		catl, err := catalogue.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for name := range catl {
-			fmt.Println(name)
-		}
-	},
-}

cli/cli.go

@@ -18,29 +18,19 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
-// Verbose stores the variable from VerboseFlag.
-var Verbose bool
-
-// VerboseFlag turns on/off verbose logging down to the INFO level.
-var VerboseFlag = &cli.BoolFlag{
-	Name:        "verbose",
-	Aliases:     []string{"V"},
-	Value:       false,
-	Destination: &Verbose,
-	Usage:       "Show INFO messages",
-}
-
 func newAbraApp(version, commit string) *cli.App {
 	app := &cli.App{
 		Name: "abra",
 		Usage: `The Co-op Cloud command-line utility belt 🎩🐇
-
     ____                           ____ _                 _
    / ___|___         ___  _ __    / ___| | ___  _   _  __| |
   | |   / _ \ _____ / _ \| '_ \  | |   | |/ _ \| | | |/ _' |
   | |__| (_) |_____| (_) | |_) | | |___| | (_) | |_| | (_| |
    \____\___/       \___/| .__/   \____|_|\___/ \__,_|\__,_|
                          |_|
+
+If you haven't already done so, consider setting up autocompletion for a more
+convenient command-line experience. See "abra autocomplete -h" for more.
 		`,
 		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
 		Commands: []*cli.Command{
@@ -53,11 +43,14 @@ func newAbraApp(version, commit string) *cli.App {
 			AutoCompleteCommand,
 		},
 		Flags: []cli.Flag{
-			VerboseFlag,
+			internal.VerboseFlag,
 			internal.DebugFlag,
 			internal.NoInputFlag,
 		},
 		Authors: []*cli.Author{
+			// If you're looking at this and you hack on Abra and you're not listed
+			// here, please do add yourself! This is a community project, let's show
+			// some love
 			{Name: "3wordchant"},
 			{Name: "decentral1se"},
 			{Name: "knoflook"},
@@ -83,14 +76,12 @@ func newAbraApp(version, commit string) *cli.App {
 		}
 
 		for _, path := range paths {
-			if err := os.Mkdir(path, 0755); err != nil {
+			if err := os.Mkdir(path, 0764); err != nil {
 				if !os.IsExist(err) {
 					logrus.Fatal(err)
 				}
-				logrus.Debugf("'%s' already created, moving on...", path)
 				continue
 			}
-			logrus.Debugf("'%s' is missing, creating...", path)
 		}
 
 		logrus.Debugf("abra version '%s', commit '%s'", version, commit)

cli/internal/common.go

@@ -271,3 +271,199 @@ var DebugFlag = &cli.BoolFlag{
 	Destination: &Debug,
 	Usage:       "Show DEBUG messages",
 }
+
+// Verbose stores the variable from VerboseFlag.
+var Verbose bool
+
+// VerboseFlag turns on/off verbose logging down to the INFO level.
+var VerboseFlag = &cli.BoolFlag{
+	Name:        "verbose",
+	Aliases:     []string{"V"},
+	Value:       false,
+	Destination: &Verbose,
+	Usage:       "Show INFO messages",
+}
+
+// RC signifies the latest release candidate
+var RC bool
+
+// RCFlag chooses the latest release candidate for install
+var RCFlag = &cli.BoolFlag{
+	Name:        "rc",
+	Value:       false,
+	Destination: &RC,
+	Usage:       "Insatll the latest release candidate",
+}
+
+var Major bool
+var MajorFlag = &cli.BoolFlag{
+	Name:        "major",
+	Usage:       "Increase the major part of the version",
+	Value:       false,
+	Aliases:     []string{"ma", "x"},
+	Destination: &Major,
+}
+
+var Minor bool
+var MinorFlag = &cli.BoolFlag{
+	Name:        "minor",
+	Usage:       "Increase the minor part of the version",
+	Value:       false,
+	Aliases:     []string{"mi", "y"},
+	Destination: &Minor,
+}
+
+var Patch bool
+var PatchFlag = &cli.BoolFlag{
+	Name:        "patch",
+	Usage:       "Increase the patch part of the version",
+	Value:       false,
+	Aliases:     []string{"p", "z"},
+	Destination: &Patch,
+}
+
+var Dry bool
+var DryFlag = &cli.BoolFlag{
+	Name:        "dry-run",
+	Usage:       "Only reports changes that would be made",
+	Value:       false,
+	Aliases:     []string{"d"},
+	Destination: &Dry,
+}
+
+var Push bool
+var PushFlag = &cli.BoolFlag{
+	Name:        "push",
+	Usage:       "Git push changes",
+	Value:       false,
+	Aliases:     []string{"P"},
+	Destination: &Push,
+}
+
+var CommitMessage string
+var CommitMessageFlag = &cli.StringFlag{
+	Name:        "commit-message",
+	Usage:       "Commit message (implies --commit)",
+	Aliases:     []string{"cm"},
+	Destination: &CommitMessage,
+}
+
+var Commit bool
+var CommitFlag = &cli.BoolFlag{
+	Name:        "commit",
+	Usage:       "Commit new changes",
+	Value:       false,
+	Aliases:     []string{"c"},
+	Destination: &Commit,
+}
+
+var TagMessage string
+var TagMessageFlag = &cli.StringFlag{
+	Name:        "tag-comment",
+	Usage:       "Description for release tag",
+	Aliases:     []string{"t", "tm"},
+	Destination: &TagMessage,
+}
+
+var Domain string
+var DomainFlag = &cli.StringFlag{
+	Name:        "domain",
+	Aliases:     []string{"d"},
+	Value:       "",
+	Usage:       "Choose a domain name",
+	Destination: &Domain,
+}
+
+var NewAppServer string
+var NewAppServerFlag = &cli.StringFlag{
+	Name:        "server",
+	Aliases:     []string{"s"},
+	Value:       "",
+	Usage:       "Show apps of a specific server",
+	Destination: &NewAppServer,
+}
+
+var NewAppName string
+var NewAppNameFlag = &cli.StringFlag{
+	Name:        "app-name",
+	Aliases:     []string{"a"},
+	Value:       "",
+	Usage:       "Choose an app name",
+	Destination: &NewAppName,
+}
+
+var NoDomainChecks bool
+var NoDomainChecksFlag = &cli.BoolFlag{
+	Name:        "no-domain-checks",
+	Aliases:     []string{"nd"},
+	Value:       false,
+	Usage:       "Disable app domain sanity checks",
+	Destination: &NoDomainChecks,
+}
+
+var StdErrOnly bool
+var StdErrOnlyFlag = &cli.BoolFlag{
+	Name:        "stderr",
+	Aliases:     []string{"s"},
+	Value:       false,
+	Usage:       "Only tail stderr",
+	Destination: &StdErrOnly,
+}
+
+var AutoDNSRecord bool
+var AutoDNSRecordFlag = &cli.BoolFlag{
+	Name:        "auto",
+	Aliases:     []string{"a"},
+	Value:       false,
+	Usage:       "Automatically configure DNS records",
+	Destination: &StdErrOnly,
+}
+
+// SSHFailMsg is a hopefully helpful SSH failure message
+var SSHFailMsg = `
+Woops, Abra is unable to connect to connect to %s.
+
+Here are a few tips for debugging your local SSH config. Abra uses plain 'ol
+SSH to make connections to servers, so if your SSH config is working, Abra is
+working.
+
+In the first place, Abra will always try to read your Docker context connection
+string for SSH connection details. You can view your server context configs
+with the following command. Are they correct?
+
+    abra server ls
+
+Is your ssh-agent running? You can start it by running the following command:
+
+    eval "$(ssh-agent)"
+
+If your SSH private key loaded? You can check by running the following command:
+
+    ssh-add -L
+
+If, you can add it with:
+
+    ssh-add ~/.ssh/<private-key-part>
+
+If you are using a non-default public/private key, you can configure this in
+your ~/.ssh/config file which Abra will read in order to figure out connection
+details:
+
+Host foo.coopcloud.tech
+  Hostname foo.coopcloud.tech
+  User bar
+  Port 12345
+  IdentityFile ~/.ssh/bar@foo.coopcloud.tech
+
+If you're only using password authentication, you can use the following config:
+
+Host foo.coopcloud.tech
+  Hostname foo.coopcloud.tech
+  User bar
+  Port 12345
+  PreferredAuthentications=password
+  PubkeyAuthentication=no
+
+Good luck!
+
+`

cli/internal/copy.go

@@ -7,6 +7,7 @@ import (
 	"coopcloud.tech/abra/cli/formatter"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/container"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/pkg/archive"
@@ -32,21 +33,17 @@ func ConfigureAndCp(c *cli.Context, app config.App, srcPath string, dstPath stri
 
 	filters := filters.NewArgs()
 	filters.Add("name", fmt.Sprintf("%s_%s", appEnv.StackName(), service))
-	containers, err := cl.ContainerList(c.Context, types.ContainerListOptions{Filters: filters})
+
+	container, err := container.GetContainer(c.Context, cl, filters, true)
 	if err != nil {
 		logrus.Fatal(err)
 	}
 
-	if len(containers) != 1 {
+	logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(container.ID), app.Server)
-		logrus.Fatalf("expected 1 container but got %v", len(containers))
-	}
-	container := containers[0]
-
-	logrus.Debugf("retrieved '%s' as target container on '%s'", formatter.ShortenID(container.ID), app.Server)
 
 	if isToContainer {
 		if _, err := os.Stat(srcPath); err != nil {
-			logrus.Fatalf("'%s' does not exist?", srcPath)
+			logrus.Fatalf("%s does not exist?", srcPath)
 		}
 
 		toTarOpts := &archive.TarOptions{NoOverwriteDirNonDir: true, Compression: archive.Gzip}

cli/internal/deploy.go

@@ -26,7 +26,7 @@ func DeployAction(c *cli.Context) error {
 		logrus.Fatal(err)
 	}
 
-	logrus.Debugf("checking whether '%s' is already deployed", stackName)
+	logrus.Debugf("checking whether %s is already deployed", stackName)
 
 	isDeployed, deployedVersion, err := stack.IsDeployed(c.Context, cl, stackName)
 	if err != nil {
@@ -34,24 +34,26 @@ func DeployAction(c *cli.Context) error {
 	}
 
 	if isDeployed {
-		if Force {
+		if Force || Chaos {
-			logrus.Warnf("'%s' already deployed but continuing (--force)", stackName)
+			logrus.Warnf("%s is already deployed but continuing (--force/--chaos)", stackName)
-		} else if Chaos {
-			logrus.Warnf("'%s' already deployed but continuing (--chaos)", stackName)
 		} else {
-			logrus.Fatalf("'%s' is already deployed", stackName)
+			logrus.Fatalf("%s is already deployed", stackName)
 		}
 	}
 
 	version := deployedVersion
 	if version == "" && !Chaos {
-		versions, err := catalogue.GetRecipeCatalogueVersions(app.Type)
+		catl, err := catalogue.ReadRecipeCatalogue()
+		if err != nil {
+			logrus.Fatal(err)
+		}
+		versions, err := catalogue.GetRecipeCatalogueVersions(app.Type, catl)
 		if err != nil {
 			logrus.Fatal(err)
 		}
 		if len(versions) > 0 {
 			version = versions[len(versions)-1]
-			logrus.Debugf("choosing '%s' as version to deploy", version)
+			logrus.Debugf("choosing %s as version to deploy", version)
 			if err := recipe.EnsureVersion(app.Type, version); err != nil {
 				logrus.Fatal(err)
 			}
@@ -65,7 +67,13 @@ func DeployAction(c *cli.Context) error {
 	}
 
 	if version == "" && !Chaos {
-		logrus.Debugf("choosing '%s' as version to deploy", version)
+		logrus.Debugf("choosing %s as version to deploy", version)
+		if err := recipe.EnsureVersion(app.Type, version); err != nil {
+			logrus.Fatal(err)
+		}
+	}
+
+	if version != "" && !Chaos {
 		if err := recipe.EnsureVersion(app.Type, version); err != nil {
 			logrus.Fatal(err)
 		}
@@ -108,17 +116,21 @@ func DeployAction(c *cli.Context) error {
 		logrus.Fatal(err)
 	}
 
-	domainName := app.Env["DOMAIN"]
+	if !NoDomainChecks {
-	ipv4, err := dns.EnsureIPv4(domainName)
+		domainName := app.Env["DOMAIN"]
-	if err != nil || ipv4 == "" {
+		ipv4, err := dns.EnsureIPv4(domainName)
-		logrus.Fatalf("could not find an IP address assigned to %s?", domainName)
+		if err != nil || ipv4 == "" {
+			logrus.Fatalf("could not find an IP address assigned to %s?", domainName)
+		}
+
+		if _, err = dns.EnsureDomainsResolveSameIPv4(domainName, app.Server); err != nil {
+			logrus.Fatal(err)
+		}
+	} else {
+		logrus.Warn("skipping domain checks as requested")
 	}
 
-	if _, err = dns.EnsureDomainsResolveSameIPv4(domainName, app.Server); err != nil {
+	if err := stack.RunDeploy(cl, deployOpts, compose, app.Env["TYPE"]); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := stack.RunDeploy(cl, deployOpts, compose); err != nil {
 		logrus.Fatal(err)
 	}
 

cli/internal/errors_test.go

@@ -1,38 +0,0 @@
-package internal
-
-import (
-	"github.com/urfave/cli/v2"
-)
-
-// Testing functions that call os.Exit
-// https://stackoverflow.com/questions/26225513/how-to-test-os-exit-scenarios-in-go
-// https://talks.golang.org/2014/testing.slide#23
-
-var testapp = &cli.App{
-	Name:  "abra",
-	Usage: `The Co-op Cloud command-line utility belt 🎩🐇`,
-}
-
-// not testing output as that changes. just if it exits with code 1
-// does not work because of some weird errors on cli's part. Its a hard lib to test effectively.
-// func TestShowSubcommandHelpAndError(t *testing.T) {
-// 	if os.Getenv("HelpAndError") == "1" {
-// 		ShowSubcommandHelpAndError(cli.NewContext(testapp, nil, nil), errors.New("Test error"))
-// 		return
-// 	}
-// 	cmd := exec.Command(os.Args[0], "-test.run=TestShowSubcommandHelpAndError")
-// 	cmd.Env = append(os.Environ(), "HelpAndError=1")
-// 	var out bytes.Buffer
-// 	cmd.Stderr = &out
-// 	err := cmd.Run()
-// 	println(out.String())
-// 	if !strings.Contains(out.String(), "Test error") {
-
-// 		t.Fatalf("expected command to show the error causing the exit, did not get correct stdout output")
-// 	}
-
-// 	if e, ok := err.(*exec.ExitError); ok && !e.Success() {
-// 		return
-// 	}
-// 	t.Fatalf("process ran with err %v, want exit status 1", err)
-// }

cli/internal/new.go

@@ -14,35 +14,9 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
+// AppSecrets represents all app secrest
 type AppSecrets map[string]string
 
-var Domain string
-var DomainFlag = &cli.StringFlag{
-	Name:        "domain",
-	Aliases:     []string{"d"},
-	Value:       "",
-	Usage:       "Choose a domain name",
-	Destination: &Domain,
-}
-
-var NewAppServer string
-var NewAppServerFlag = &cli.StringFlag{
-	Name:        "server",
-	Aliases:     []string{"s"},
-	Value:       "",
-	Usage:       "Show apps of a specific server",
-	Destination: &NewAppServer,
-}
-
-var NewAppName string
-var NewAppNameFlag = &cli.StringFlag{
-	Name:        "app-name",
-	Aliases:     []string{"a"},
-	Value:       "",
-	Usage:       "Choose an app name",
-	Destination: &NewAppName,
-}
-
 // RecipeName is used for configuring recipe name programmatically
 var RecipeName string
 
@@ -155,11 +129,11 @@ func NewAction(c *cli.Context) error {
 
 	sanitisedAppName := config.SanitiseAppName(NewAppName)
 	if len(sanitisedAppName) > 45 {
-		logrus.Fatalf("'%s' cannot be longer than 45 characters", sanitisedAppName)
+		logrus.Fatalf("%s cannot be longer than 45 characters", sanitisedAppName)
 	}
-	logrus.Debugf("'%s' sanitised as '%s' for new app", NewAppName, sanitisedAppName)
+	logrus.Debugf("%s sanitised as %s for new app", NewAppName, sanitisedAppName)
 
-	if err := config.TemplateAppEnvSample(recipe.Name, NewAppName, NewAppServer, Domain, recipe.Name); err != nil {
+	if err := config.TemplateAppEnvSample(recipe.Name, NewAppName, NewAppServer, Domain); err != nil {
 		logrus.Fatal(err)
 	}
 

cli/internal/recipe.go

@@ -7,99 +7,30 @@ import (
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli/v2"
 )
 
-var Major bool
-var MajorFlag = &cli.BoolFlag{
-	Name:        "major",
-	Usage:       "Increase the major part of the version",
-	Value:       false,
-	Aliases:     []string{"ma", "x"},
-	Destination: &Major,
-}
-
-var Minor bool
-var MinorFlag = &cli.BoolFlag{
-	Name:        "minor",
-	Usage:       "Increase the minor part of the version",
-	Value:       false,
-	Aliases:     []string{"mi", "y"},
-	Destination: &Minor,
-}
-
-var Patch bool
-var PatchFlag = &cli.BoolFlag{
-	Name:        "patch",
-	Usage:       "Increase the patch part of the version",
-	Value:       false,
-	Aliases:     []string{"p", "z"},
-	Destination: &Patch,
-}
-
-var Dry bool
-var DryFlag = &cli.BoolFlag{
-	Name:        "dry-run",
-	Usage:       "No changes are made, only reports changes that would be made",
-	Value:       false,
-	Aliases:     []string{"d"},
-	Destination: &Dry,
-}
-
-var Push bool
-var PushFlag = &cli.BoolFlag{
-	Name:        "push",
-	Usage:       "Git push changes",
-	Value:       false,
-	Aliases:     []string{"P"},
-	Destination: &Push,
-}
-
-var CommitMessage string
-var CommitMessageFlag = &cli.StringFlag{
-	Name:        "commit-message",
-	Usage:       "Commit message (implies --commit)",
-	Aliases:     []string{"cm"},
-	Destination: &CommitMessage,
-}
-
-var Commit bool
-var CommitFlag = &cli.BoolFlag{
-	Name:        "commit",
-	Usage:       "Commits compose.**yml file changes to recipe repository",
-	Value:       false,
-	Aliases:     []string{"c"},
-	Destination: &Commit,
-}
-
-var TagMessage string
-var TagMessageFlag = &cli.StringFlag{
-	Name:        "tag-comment",
-	Usage:       "Description for release tag",
-	Aliases:     []string{"t", "tm"},
-	Destination: &TagMessage,
-}
-
 // PromptBumpType prompts for version bump type
 func PromptBumpType(tagString string) error {
 	if (!Major && !Minor && !Patch) && tagString == "" {
-		fmt.Printf(`
+		fmt.Printf(`semver cheat sheet (more via semver.org):
-semver cheat sheet (more via semver.org):
   major: new features/bug fixes, backwards incompatible
   minor: new features/bug fixes, backwards compatible
   patch: bug fixes, backwards compatible
-
 `)
+
 		var chosenBumpType string
 		prompt := &survey.Select{
 			Message: fmt.Sprintf("select recipe version increment type"),
 			Options: []string{"major", "minor", "patch"},
 		}
+
 		if err := survey.AskOne(prompt, &chosenBumpType); err != nil {
 			return err
 		}
+
 		SetBumpType(chosenBumpType)
 	}
+
 	return nil
 }
 

cli/internal/validate.go

@@ -27,7 +27,14 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe {
 
 	recipe, err := recipe.Get(recipeName)
 	if err != nil {
-		logrus.Fatal(err)
+		if c.Command.Name == "generate" {
+			if strings.Contains(err.Error(), "missing a compose") {
+				logrus.Fatal(err)
+			}
+			logrus.Warn(err)
+		} else {
+			logrus.Fatal(err)
+		}
 	}
 
 	logrus.Debugf("validated '%s' as recipe argument", recipeName)
@@ -41,14 +48,33 @@ func ValidateRecipeWithPrompt(c *cli.Context) recipe.Recipe {
 	recipeName := c.Args().First()
 
 	if recipeName == "" && !NoInput {
+		var recipes []string
+
 		catl, err := catalogue.ReadRecipeCatalogue()
 		if err != nil {
 			logrus.Fatal(err)
 		}
-		var recipes []string
+
+		knownRecipes := make(map[string]bool)
 		for name := range catl {
-			recipes = append(recipes, name)
+			knownRecipes[name] = true
 		}
+
+		localRecipes, err := recipe.GetRecipesLocal()
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		for _, recipeLocal := range localRecipes {
+			if _, ok := knownRecipes[recipeLocal]; !ok {
+				knownRecipes[recipeLocal] = true
+			}
+		}
+
+		for recipeName := range knownRecipes {
+			recipes = append(recipes, recipeName)
+		}
+
 		prompt := &survey.Select{
 			Message: "Select recipe",
 			Options: recipes,
@@ -72,7 +98,7 @@ func ValidateRecipeWithPrompt(c *cli.Context) recipe.Recipe {
 		logrus.Fatal(err)
 	}
 
-	logrus.Debugf("validated '%s' as recipe argument", recipeName)
+	logrus.Debugf("validated %s as recipe argument", recipeName)
 
 	return recipe
 }
@@ -103,7 +129,7 @@ func ValidateApp(c *cli.Context) config.App {
 		logrus.Fatal(err)
 	}
 
-	logrus.Debugf("validated '%s' as app argument", appName)
+	logrus.Debugf("validated %s as app argument", appName)
 
 	return app
 }
@@ -126,7 +152,7 @@ func ValidateDomain(c *cli.Context) (string, error) {
 		ShowSubcommandHelpAndError(c, errors.New("no domain provided"))
 	}
 
-	logrus.Debugf("validated '%s' as domain argument", domainName)
+	logrus.Debugf("validated %s as domain argument", domainName)
 
 	return domainName, nil
 }
@@ -168,7 +194,7 @@ func ValidateServer(c *cli.Context) (string, error) {
 		ShowSubcommandHelpAndError(c, errors.New("no server provided"))
 	}
 
-	logrus.Debugf("validated '%s' as server argument", serverName)
+	logrus.Debugf("validated %s as server argument", serverName)
 
 	return serverName, nil
 }

cli/recipe/lint.go

@@ -7,7 +7,7 @@ import (
 
 	"coopcloud.tech/abra/cli/formatter"
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/catalogue"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/tagcmp"
 	"github.com/docker/distribution/reference"
@@ -98,16 +98,5 @@ var recipeLintCommand = &cli.Command{
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.RecipeNameComplete,
-		catl, err := catalogue.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for name := range catl {
-			fmt.Println(name)
-		}
-	},
 }

cli/recipe/new.go

@@ -41,7 +41,7 @@ The new example repository is cloned to ~/.abra/apps/<recipe>.
 
 		directory := path.Join(config.APPS_DIR, recipeName)
 		if _, err := os.Stat(directory); !os.IsNotExist(err) {
-			logrus.Fatalf("'%s' recipe directory already exists?", directory)
+			logrus.Fatalf("%s recipe directory already exists?", directory)
 		}
 
 		url := fmt.Sprintf("%s/example.git", config.REPOS_BASE_URL)
@@ -53,7 +53,7 @@ The new example repository is cloned to ~/.abra/apps/<recipe>.
 		if err := os.RemoveAll(gitRepo); err != nil {
 			logrus.Fatal(err)
 		}
-		logrus.Debugf("removed git repo in '%s'", gitRepo)
+		logrus.Debugf("removed git repo in %s", gitRepo)
 
 		toParse := []string{
 			path.Join(config.APPS_DIR, recipeName, "README.md"),
@@ -61,7 +61,7 @@ The new example repository is cloned to ~/.abra/apps/<recipe>.
 			path.Join(config.APPS_DIR, recipeName, ".drone.yml"),
 		}
 		for _, path := range toParse {
-			file, err := os.OpenFile(path, os.O_RDWR, 0755)
+			file, err := os.OpenFile(path, os.O_RDWR, 0664)
 			if err != nil {
 				logrus.Fatal(err)
 			}
@@ -88,7 +88,7 @@ The new example repository is cloned to ~/.abra/apps/<recipe>.
 		}
 
 		logrus.Infof(
-			"new recipe '%s' created in %s, happy hacking!\n",
+			"new recipe %s created in %s, happy hacking!\n",
 			recipeName, path.Join(config.APPS_DIR, recipeName),
 		)
 

cli/recipe/recipe.go

@@ -7,13 +7,18 @@ import (
 // RecipeCommand defines all recipe related sub-commands.
 var RecipeCommand = &cli.Command{
 	Name:      "recipe",
-	Usage:     "Manage recipes (for maintainers)",
+	Usage:     "Manage recipes",
 	ArgsUsage: "<recipe>",
 	Aliases:   []string{"r"},
 	Description: `
-A recipe is a blueprint for an app. It is a bunch of configuration files which
+A recipe is a blueprint for an app. It is a bunch of config files which
 describe how to deploy and maintain an app. Recipes are maintained by the Co-op
 Cloud community and you can use Abra to read them and create apps for you.
+
+Anyone who uses a recipe can become a maintainer. Maintainers typically make
+sure the recipe is in good working order and the config upgraded in a timely
+manner. Abra supports convenient automation for recipe maintainenace, see the
+"abra recipe upgrade", "abra recipe sync" and "abra recipe release" commands.
 `,
 	Subcommands: []*cli.Command{
 		recipeListCommand,

cli/recipe/release.go

@@ -8,14 +8,16 @@ import (
 
 	abraFormatter "coopcloud.tech/abra/cli/formatter"
 	"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/recipe"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/distribution/reference"
 	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
+	configPkg "github.com/go-git/go-git/v5/config"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
@@ -34,9 +36,9 @@ These tags take the following form:
 
     a.b.c+x.y.z
 
-Where the "a.b.c" part is maintained as a semantic version of the recipe by the
+Where the "a.b.c" part is a semantic version determined by the maintainer. And
-recipe maintainer. And the "x.y.z" part is the image tag of the recipe "app"
+the "x.y.z" part is the image tag of the recipe "app" service (the main
-service (the main container which contains the software to be used).
+container which contains the software to be used).
 
 We maintain a semantic versioning scheme ("a.b.c") alongside the libre app
 versioning scheme in order to maximise the chances that the nature of recipe
@@ -61,235 +63,77 @@ You may invoke this command in "wizard" mode and be prompted for input:
 		internal.CommitMessageFlag,
 		internal.TagMessageFlag,
 	},
+	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
 		recipe := internal.ValidateRecipeWithPrompt(c)
-		directory := path.Join(config.APPS_DIR, recipe.Name)
-		tagString := c.Args().Get(1)
-		mainApp := internal.GetMainApp(recipe)
 
 		imagesTmp, err := getImageVersions(recipe)
 		if err != nil {
 			logrus.Fatal(err)
 		}
+
+		mainApp := internal.GetMainApp(recipe)
 		mainAppVersion := imagesTmp[mainApp]
-
-		if err := recipePkg.EnsureExists(recipe.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
 		if mainAppVersion == "" {
-			logrus.Fatalf("main 'app' service version for %s is empty?", recipe.Name)
+			logrus.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.Fatal("invalid tag specified")
+				logrus.Fatalf("cannot parse %s, invalid tag specified?", tagString)
 			}
 		}
 
-		if (!internal.Major && !internal.Minor && !internal.Patch) && tagString != "" {
-			logrus.Fatal("please specify <version> or bump type (--major/--minor/--patch)")
-		}
-
 		if (internal.Major || internal.Minor || internal.Patch) && tagString != "" {
 			logrus.Fatal("cannot specify tag and bump type at the same time")
 		}
 
-		// bumpType is used to decide what part of the tag should be incremented
-		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.")
-			}
-		}
-
-		if err := internal.PromptBumpType(tagString); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if internal.TagMessage == "" {
-			prompt := &survey.Input{
-				Message: "tag message",
-				Default: fmt.Sprintf("chore: publish new %s version", internal.GetBumpType()),
-			}
-			if err := survey.AskOne(prompt, &internal.TagMessage); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		var createTagOptions git.CreateTagOptions
-		createTagOptions.Message = internal.TagMessage
-
-		if !internal.Commit {
-			prompt := &survey.Confirm{
-				Message: "git commit changes also?",
-			}
-			if err := survey.AskOne(prompt, &internal.Commit); err != nil {
-				return err
-			}
-		}
-
-		if !internal.Push {
-			prompt := &survey.Confirm{
-				Message: "git push changes also?",
-			}
-			if err := survey.AskOne(prompt, &internal.Push); err != nil {
-				return err
-			}
-		}
-
-		if internal.Commit || internal.CommitMessage != "" {
-			commitRepo, err := git.PlainOpen(directory)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			commitWorktree, err := commitRepo.Worktree()
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if internal.CommitMessage == "" {
-				prompt := &survey.Input{
-					Message: "commit message",
-					Default: fmt.Sprintf("chore: publish new %s version", internal.GetBumpType()),
-				}
-				if err := survey.AskOne(prompt, &internal.CommitMessage); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			err = commitWorktree.AddGlob("compose.**yml")
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			logrus.Debug("staged compose.**yml for commit")
-
-			if !internal.Dry {
-				_, err = commitWorktree.Commit(internal.CommitMessage, &git.CommitOptions{})
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				logrus.Info("changes commited")
-			} else {
-				logrus.Info("dry run only: NOT committing changes")
-			}
-		}
-
-		repo, err := git.PlainOpen(directory)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		head, err := repo.Head()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
 		if tagString != "" {
-			tag, err := tagcmp.Parse(tagString)
+			if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
-			if err != nil {
 				logrus.Fatal(err)
 			}
-			if tag.MissingMinor {
-				tag.Minor = "0"
-				tag.MissingMinor = false
-			}
-			if tag.MissingPatch {
-				tag.Patch = "0"
-				tag.MissingPatch = false
-			}
-			tagString = fmt.Sprintf("%s+%s", tag.String(), mainAppVersion)
-			if internal.Dry {
-				hash := abraFormatter.SmallSHA(head.Hash().String())
-				logrus.Info(fmt.Sprintf("dry run only: NOT creating tag %s at %s", tagString, hash))
-				return nil
-			}
-
-			repo.CreateTag(tagString, head.Hash(), &createTagOptions)
-			hash := abraFormatter.SmallSHA(head.Hash().String())
-			logrus.Info(fmt.Sprintf("created tag %s at %s", tagString, hash))
-			if internal.Push && !internal.Dry {
-				if err := repo.Push(&git.PushOptions{}); err != nil {
-					logrus.Fatal(err)
-				}
-				logrus.Info(fmt.Sprintf("pushed tag %s to remote", tagString))
-			} else {
-				logrus.Info("dry run only: NOT pushing changes")
-			}
-
-			return nil
 		}
 
-		// get the latest tag with its hash, name etc
+		tags, err := recipe.Tags()
-		var lastGitTag tagcmp.Tag
-		iter, err := repo.Tags()
 		if err != nil {
-			logrus.Fatal(err)
+			return err
-		}
-		if err := iter.ForEach(func(ref *plumbing.Reference) error {
-			obj, err := repo.TagObject(ref.Hash())
-			if err != nil {
-				return err
-			}
-			tagcmpTag, err := tagcmp.Parse(obj.Name)
-			if err != nil {
-				return err
-			}
-			if (lastGitTag == tagcmp.Tag{}) {
-				lastGitTag = tagcmpTag
-			} else if tagcmpTag.IsGreaterThan(lastGitTag) {
-				lastGitTag = tagcmpTag
-			}
-			return nil
-		}); err != nil {
-			logrus.Fatal(err)
 		}
 
-		newTag := lastGitTag
+		if len(tags) > 0 {
-		var newtagString string
+			logrus.Warnf("previous git tags detected, assuming this is a new semver release")
-		if bumpType > 0 {
+			if err := createReleaseFromPreviousTag(tagString, mainAppVersion, recipe, tags); err != nil {
-			if internal.Patch {
-				now, err := strconv.Atoi(newTag.Patch)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				newTag.Patch = strconv.Itoa(now + 1)
-			} else if internal.Minor {
-				now, err := strconv.Atoi(newTag.Minor)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				newTag.Patch = "0"
-				newTag.Minor = strconv.Itoa(now + 1)
-			} else if internal.Major {
-				now, err := strconv.Atoi(newTag.Major)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				newTag.Patch = "0"
-				newTag.Minor = "0"
-				newTag.Major = strconv.Itoa(now + 1)
-			}
-		}
-
-		newTag.Metadata = mainAppVersion
-		newtagString = newTag.String()
-		if internal.Dry {
-			hash := abraFormatter.SmallSHA(head.Hash().String())
-			logrus.Info(fmt.Sprintf("dry run only: NOT creating tag %s at %s", newtagString, hash))
-			return nil
-		}
-
-		repo.CreateTag(newtagString, head.Hash(), &createTagOptions)
-		hash := abraFormatter.SmallSHA(head.Hash().String())
-		logrus.Info(fmt.Sprintf("created tag %s at %s", newtagString, hash))
-		if internal.Push && !internal.Dry {
-			if err := repo.Push(&git.PushOptions{}); err != nil {
 				logrus.Fatal(err)
 			}
-			logrus.Info(fmt.Sprintf("pushed tag %s to remote", newtagString))
 		} else {
-			logrus.Info("gry run only: NOT pushing changes")
+			logrus.Warnf("no tag specified and no previous tag available for %s, assuming this is the initial release", recipe.Name)
+
+			initTag, err := recipePkg.GetVersionLabelLocal(recipe)
+			if err != nil {
+				logrus.Fatal(err)
+			}
+
+			logrus.Warnf("discovered %s as currently synced recipe label", initTag)
+
+			prompt := &survey.Confirm{
+				Message: fmt.Sprintf("use %s as the initial release?", initTag),
+			}
+
+			var response bool
+			if err := survey.AskOne(prompt, &response); err != nil {
+				return err
+			}
+
+			if !response {
+				logrus.Fatalf("please fix your synced label for %s and re-run this command", recipe.Name)
+			}
+
+			if err := createReleaseFromTag(recipe, initTag, mainAppVersion); err != nil {
+				if cleanUpErr := cleanUpTag(initTag, recipe.Name); err != nil {
+					logrus.Fatal(cleanUpErr)
+				}
+				logrus.Fatal(err)
+			}
 		}
 
 		return nil
@@ -320,7 +164,7 @@ func getImageVersions(recipe recipe.Recipe) (map[string]string, error) {
 		case reference.NamedTagged:
 			tag = img.(reference.NamedTagged).Tag()
 		case reference.Named:
-			logrus.Fatalf("%s service is missing image tag?", path)
+			return services, fmt.Errorf("%s service is missing image tag?", path)
 		}
 
 		services[path] = tag
@@ -329,6 +173,50 @@ func getImageVersions(recipe recipe.Recipe) (map[string]string, error) {
 	return services, nil
 }
 
+// createReleaseFromTag creates a new release based on a supplied recipe version string
+func createReleaseFromTag(recipe recipe.Recipe, tagString, mainAppVersion string) error {
+	var err error
+
+	directory := path.Join(config.APPS_DIR, recipe.Name)
+	repo, err := git.PlainOpen(directory)
+	if err != nil {
+		return err
+	}
+
+	tag, err := tagcmp.Parse(tagString)
+	if err != nil {
+		return err
+	}
+
+	if tag.MissingMinor {
+		tag.Minor = "0"
+		tag.MissingMinor = false
+	}
+
+	if tag.MissingPatch {
+		tag.Patch = "0"
+		tag.MissingPatch = false
+	}
+
+	if err := commitRelease(recipe); err != nil {
+		logrus.Fatal(err)
+	}
+
+	if tagString == "" {
+		tagString = fmt.Sprintf("%s+%s", tag.String(), mainAppVersion)
+	}
+
+	if err := tagRelease(tagString, repo); err != nil {
+		logrus.Fatal(err)
+	}
+
+	if err := pushRelease(tagString, repo); err != nil {
+		logrus.Fatal(err)
+	}
+
+	return nil
+}
+
 // btoi converts a boolean value into an integer
 func btoi(b bool) int {
 	if b {
@@ -337,3 +225,208 @@ func btoi(b bool) int {
 
 	return 0
 }
+
+// getTagCreateOptions constructs git tag create options
+func getTagCreateOptions() (git.CreateTagOptions, error) {
+	if internal.TagMessage == "" && !internal.NoInput {
+		prompt := &survey.Input{
+			Message: "git tag message",
+			Default: "chore: publish new release",
+		}
+
+		if err := survey.AskOne(prompt, &internal.TagMessage); err != nil {
+			return git.CreateTagOptions{}, err
+		}
+	}
+
+	return git.CreateTagOptions{Message: internal.TagMessage}, nil
+}
+
+func commitRelease(recipe recipe.Recipe) error {
+	if internal.Dry {
+		logrus.Info("dry run: no changed committed")
+		return nil
+	}
+
+	if !internal.Commit && !internal.NoInput {
+		prompt := &survey.Confirm{
+			Message: "git commit changes?",
+		}
+
+		if err := survey.AskOne(prompt, &internal.Commit); err != nil {
+			return err
+		}
+	}
+
+	if internal.CommitMessage == "" && !internal.NoInput && internal.Commit {
+		prompt := &survey.Input{
+			Message: "commit message",
+			Default: "chore: publish new version",
+		}
+		if err := survey.AskOne(prompt, &internal.CommitMessage); err != nil {
+			return err
+		}
+	}
+
+	if internal.Commit {
+		repoPath := path.Join(config.APPS_DIR, recipe.Name)
+		if err := gitPkg.Commit(repoPath, "compose.**yml", internal.CommitMessage, internal.Dry, false); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func tagRelease(tagString string, repo *git.Repository) error {
+	if internal.Dry {
+		logrus.Infof("dry run: no git tag created (%s)", tagString)
+		return nil
+	}
+
+	head, err := repo.Head()
+	if err != nil {
+		return err
+	}
+
+	createTagOptions, err := getTagCreateOptions()
+	if err != nil {
+		return err
+	}
+
+	_, err = repo.CreateTag(tagString, head.Hash(), &createTagOptions)
+	if err != nil {
+		return err
+	}
+
+	hash := abraFormatter.SmallSHA(head.Hash().String())
+	logrus.Info(fmt.Sprintf("created tag %s at %s", tagString, hash))
+
+	return nil
+}
+
+func pushRelease(tagString string, repo *git.Repository) error {
+	if internal.Dry {
+		logrus.Info("dry run: no changes pushed")
+		return nil
+	}
+
+	if !internal.Push && !internal.NoInput {
+		prompt := &survey.Confirm{
+			Message: "git push changes?",
+		}
+
+		if err := survey.AskOne(prompt, &internal.Push); err != nil {
+			return err
+		}
+	}
+
+	if internal.Push {
+		tagRef := fmt.Sprintf("+refs/tags/%s:refs/tags/%s", tagString, tagString)
+		pushOpts := &git.PushOptions{
+			RefSpecs: []configPkg.RefSpec{
+				configPkg.RefSpec(tagRef),
+			},
+		}
+		if err := repo.Push(pushOpts); err != nil {
+			return err
+		}
+		logrus.Info(fmt.Sprintf("pushed tag %s to remote", tagString))
+	}
+
+	return nil
+}
+
+func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recipe.Recipe, tags []string) error {
+	directory := path.Join(config.APPS_DIR, recipe.Name)
+	repo, err := git.PlainOpen(directory)
+	if err != nil {
+		return err
+	}
+
+	bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
+	if bumpType != 0 {
+		if (bumpType & (bumpType - 1)) != 0 {
+			return fmt.Errorf("you can only use one of: --major, --minor, --patch")
+		}
+	}
+
+	if err := internal.PromptBumpType(tagString); err != nil {
+		return err
+	}
+
+	var lastGitTag tagcmp.Tag
+	for _, tag := range tags {
+		parsed, err := tagcmp.Parse(tag)
+		if err != nil {
+			return err
+		}
+
+		if (lastGitTag == tagcmp.Tag{}) {
+			lastGitTag = parsed
+		} else if parsed.IsGreaterThan(lastGitTag) {
+			lastGitTag = parsed
+		}
+	}
+
+	newTag := lastGitTag
+	if internal.Patch {
+		now, err := strconv.Atoi(newTag.Patch)
+		if err != nil {
+			return err
+		}
+
+		newTag.Patch = strconv.Itoa(now + 1)
+	} else if internal.Minor {
+		now, err := strconv.Atoi(newTag.Minor)
+		if err != nil {
+			return err
+		}
+
+		newTag.Patch = "0"
+		newTag.Minor = strconv.Itoa(now + 1)
+	} else if internal.Major {
+		now, err := strconv.Atoi(newTag.Major)
+		if err != nil {
+			return err
+		}
+
+		newTag.Patch = "0"
+		newTag.Minor = "0"
+		newTag.Major = strconv.Itoa(now + 1)
+	}
+
+	if err := commitRelease(recipe); err != nil {
+		logrus.Fatal(err)
+	}
+
+	newTag.Metadata = mainAppVersion
+	newTagString := newTag.String()
+
+	if err := tagRelease(newTagString, repo); err != nil {
+		logrus.Fatal(err)
+	}
+
+	if err := pushRelease(newTagString, repo); err != nil {
+		logrus.Fatal(err)
+	}
+
+	return nil
+}
+
+// cleanUpTag removes a freshly created tag
+func cleanUpTag(tag, recipeName string) error {
+	directory := path.Join(config.APPS_DIR, recipeName)
+	repo, err := git.PlainOpen(directory)
+	if err != nil {
+		return err
+	}
+
+	if err := repo.DeleteTag(tag); err != nil {
+		return err
+	}
+
+	logrus.Warn("removed freshly created tag %s")
+
+	return nil
+}

cli/recipe/sync.go

@@ -6,7 +6,7 @@ import (
 	"strconv"
 
 	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/catalogue"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
@@ -51,6 +51,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 		if err != nil {
 			logrus.Fatal(err)
 		}
+
 		mainAppVersion := imagesTmp[mainApp]
 
 		tags, err := recipe.Tags()
@@ -60,15 +61,30 @@ You may invoke this command in "wizard" mode and be prompted for input:
 
 		nextTag := c.Args().Get(1)
 		if len(tags) == 0 && nextTag == "" {
-			logrus.Warnf("no tags found for %s", recipe.Name)
+			logrus.Warnf("no git tags found for %s", recipe.Name)
+			fmt.Println(fmt.Sprintf(`
+The following options are two types of initial version that you can pick for
+the first published version of %s that will be in the recipe catalogue. This
+follows the semver convention (more on semver.org), here is a short cheatsheet
+
+    0.1.0 -> development release, still hacking
+    1.0.0 -> public release, assumed to be working
+
+In other words, if you want people to be able alpha test your current config
+for %s but don't think it is quite ready and reliable, go with 0.1.0 and people
+will know that things are likely to change.
+
+`, recipe.Name, recipe.Name))
 			var chosenVersion string
 			edPrompt := &survey.Select{
 				Message: "which version do you want to begin with?",
 				Options: []string{"0.1.0", "1.0.0"},
 			}
+
 			if err := survey.AskOne(edPrompt, &chosenVersion); err != nil {
 				logrus.Fatal(err)
 			}
+
 			nextTag = fmt.Sprintf("%s+%s", chosenVersion, mainAppVersion)
 		}
 
@@ -84,25 +100,30 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			if err != nil {
 				logrus.Fatal(err)
 			}
+
 			var lastGitTag tagcmp.Tag
 			iter, err := repo.Tags()
 			if err != nil {
 				logrus.Fatal(err)
 			}
+
 			if err := iter.ForEach(func(ref *plumbing.Reference) error {
 				obj, err := repo.TagObject(ref.Hash())
 				if err != nil {
 					return err
 				}
+
 				tagcmpTag, err := tagcmp.Parse(obj.Name)
 				if err != nil {
 					return err
 				}
+
 				if (lastGitTag == tagcmp.Tag{}) {
 					lastGitTag = tagcmpTag
 				} else if tagcmpTag.IsGreaterThan(lastGitTag) {
 					lastGitTag = tagcmpTag
 				}
+
 				return nil
 			}); err != nil {
 				logrus.Fatal(err)
@@ -113,7 +134,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			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.")
+					logrus.Fatal("you can only use one version flag: --major, --minor or --patch")
 				}
 			}
 
@@ -124,12 +145,14 @@ You may invoke this command in "wizard" mode and be prompted for input:
 					if err != nil {
 						logrus.Fatal(err)
 					}
+
 					newTag.Patch = strconv.Itoa(now + 1)
 				} else if internal.Minor {
 					now, err := strconv.Atoi(newTag.Minor)
 					if err != nil {
 						logrus.Fatal(err)
 					}
+
 					newTag.Patch = "0"
 					newTag.Minor = strconv.Itoa(now + 1)
 				} else if internal.Major {
@@ -137,6 +160,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 					if err != nil {
 						logrus.Fatal(err)
 					}
+
 					newTag.Patch = "0"
 					newTag.Minor = "0"
 					newTag.Major = strconv.Itoa(now + 1)
@@ -153,44 +177,16 @@ You may invoke this command in "wizard" mode and be prompted for input:
 		}
 
 		mainService := "app"
-		var services []string
-		hasAppService := false
-		for _, service := range recipe.Config.Services {
-			services = append(services, service.Name)
-			if service.Name == "app" {
-				hasAppService = true
-				logrus.Debugf("detected app service in %s", recipe.Name)
-			}
-		}
-
-		if !hasAppService {
-			logrus.Fatalf("%s has no main 'app' service?", recipe.Name)
-		}
-
-		logrus.Debugf("selecting %s as the service to sync version label", mainService)
-
 		label := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", nextTag)
 		if !internal.Dry {
-			if err := recipe.UpdateLabel(mainService, label); err != nil {
+			if err := recipe.UpdateLabel("compose.y*ml", mainService, label); err != nil {
 				logrus.Fatal(err)
 			}
-			logrus.Infof("synced label '%s' to service '%s'", label, mainService)
 		} else {
-			logrus.Infof("dry run only: NOT syncing label %s for recipe %s", nextTag, recipe.Name)
+			logrus.Infof("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name)
 		}
 
 		return nil
 	},
-	BashComplete: func(c *cli.Context) {
+	BashComplete: autocomplete.RecipeNameComplete,
-		catl, err := catalogue.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Warn(err)
-		}
-		if c.NArg() > 0 {
-			return
-		}
-		for name := range catl {
-			fmt.Println(name)
-		}
-	},
 }

cli/recipe/upgrade.go

@@ -97,11 +97,6 @@ You may invoke this command in "wizard" mode and be prompted for input:
 		}
 
 		for _, service := range recipe.Config.Services {
-			catlVersions, err := catalogue.VersionsOfService(recipe.Name, service.Name)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
 			img, err := reference.ParseNormalizedNamed(service.Image)
 			if err != nil {
 				logrus.Fatal(err)
@@ -112,7 +107,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			if err != nil {
 				logrus.Fatal(err)
 			}
-			logrus.Debugf("retrieved '%s' from remote registry for '%s'", regVersions, image)
+			logrus.Debugf("retrieved %s from remote registry for %s", regVersions, image)
 
 			if strings.Contains(image, "library") {
 				// ParseNormalizedNamed prepends 'library' to images like nginx:<tag>,
@@ -122,7 +117,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			}
 			semverLikeTag := true
 			if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) {
-				logrus.Debugf("'%s' not considered semver-like", img.(reference.NamedTagged).Tag())
+				logrus.Debugf("%s not considered semver-like", img.(reference.NamedTagged).Tag())
 				semverLikeTag = false
 			}
 
@@ -130,7 +125,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			if err != nil && semverLikeTag {
 				logrus.Fatal(err)
 			}
-			logrus.Debugf("parsed '%s' for '%s'", tag, service.Name)
+			logrus.Debugf("parsed %s for %s", tag, service.Name)
 			var compatible []tagcmp.Tag
 			for _, regVersion := range regVersions {
 				other, err := tagcmp.Parse(regVersion.Name)
@@ -143,15 +138,20 @@ 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)
+			logrus.Debugf("detected potential upgradable tags %s for %s", compatible, service.Name)
 
 			sort.Sort(tagcmp.ByTagDesc(compatible))
 
 			if len(compatible) == 0 && semverLikeTag {
-				logrus.Info(fmt.Sprintf("no new versions available for '%s', '%s' is the latest", image, tag))
+				logrus.Info(fmt.Sprintf("no new versions available for %s, %s is the latest", image, tag))
 				continue // skip on to the next tag and don't update any compose files
 			}
 
+			catlVersions, err := catalogue.VersionsOfService(recipe.Name, service.Name)
+			if err != nil {
+				logrus.Fatal(err)
+			}
+
 			var compatibleStrings []string
 			for _, compat := range compatible {
 				skip := false
@@ -165,7 +165,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)
+			logrus.Debugf("detected compatible upgradable tags %s for %s", compatibleStrings, service.Name)
 
 			var upgradeTag string
 			_, ok := servicePins[service.Name]
@@ -205,14 +205,14 @@ 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)
+						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)
 						continue
 					}
 				} else {
 					msg := fmt.Sprintf("upgrade to which tag? (service: %s, tag: %s)", service.Name, tag)
 					if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) {
 						tag := img.(reference.NamedTagged).Tag()
-						logrus.Warning(fmt.Sprintf("unable to determine versioning semantics of '%s', listing all tags", tag))
+						logrus.Warning(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{}
 						for _, regVersion := range regVersions {
@@ -232,7 +232,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
 			if err := recipe.UpdateTag(image, upgradeTag); err != nil {
 				logrus.Fatal(err)
 			}
-			logrus.Infof("tag upgraded from '%s' to '%s' for '%s'", tag.String(), upgradeTag, image)
+			logrus.Infof("tag upgraded from %s to %s for %s", tag.String(), upgradeTag, image)
 		}
 
 		return nil

cli/record/new.go

@@ -7,6 +7,7 @@ import (
 
 	abraFormatter "coopcloud.tech/abra/cli/formatter"
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/dns"
 	gandiPkg "coopcloud.tech/abra/pkg/dns/gandi"
 	"github.com/libdns/gandi"
 	"github.com/libdns/libdns"
@@ -27,6 +28,7 @@ var RecordNewCommand = &cli.Command{
 		internal.DNSValueFlag,
 		internal.DNSTTLFlag,
 		internal.DNSPriorityFlag,
+		internal.AutoDNSRecordFlag,
 	},
 	Description: `
 This command creates a new domain name record for a specific zone.
@@ -38,6 +40,12 @@ Example:
 
     abra record new foo.com -p gandi -t A -n myapp -v 192.168.178.44
 
+Typically, you need two records, an A record which points at the zone (@.) and
+a wildcard record for your apps (*.). Pass "--auto" to have Abra automatically
+set this up.
+
+    abra record new --auto
+
 You may also invoke this command in "wizard" mode and be prompted for input
 
     abra record new
@@ -63,6 +71,14 @@ You may also invoke this command in "wizard" mode and be prompted for input
 			logrus.Fatalf("'%s' is not a supported DNS provider", internal.DNSProvider)
 		}
 
+		if internal.AutoDNSRecord {
+			logrus.Infof("automatically configuring @./*. A records for %s (--auto)", zone)
+			if err := autoConfigure(c, &provider, zone); err != nil {
+				logrus.Fatal(err)
+			}
+			return nil
+		}
+
 		if err := internal.EnsureDNSTypeFlag(c); err != nil {
 			logrus.Fatal(err)
 		}
@@ -95,7 +111,7 @@ You may also invoke this command in "wizard" mode and be prompted for input
 			if existingRecord.Type == record.Type &&
 				existingRecord.Name == record.Name &&
 				existingRecord.Value == record.Value {
-				logrus.Fatal("provider library reports that this record already exists?")
+				logrus.Fatalf("%s record for %s already exists?", record.Type, zone)
 			}
 		}
 
@@ -104,6 +120,9 @@ You may also invoke this command in "wizard" mode and be prompted for input
 			zone,
 			[]libdns.Record{record},
 		)
+		if err != nil {
+			logrus.Fatal(err)
+		}
 
 		if len(createdRecords) == 0 {
 			logrus.Fatal("provider library reports that no record was created?")
@@ -134,3 +153,79 @@ You may also invoke this command in "wizard" mode and be prompted for input
 		return nil
 	},
 }
+
+func autoConfigure(c *cli.Context, provider *gandi.Provider, zone string) error {
+	ipv4, err := dns.EnsureIPv4(zone)
+	if err != nil {
+		return err
+	}
+
+	atRecord := libdns.Record{
+		Type:  "A",
+		Name:  "@",
+		Value: ipv4,
+		TTL:   time.Duration(internal.DNSTTL),
+	}
+
+	wildcardRecord := libdns.Record{
+		Type:  "A",
+		Name:  "*",
+		Value: ipv4,
+		TTL:   time.Duration(internal.DNSTTL),
+	}
+
+	records := []libdns.Record{atRecord, wildcardRecord}
+
+	tableCol := []string{"type", "name", "value", "TTL", "priority"}
+	table := abraFormatter.CreateTable(tableCol)
+
+	for _, record := range records {
+		existingRecords, err := provider.GetRecords(c.Context, zone)
+		if err != nil {
+			return err
+		}
+
+		for _, existingRecord := range existingRecords {
+			if existingRecord.Type == record.Type &&
+				existingRecord.Name == record.Name &&
+				existingRecord.Value == record.Value {
+				logrus.Warnf("%s record for %s already exists?", record.Type, zone)
+				continue
+			}
+		}
+
+		createdRecords, err := provider.SetRecords(
+			c.Context,
+			zone,
+			[]libdns.Record{record},
+		)
+		if err != nil {
+			return err
+		}
+
+		if len(createdRecords) == 0 {
+			return fmt.Errorf("provider library reports that no record was created?")
+		}
+
+		createdRecord := createdRecords[0]
+
+		value := createdRecord.Value
+		if len(createdRecord.Value) > 30 {
+			value = fmt.Sprintf("%s...", createdRecord.Value[:30])
+		}
+
+		table.Append([]string{
+			createdRecord.Type,
+			createdRecord.Name,
+			value,
+			createdRecord.TTL.String(),
+			strconv.Itoa(createdRecord.Priority),
+		})
+	}
+
+	if table.NumLines() > 0 {
+		table.Render()
+	}
+
+	return nil
+}

cli/server/add.go

@@ -10,7 +10,6 @@ import (
 	"path/filepath"
 	"strings"
 
-	abraFormatter "coopcloud.tech/abra/cli/formatter"
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
@@ -117,7 +116,17 @@ func installDockerLocal(c *cli.Context) error {
 		logrus.Fatal("exiting as requested")
 	}
 
-	cmd := exec.Command("bash", "-c", "curl -s https://get.docker.com | bash")
+	for _, exe := range []string{"wget", "bash"} {
+		exists, err := ensureLocalExecutable(exe)
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return fmt.Errorf("%s missing, please install it", exe)
+		}
+	}
+
+	cmd := exec.Command("bash", "-c", "wget -O- https://get.docker.com | bash")
 	if err := internal.RunCmd(cmd); err != nil {
 		return err
 	}
@@ -136,15 +145,17 @@ func newLocalServer(c *cli.Context, domainName string) error {
 	}
 
 	if provision {
-		out, err := exec.Command("which", "docker").Output()
+		exists, err := ensureLocalExecutable("docker")
 		if err != nil {
 			return err
 		}
-		if string(out) == "" {
+
+		if !exists {
 			if err := installDockerLocal(c); err != nil {
 				return err
 			}
 		}
+
 		if err := initSwarmLocal(c, cl, domainName); err != nil {
 			if !strings.Contains(err.Error(), "proxy already exists") {
 				logrus.Fatal(err)
@@ -195,59 +206,127 @@ func newClient(c *cli.Context, domainName string) (*dockerClient.Client, error)
 }
 
 func installDocker(c *cli.Context, cl *dockerClient.Client, sshCl *ssh.Client, domainName string) error {
-	result, err := sshCl.Exec("which docker")
+	exists, err := ensureRemoteExecutable("docker", sshCl)
-	if err != nil && string(result) != "" {
+	if err != nil {
 		return err
 	}
 
-	if string(result) == "" {
+	if !exists {
 		fmt.Println(fmt.Sprintf(dockerInstallMsg, domainName))
 
 		response := false
 		prompt := &survey.Confirm{
 			Message: fmt.Sprintf("attempt install docker on %s?", domainName),
 		}
+
 		if err := survey.AskOne(prompt, &response); err != nil {
 			return err
 		}
+
 		if !response {
 			logrus.Fatal("exiting as requested")
 		}
 
-		cmd := "curl -s https://get.docker.com | bash"
+		exes := []string{"wget", "bash"}
+		if askSudoPass {
+			exes = append(exes, "ssh-askpass")
+		}
+
+		for _, exe := range exes {
+			exists, err := ensureRemoteExecutable(exe, sshCl)
+			if err != nil {
+				return err
+			}
+			if !exists {
+				return fmt.Errorf("%s missing on remote, please install it", exe)
+			}
+		}
 
 		var sudoPass string
 		if askSudoPass {
+			cmd := "wget -O- https://get.docker.com | bash"
+
 			prompt := &survey.Password{
 				Message: "sudo password?",
 			}
+
 			if err := survey.AskOne(prompt, &sudoPass); err != nil {
 				return err
 			}
-			logrus.Debugf("running '%s' on %s now with sudo password", cmd, domainName)
+
+			logrus.Debugf("running %s on %s now with sudo password", cmd, domainName)
+
+			if sudoPass == "" {
+				return fmt.Errorf("missing sudo password but requested --ask-sudo-pass?")
+			}
+
+			logrus.Warn("installing docker, this could take some time...")
+
 			if err := ssh.RunSudoCmd(cmd, sudoPass, sshCl); err != nil {
+				fmt.Print(fmt.Sprintf(`
+Abra was unable to bootstrap Docker, see below for logs:
+
+
+%s
+
+If nothing works, you try running the Docker install script manually on your server:
+
+    wget -O- https://get.docker.com | bash
+
+`, string(err.Error())))
+				logrus.Fatal("Process exited with status 1")
+			}
+
+			logrus.Infof("docker is installed on %s", domainName)
+
+			remoteUser := sshCl.SSHClient.Conn.User()
+			logrus.Infof("adding %s to docker group", remoteUser)
+			permsCmd := fmt.Sprintf("sudo usermod -aG docker %s", remoteUser)
+			if err := ssh.RunSudoCmd(permsCmd, sudoPass, sshCl); err != nil {
 				return err
 			}
 		} else {
-			logrus.Debugf("running '%s' on %s now without sudo password", cmd, domainName)
+			cmd := "wget -O- https://get.docker.com | bash"
-			if err := ssh.Exec(cmd, sshCl); err != nil {
+
-				return err
+			logrus.Debugf("running %s on %s now without sudo password", cmd, domainName)
+
+			logrus.Warn("installing docker, this could take some time...")
+
+			if out, err := sshCl.Exec(cmd); err != nil {
+				fmt.Print(fmt.Sprintf(`
+Abra was unable to bootstrap Docker, see below for logs:
+
+
+%s
+
+This could be due to a number of things but one of the most common is that your
+server user account does not have sudo access, and if it does, you need to pass
+"--ask-sudo-pass" in order to supply Abra with your password.
+
+If nothing works, you try running the Docker install script manually on your server:
+
+    wget -O- https://get.docker.com | bash
+
+`, string(out)))
+				logrus.Fatal(err)
 			}
+
+			logrus.Infof("docker is installed on %s", domainName)
 		}
 	}
 
-	logrus.Infof("docker is installed on %s", domainName)
-
 	return nil
 }
 
 func initSwarmLocal(c *cli.Context, cl *dockerClient.Client, domainName string) error {
 	initReq := swarm.InitRequest{ListenAddr: "0.0.0.0:2377"}
 	if _, err := cl.SwarmInit(c.Context, initReq); err != nil {
-		if !strings.Contains(err.Error(), "is already part of a swarm") {
+		if strings.Contains(err.Error(), "is already part of a swarm") ||
+			strings.Contains(err.Error(), "must specify a listening address") {
+			logrus.Infof("swarm mode already initialised on %s", domainName)
+		} else {
 			return err
 		}
-		logrus.Info("swarm mode already initialised on local server")
 	} else {
 		logrus.Infof("initialised swarm mode on local server")
 	}
@@ -276,10 +355,12 @@ func initSwarm(c *cli.Context, cl *dockerClient.Client, domainName string) error
 		AdvertiseAddr: ipv4,
 	}
 	if _, err := cl.SwarmInit(c.Context, initReq); err != nil {
-		if !strings.Contains(err.Error(), "is already part of a swarm") {
+		if strings.Contains(err.Error(), "is already part of a swarm") ||
+			strings.Contains(err.Error(), "must specify a listening address") {
+			logrus.Infof("swarm mode already initialised on %s", domainName)
+		} else {
 			return err
 		}
-		logrus.Infof("swarm mode already initialised on %s", domainName)
 	} else {
 		logrus.Infof("initialised swarm mode on %s", domainName)
 	}
@@ -316,16 +397,8 @@ func deployTraefik(c *cli.Context, cl *dockerClient.Client, domainName string) e
 	internal.NewAppName = fmt.Sprintf("%s_%s", "traefik", config.SanitiseAppName(domainName))
 
 	appEnvPath := path.Join(config.ABRA_DIR, "servers", internal.Domain, fmt.Sprintf("%s.env", internal.NewAppName))
-	if _, err := os.Stat(appEnvPath); !os.IsNotExist(err) {
+	if _, err := os.Stat(appEnvPath); os.IsNotExist(err) {
-		fmt.Println(fmt.Sprintf(`
+		logrus.Info(fmt.Sprintf("-t/--traefik specified, automatically deploying traefik to %s", internal.NewAppServer))
-	You specified "--traefik/-t" and that means that Abra will now try to
-	automatically create a new Traefik app on %s.
-	`, internal.NewAppServer))
-
-		tableCol := []string{"recipe", "domain", "server", "name"}
-		table := abraFormatter.CreateTable(tableCol)
-		table.Append([]string{internal.RecipeName, internal.Domain, internal.NewAppServer, internal.NewAppName})
-
 		if err := internal.NewAction(c); err != nil {
 			logrus.Fatal(err)
 		}
@@ -405,12 +478,12 @@ You may omit flags to avoid performing this provisioning logic.
 	ArgsUsage: "<domain> [<user>] [<port>]",
 	Action: func(c *cli.Context) error {
 		if c.Args().Len() > 0 && local || !internal.ValidateSubCmdFlags(c) {
-			err := errors.New("cannot use '<domain>' and '--local' together")
+			err := errors.New("cannot use <domain> and --local together")
 			internal.ShowSubcommandHelpAndError(c, err)
 		}
 
 		if sshAuth != "password" && sshAuth != "identity-file" {
-			err := errors.New("--ssh-auth only accepts 'identity-file' or 'password'")
+			err := errors.New("--ssh-auth only accepts identity-file or password")
 			internal.ShowSubcommandHelpAndError(c, err)
 		}
 
@@ -484,3 +557,23 @@ You may omit flags to avoid performing this provisioning logic.
 		return nil
 	},
 }
+
+// ensureLocalExecutable ensures that an executable is present on the local machine
+func ensureLocalExecutable(exe string) (bool, error) {
+	out, err := exec.Command("which", exe).Output()
+	if err != nil {
+		return false, err
+	}
+
+	return string(out) != "", nil
+}
+
+// ensureRemoteExecutable ensures that an executable is present on a remote machine
+func ensureRemoteExecutable(exe string, sshCl *ssh.Client) (bool, error) {
+	out, err := sshCl.Exec(fmt.Sprintf("which %s", exe))
+	if err != nil && string(out) != "" {
+		return false, err
+	}
+
+	return string(out) != "", nil
+}

cli/server/new.go

@@ -96,9 +96,21 @@ Please note, this server is not managed by Abra yet (i.e. "abra server ls" will
 not list this server)! You will need to assign a domain name record ("abra
 record new") and add the server to your Abra configuration ("abra server add")
 to have a working server that you can deploy Co-op Cloud apps to.
+
+When setting up domain name records, you probably want to set up the following
+2 A records. This supports deploying apps to your root domain (e.g.
+example.com) and other apps on sub-domains (e.g. foo.example.com,
+bar.example.com).
+
+    @  1800 IN A %s
+    *  1800 IN A %s
+
+"abra record new --auto" can help you do this quickly if you use a supported
+DNS provider.
+
 	`,
 		internal.HetznerCloudName, ip, rootPassword,
-		ip,
+		ip, ip, ip,
 	))
 
 	return nil
@@ -169,6 +181,15 @@ Please note, this server is not managed by Abra yet (i.e. "abra server ls" will
 not list this server)! You will need to assign a domain name record ("abra
 record new") and add the server to your Abra configuration ("abra server add")
 to have a working server that you can deploy Co-op Cloud apps to.
+
+When setting up domain name records, you probably want to set up the following
+2 A records. This supports deploying apps to your root domain (e.g.
+example.com) and other apps on sub-domains (e.g. foo.example.com,
+bar.example.com).
+
+    @  1800 IN A <your-capsul-ip>
+    *  1800 IN A <your-capsul-ip>
+
 	`, internal.CapsulName, resp.ID, internal.CapsulInstanceURL))
 
 	return nil

cli/server/remove.go

@@ -128,6 +128,22 @@ like tears in rain.
 			logrus.Fatal(err)
 		}
 
+		if !rmServer {
+			logrus.Warn("did not pass -s/--server for actual server deletion, prompting")
+
+			response := false
+			prompt := &survey.Confirm{
+				Message: "prompt to actual server deletion?",
+			}
+			if err := survey.AskOne(prompt, &response); err != nil {
+				logrus.Fatal(err)
+			}
+			if response {
+				logrus.Info("setting -s/--server and attempting to remove actual server")
+				rmServer = true
+			}
+		}
+
 		if rmServer {
 			if err := internal.EnsureServerProvider(); err != nil {
 				logrus.Fatal(err)

cli/upgrade.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"fmt"
 	"os/exec"
 
 	"coopcloud.tech/abra/cli/internal"
@@ -8,28 +9,36 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
-var RC bool
+var mainURL = "https://install.abra.coopcloud.tech"
-var RCFlag = &cli.BoolFlag{
+
-	Name:        "rc",
+var releaseCandidateURL = "https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/installer/installer"
-	Value:       false,
-	Destination: &RC,
-	Usage:       "Insatll the latest Release Candidate",
-}
 
 // UpgradeCommand upgrades abra in-place.
 var UpgradeCommand = &cli.Command{
 	Name:  "upgrade",
-	Usage: "Upgrade abra",
+	Usage: "Upgrade Abra",
-	Flags: []cli.Flag{RCFlag},
+	Description: `
+This command allows you to upgrade Abra in-place with the latest stable or
+release candidate.
+
+If you would like to install the latest release candidate, please pass the
+"--rc" option. Please bear in mind that the latest release candidate may have
+some catastrophic bugs contained in it. In any case, thank you very much for
+testing efforts!
+`,
+	Flags: []cli.Flag{internal.RCFlag},
 	Action: func(c *cli.Context) error {
-		cmd := exec.Command("bash", "-c", "curl -s https://install.abra.coopcloud.tech | bash")
+		cmd := exec.Command("bash", "-c", fmt.Sprintf("curl -s %s | bash", mainURL))
-		if RC {
+		if internal.RC {
-			cmd = exec.Command("bash", "-c", "curl -s https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/installer/installer | bash -s -- --rc")
+			cmd = exec.Command("bash", "-c", fmt.Sprintf("curl -s %s | bash -s -- --rc", releaseCandidateURL))
 		}
+
 		logrus.Debugf("attempting to run '%s'", cmd)
+
 		if err := internal.RunCmd(cmd); err != nil {
 			logrus.Fatal(err)
 		}
+
 		return nil
 	},
 }

cmd/abra/main.go

@@ -12,7 +12,6 @@ var Version string
 var Commit string
 
 func main() {
-	// If not set in the ld-flags
 	if Version == "" {
 		Version = "dev"
 	}

go.mod

@@ -7,9 +7,9 @@ require (
 	github.com/AlecAivazis/survey/v2 v2.3.2
 	github.com/Autonomic-Cooperative/godotenv v1.3.1-0.20210731170023-c37c0920d1a4
 	github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4
-	github.com/docker/cli v20.10.11+incompatible
+	github.com/docker/cli v20.10.12+incompatible
 	github.com/docker/distribution v2.7.1+incompatible
-	github.com/docker/docker v20.10.11+incompatible
+	github.com/docker/docker v20.10.12+incompatible
 	github.com/docker/go-units v0.4.0
 	github.com/go-git/go-git/v5 v5.4.2
 	github.com/hetznercloud/hcloud-go v1.33.1
@@ -17,7 +17,7 @@ require (
 	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6
 	github.com/olekukonko/tablewriter v0.0.5
 	github.com/pkg/errors v0.9.1
-	github.com/schollz/progressbar/v3 v3.8.3
+	github.com/schollz/progressbar/v3 v3.8.5
 	github.com/schultz-is/passgen v1.0.1
 	github.com/sirupsen/logrus v1.8.1
 	github.com/urfave/cli/v2 v2.3.0
@@ -34,6 +34,7 @@ require (
 	github.com/gliderlabs/ssh v0.3.3
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/gorilla/mux v1.8.0 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.0
 	github.com/kevinburke/ssh_config v1.1.0
 	github.com/libdns/gandi v1.0.2
 	github.com/libdns/libdns v0.2.1
@@ -42,6 +43,6 @@ require (
 	github.com/opencontainers/runc v1.0.2 // indirect
 	github.com/theupdateframework/notary v0.7.0 // indirect
 	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
-	golang.org/x/crypto v0.0.0-20210817164053-32db794688a5
+	golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3
-	golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359
+	golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e
 )

go.sum

@@ -260,14 +260,14 @@ github.com/dgrijalva/jwt-go v0.0.0-20170104182250-a601269ab70c/go.mod h1:E3ru+11
 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/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
-github.com/docker/cli v20.10.11+incompatible h1:tXU1ezXcruZQRrMP8RN2z9N91h+6egZTS1gsPsKantc=
+github.com/docker/cli v20.10.12+incompatible h1:lZlz0uzG+GH+c0plStMUdF/qk3ppmgnswpR5EbqzVGA=
-github.com/docker/cli v20.10.11+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v20.10.12+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/docker v20.10.11+incompatible h1:OqzI/g/W54LczvhnccGqniFoQghHx3pklbLuhfXpqGo=
+github.com/docker/docker v20.10.12+incompatible h1:CEeNmFM0QZIsJCZKMkZx0ZcahTiewkrgiwfYD+dfl1U=
-github.com/docker/docker v20.10.11+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v20.10.12+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/docker-credential-helpers v0.6.4 h1:axCks+yV+2MR3/kZhAmy07yC56WZ2Pwu/fKWtKuZB0o=
 github.com/docker/docker-credential-helpers v0.6.4/go.mod h1:ofX3UI0Gz1TteYBjtgs07O36Pyasyp66D2uKT7H8W1c=
 github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c h1:lzqkGL9b3znc+ZUgi7FlLnqjQhcXxkNM/quxIjBVMD0=
@@ -444,8 +444,14 @@ github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc
 github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4=
 github.com/hashicorp/errwrap v0.0.0-20141028054710-7554cd9344ce/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-cleanhttp v0.5.1 h1:dH3aiDG9Jvb5r5+bYHsikaOUIpcM0xvgMXVoDkXMzJM=
+github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-hclog v0.9.2 h1:CG6TE5H9/JXsFWJCfoIVpKFIkFe6ysEuHirp4DxCsHI=
+github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
 github.com/hashicorp/go-multierror v0.0.0-20161216184304-ed905158d874/go.mod h1:JMRHfdO9jKNzS/+BTlxCjKNQHg/jZAft8U7LloJvN7I=
 github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/hashicorp/go-retryablehttp v0.7.0 h1:eu1EI/mbirUgP5C8hVsTNaGZreBDlYiwC1FZWkvQPQ4=
+github.com/hashicorp/go-retryablehttp v0.7.0/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
@@ -689,8 +695,8 @@ github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/safchain/ethtool v0.0.0-20190326074333-42ed695e3de8/go.mod h1:Z0q5wiBQGYcxhMZ6gUqHn6pYNLypFAvaL3UvgZLR0U4=
 github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
-github.com/schollz/progressbar/v3 v3.8.3 h1:FnLGl3ewlDUP+YdSwveXBaXs053Mem/du+wr7XSYKl8=
+github.com/schollz/progressbar/v3 v3.8.5 h1:VcmmNRO+eFN3B0m5dta6FXYXY+MEJmXdWoIS+jjssQM=
-github.com/schollz/progressbar/v3 v3.8.3/go.mod h1:pWnVCjSBZsT2X3nx9HfRdnCDrpbevliMeoEVhStwHko=
+github.com/schollz/progressbar/v3 v3.8.5/go.mod h1:ewO25kD7ZlaJFTvMeOItkOZa8kXu1UvFs379htE8HMQ=
 github.com/schultz-is/passgen v1.0.1 h1:wUINzqW1Xmmy3yREHR6YTj+83VlFYjj2DIDMHzIi5TQ=
 github.com/schultz-is/passgen v1.0.1/go.mod h1:NnqzT2aSfvyheNQvBtlLUa0YlPFLDj60Jw2DZVwqiJk=
 github.com/seccomp/libseccomp-golang v0.9.1/go.mod h1:GbW5+tmTXfcxTToHLXlScSlAvWlF4P2Ca7zGrPiEpWo=
@@ -823,8 +829,8 @@ golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWP
 golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ=
+golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3 h1:0es+/5331RGQPcXlMfP+WrnIIS6dNnNRe0WB02W0F4M=
-golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 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=
@@ -890,8 +896,9 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY
 golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210326060303-6b1517762897 h1:KrsHThm5nFk34YtATK1LsThyGhGbGe1olrte/HInHvs=
 golang.org/x/net v0.0.0-20210326060303-6b1517762897/go.mod h1:uSPa2vr4CLtc/ILN5odXGNXS6mhrKVzTaCXzk9m6W3k=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2 h1:CIJ76btIcR3eFI5EgSo6k1qKw9KJexJuRLI9G7Hp5wE=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 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=
@@ -969,27 +976,29 @@ golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210324051608-47abb6519492/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-20210502180810-71e4cd670f79/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210910150752-751e447fb3d0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 h1:2B5p2L5IfGiD7+b9BOoRMC6DgObAVZV+Fsp050NqXik=
 golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 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-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY=
-golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
-golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 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=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.4 h1:0YWbFKbhXG/wIiuHDSKpS0Iy7FSA+u45VtBMfQcFTTc=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=

pkg/app/app.go

@@ -57,9 +57,9 @@ func DeployedVersions(ctx context.Context, cl *apiclient.Client, app config.App)
 	deployed := len(services) > 0
 
 	if deployed {
-		logrus.Debugf("detected '%s' as deployed versions of '%s'", appSpec, app.Name)
+		logrus.Debugf("detected %s as deployed versions of %s", appSpec, app.Name)
 	} else {
-		logrus.Debugf("detected '%s' as not deployed", app.Name)
+		logrus.Debugf("detected %s as not deployed", app.Name)
 	}
 
 	return appSpec, len(services) > 0, nil
@@ -71,15 +71,15 @@ func ParseVersionLabel(label string) (string, string) {
 	idx := strings.LastIndex(label, "-")
 	version := label[:idx]
 	digest := label[idx+1:]
-	logrus.Debugf("parsed '%s' as version from '%s'", version, label)
+	logrus.Debugf("parsed %s as version from %s", version, label)
-	logrus.Debugf("parsed '%s' as digest from '%s'", digest, label)
+	logrus.Debugf("parsed %s as digest from %s", digest, label)
 	return version, digest
 }
 
-// ParseVersionName parses a $STACK_NAME_$SERVICE_NAME service label.
+// ParseServiceName parses a $STACK_NAME_$SERVICE_NAME service label.
 func ParseServiceName(label string) string {
 	idx := strings.LastIndex(label, "_")
 	serviceName := label[idx+1:]
-	logrus.Debugf("parsed '%s' as service name from '%s'", serviceName, label)
+	logrus.Debugf("parsed %s as service name from %s", serviceName, label)
 	return serviceName
 }

pkg/autocomplete/autocomplete.go

@@ -0,0 +1,42 @@
+package autocomplete
+
+import (
+	"fmt"
+
+	"coopcloud.tech/abra/pkg/catalogue"
+	"coopcloud.tech/abra/pkg/config"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+// AppNameComplete copletes app names
+func AppNameComplete(c *cli.Context) {
+	appNames, err := config.GetAppNames()
+	if err != nil {
+		logrus.Warn(err)
+	}
+
+	if c.NArg() > 0 {
+		return
+	}
+
+	for _, a := range appNames {
+		fmt.Println(a)
+	}
+}
+
+// RecipeNameComplete completes recipe names
+func RecipeNameComplete(c *cli.Context) {
+	catl, err := catalogue.ReadRecipeCatalogue()
+	if err != nil {
+		logrus.Warn(err)
+	}
+
+	if c.NArg() > 0 {
+		return
+	}
+
+	for name := range catl {
+		fmt.Println(name)
+	}
+}

pkg/catalogue/catalogue.go

@@ -7,12 +7,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
-	"net/http"
 	"os"
 	"path"
 	"strings"
 	"time"
 
+	"coopcloud.tech/abra/cli/formatter"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/recipe"
@@ -46,6 +46,7 @@ type features struct {
 	Image       image  `json:"image"`
 	Status      int    `json:"status"`
 	Tests       string `json:"tests"`
+	SSO         string `json:"sso"`
 }
 
 // tag represents a git tag.
@@ -88,7 +89,7 @@ func (r RecipeMeta) LatestVersion() string {
 		version = tag
 	}
 
-	logrus.Debugf("choosing '%s' as latest version of '%s'", version, r.Name)
+	logrus.Debugf("choosing %s as latest version of %s", version, r.Name)
 
 	return version
 }
@@ -122,7 +123,7 @@ func (r ByRecipeName) Less(i, j int) bool {
 // recipeCatalogueFSIsLatest checks whether the recipe catalogue stored locally
 // is up to date.
 func recipeCatalogueFSIsLatest() (bool, error) {
-	httpClient := &http.Client{Timeout: web.Timeout}
+	httpClient := web.NewHTTPRetryClient()
 	res, err := httpClient.Head(RecipeCatalogueURL)
 	if err != nil {
 		return false, err
@@ -151,7 +152,7 @@ func recipeCatalogueFSIsLatest() (bool, error) {
 		return false, nil
 	}
 
-	logrus.Debug("file system cached recipe catalogue is up-to-date")
+	logrus.Debug("file system cached recipe catalogue is now up-to-date")
 
 	return true, nil
 }
@@ -192,7 +193,7 @@ func readRecipeCatalogueFS(target interface{}) error {
 		return err
 	}
 
-	logrus.Debugf("read recipe catalogue from file system cache in '%s'", config.APPS_JSON)
+	logrus.Debugf("read recipe catalogue from file system cache in %s", config.APPS_JSON)
 
 	return nil
 }
@@ -208,17 +209,19 @@ func readRecipeCatalogueWeb(target interface{}) error {
 		return err
 	}
 
-	if err := ioutil.WriteFile(config.APPS_JSON, recipesJSON, 0644); err != nil {
+	if err := ioutil.WriteFile(config.APPS_JSON, recipesJSON, 0764); err != nil {
 		return err
 	}
 
-	logrus.Debugf("read recipe catalogue from web at '%s'", RecipeCatalogueURL)
+	logrus.Debugf("read recipe catalogue from web at %s", RecipeCatalogueURL)
 
 	return nil
 }
 
 // VersionsOfService lists the version of a service.
 func VersionsOfService(recipe, serviceName string) ([]string, error) {
+	var versions []string
+
 	catalogue, err := ReadRecipeCatalogue()
 	if err != nil {
 		return nil, err
@@ -226,10 +229,9 @@ func VersionsOfService(recipe, serviceName string) ([]string, error) {
 
 	rec, ok := catalogue[recipe]
 	if !ok {
-		return nil, fmt.Errorf("recipe '%s' does not exist?", recipe)
+		return versions, nil
 	}
 
-	versions := []string{}
 	alreadySeen := make(map[string]bool)
 	for _, serviceVersion := range rec.Versions {
 		for tag := range serviceVersion {
@@ -240,7 +242,7 @@ func VersionsOfService(recipe, serviceName string) ([]string, error) {
 		}
 	}
 
-	logrus.Debugf("detected versions '%s' for '%s'", strings.Join(versions, ", "), recipe)
+	logrus.Debugf("detected versions %s for %s", strings.Join(versions, ", "), recipe)
 
 	return versions, nil
 }
@@ -254,7 +256,7 @@ func GetRecipeMeta(recipeName string) (RecipeMeta, error) {
 
 	recipeMeta, ok := catl[recipeName]
 	if !ok {
-		err := fmt.Errorf("recipe '%s' does not exist?", recipeName)
+		err := fmt.Errorf("recipe %s does not exist?", recipeName)
 		return RecipeMeta{}, err
 	}
 
@@ -262,7 +264,7 @@ func GetRecipeMeta(recipeName string) (RecipeMeta, error) {
 		return RecipeMeta{}, err
 	}
 
-	logrus.Debugf("recipe metadata retrieved for '%s'", recipeName)
+	logrus.Debugf("recipe metadata retrieved for %s", recipeName)
 
 	return recipeMeta, nil
 }
@@ -349,18 +351,20 @@ func ReadReposMetadata() (RepoCatalogue, error) {
 	reposMeta := make(RepoCatalogue)
 
 	pageIdx := 1
+	bar := formatter.CreateProgressbar(-1, "retrieving recipe repos list from git.coopcloud.tech...")
 	for {
 		var reposList []RepoMeta
 
 		pagedURL := fmt.Sprintf("%s?page=%v", ReposMetadataURL, pageIdx)
 
-		logrus.Debugf("fetching repo metadata from '%s'", pagedURL)
+		logrus.Debugf("fetching repo metadata from %s", pagedURL)
 
 		if err := web.ReadJSON(pagedURL, &reposList); err != nil {
 			return reposMeta, err
 		}
 
 		if len(reposList) == 0 {
+			bar.Add(1)
 			break
 		}
 
@@ -369,18 +373,144 @@ func ReadReposMetadata() (RepoCatalogue, error) {
 		}
 
 		pageIdx++
+		bar.Add(1)
 	}
 
 	return reposMeta, nil
 }
 
+func GetStringInBetween(str, start, end string) (result string, err error) {
+	// GetStringInBetween returns empty string if no start or end string found
+	s := strings.Index(str, start)
+	if s == -1 {
+		return "", fmt.Errorf("marker string '%s' not found", start)
+	}
+	s += len(start)
+	e := strings.Index(str[s:], end)
+	if e == -1 {
+		return "", fmt.Errorf("end marker '%s' not found", end)
+	}
+	return str[s : s+e], nil
+}
+
+func GetImageMetadata(imageRowString, recipeName string) (image, error) {
+	img := image{}
+
+	imgFields := strings.Split(imageRowString, ",")
+
+	for i, elem := range imgFields {
+		imgFields[i] = strings.TrimSpace(elem)
+	}
+
+	if len(imgFields) < 3 {
+		if imageRowString != "" {
+			logrus.Warnf("%s image meta has incorrect format: %s", recipeName, imageRowString)
+		} else {
+			logrus.Warnf("%s image meta is empty?", recipeName)
+		}
+		return img, nil
+	}
+
+	img.Rating = imgFields[1]
+	img.Source = imgFields[2]
+
+	imgString := imgFields[0]
+
+	imageName, err := GetStringInBetween(imgString, "[", "]")
+	if err != nil {
+		logrus.Fatal(err)
+	}
+	img.Image = strings.ReplaceAll(imageName, "`", "")
+
+	imageURL, err := GetStringInBetween(imgString, "(", ")")
+	if err != nil {
+		logrus.Fatal(err)
+	}
+	img.URL = imageURL
+
+	return img, nil
+}
+
+func GetRecipeFeaturesAndCategory(recipeName string) (features, string, error) {
+	feat := features{}
+
+	var category string
+
+	readmePath := path.Join(config.ABRA_DIR, "apps", recipeName, "README.md")
+
+	logrus.Debugf("attempting to open %s for recipe metadata parsing", readmePath)
+
+	readmeFS, err := ioutil.ReadFile(readmePath)
+	if err != nil {
+		return feat, category, err
+	}
+
+	readmeMetadata, err := GetStringInBetween( // Find text between delimiters
+		string(readmeFS),
+		"<!-- metadata -->", "<!-- endmetadata -->",
+	)
+	if err != nil {
+		return feat, category, err
+	}
+
+	readmeLines := strings.Split( // Array item from lines
+		strings.ReplaceAll( // Remove \t tabs
+			readmeMetadata, "\t", "",
+		),
+		"\n")
+
+	for _, val := range readmeLines {
+		if strings.Contains(val, "**Category**") {
+			category = strings.TrimSpace(
+				strings.TrimPrefix(val, "* **Category**:"),
+			)
+		}
+		if strings.Contains(val, "**Backups**") {
+			feat.Backups = strings.TrimSpace(
+				strings.TrimPrefix(val, "* **Backups**:"),
+			)
+		}
+		if strings.Contains(val, "**Email**") {
+			feat.Email = strings.TrimSpace(
+				strings.TrimPrefix(val, "* **Email**:"),
+			)
+		}
+		if strings.Contains(val, "**SSO**") {
+			feat.SSO = strings.TrimSpace(
+				strings.TrimPrefix(val, "* **SSO**:"),
+			)
+		}
+		if strings.Contains(val, "**Healthcheck**") {
+			feat.Healthcheck = strings.TrimSpace(
+				strings.TrimPrefix(val, "* **Healthcheck**:"),
+			)
+		}
+		if strings.Contains(val, "**Tests**") {
+			feat.Tests = strings.TrimSpace(
+				strings.TrimPrefix(val, "* **Tests**:"),
+			)
+		}
+		if strings.Contains(val, "**Image**") {
+			imageMetadata, err := GetImageMetadata(strings.TrimSpace(
+				strings.TrimPrefix(val, "* **Image**:"),
+			), recipeName)
+			if err != nil {
+				continue
+			}
+			feat.Image = imageMetadata
+		}
+	}
+
+	return feat, category, nil
+}
+
 // GetRecipeVersions retrieves all recipe versions.
 func GetRecipeVersions(recipeName string) (RecipeVersions, error) {
 	versions := RecipeVersions{}
 
 	recipeDir := path.Join(config.ABRA_DIR, "apps", recipeName)
 
-	logrus.Debugf("attempting to open git repository in '%s'", recipeDir)
+	logrus.Debugf("attempting to open git repository in %s", recipeDir)
 
 	repo, err := git.PlainOpen(recipeDir)
 	if err != nil {
@@ -400,7 +530,7 @@ func GetRecipeVersions(recipeName string) (RecipeVersions, error) {
 	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)
+		logrus.Debugf("processing %s for %s", tag, recipeName)
 
 		checkOutOpts := &git.CheckoutOptions{
 			Create: false,
@@ -408,17 +538,22 @@ func GetRecipeVersions(recipeName string) (RecipeVersions, error) {
 			Branch: plumbing.ReferenceName(ref.Name()),
 		}
 		if err := worktree.Checkout(checkOutOpts); err != nil {
-			logrus.Debugf("failed to check out '%s' in '%s'", tag, recipeDir)
+			logrus.Debugf("failed to check out %s in %s", tag, recipeDir)
 			return err
 		}
 
-		logrus.Debugf("successfully checked out '%s' in '%s'", ref.Name(), recipeDir)
+		logrus.Debugf("successfully checked out %s in %s", ref.Name(), recipeDir)
 
 		recipe, err := recipe.Get(recipeName)
 		if err != nil {
 			return err
 		}
 
+		cl, err := client.New("default") // only required for docker.io registry calls
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
 		versionMeta := make(map[string]ServiceMeta)
 		for _, service := range recipe.Config.Services {
 
@@ -432,9 +567,21 @@ func GetRecipeVersions(recipeName string) (RecipeVersions, error) {
 				path = strings.Split(path, "/")[1]
 			}
 
-			digest, err := client.GetTagDigest(img)
+			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
+			}
+
+			logrus.Debugf("looking up image: %s from %s", img, path)
+
+			digest, err := client.GetTagDigest(cl, img)
 			if err != nil {
-				return err
+				logrus.Warn(err)
+				continue
 			}
 
 			versionMeta[service.Name] = ServiceMeta{
@@ -443,7 +590,7 @@ func GetRecipeVersions(recipeName string) (RecipeVersions, error) {
 				Tag:    img.(reference.NamedTagged).Tag(),
 			}
 
-			logrus.Debugf("collecting digest: '%s', image: '%s', tag: '%s'", digest, path, tag)
+			logrus.Debugf("collecting digest: %s, image: %s, tag: %s", digest, path, tag)
 		}
 
 		versions = append(versions, map[string]map[string]ServiceMeta{tag: versionMeta})
@@ -456,7 +603,7 @@ func GetRecipeVersions(recipeName string) (RecipeVersions, error) {
 	branch := "master"
 	if _, err := repo.Branch("master"); err != nil {
 		if _, err := repo.Branch("main"); err != nil {
-			logrus.Debugf("failed to select branch in '%s'", recipeDir)
+			logrus.Debugf("failed to select branch in %s", recipeDir)
 			logrus.Fatal(err)
 		}
 		branch = "main"
@@ -469,25 +616,20 @@ func GetRecipeVersions(recipeName string) (RecipeVersions, error) {
 		Branch: plumbing.ReferenceName(refName),
 	}
 	if err := worktree.Checkout(checkOutOpts); err != nil {
-		logrus.Debugf("failed to check out '%s' in '%s'", branch, recipeDir)
+		logrus.Debugf("failed to check out %s in %s", branch, recipeDir)
 		logrus.Fatal(err)
 	}
 
-	logrus.Debugf("switched back to '%s' in '%s'", branch, recipeDir)
+	logrus.Debugf("switched back to %s in %s", branch, recipeDir)
-	logrus.Debugf("collected '%s' for '%s'", versions, recipeName)
+	logrus.Debugf("collected %s for %s", versions, recipeName)
 
 	return versions, nil
 }
 
 // GetRecipeCatalogueVersions list the recipe versions listed in the recipe catalogue.
-func GetRecipeCatalogueVersions(recipeName string) ([]string, error) {
+func GetRecipeCatalogueVersions(recipeName string, catl RecipeCatalogue) ([]string, error) {
 	var versions []string
 
-	catl, err := ReadRecipeCatalogue()
-	if err != nil {
-		return versions, err
-	}
-
 	if recipeMeta, exists := catl[recipeName]; exists {
 		for _, versionMeta := range recipeMeta.Versions {
 			for tag := range versionMeta {

pkg/client/registry.go

@@ -5,10 +5,14 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"os"
 	"strings"
 
 	"coopcloud.tech/abra/pkg/web"
 	"github.com/docker/distribution/reference"
+	"github.com/docker/docker/client"
+	"github.com/hashicorp/go-retryablehttp"
+	"github.com/sirupsen/logrus"
 )
 
 type RawTag struct {
@@ -32,15 +36,25 @@ func GetRegistryTags(image string) (RawTags, error) {
 }
 
 // getRegv2Token retrieves a registry v2 authentication token.
-func getRegv2Token(image reference.Named) (string, error) {
+func getRegv2Token(cl *client.Client, image reference.Named) (string, error) {
 	img := reference.Path(image)
-	authTokenURL := fmt.Sprintf("https://auth.docker.io/token?service=registry.docker.io&scope=repository:%s:pull", img)
+	tokenURL := "https://auth.docker.io/token"
-	req, err := http.NewRequest("GET", authTokenURL, nil)
+	values := fmt.Sprintf("service=registry.docker.io&scope=repository:%s:pull", img)
+
+	username, userOk := os.LookupEnv("DOCKER_USERNAME")
+	password, passOk := os.LookupEnv("DOCKER_PASSWORD")
+	if userOk && passOk {
+		logrus.Debugf("using docker log in credentials for registry token request")
+		values = fmt.Sprintf("%s&grant_type=password&client_id=coopcloud.tech&username=%s&password=%s", values, username, password)
+	}
+
+	fullURL := fmt.Sprintf("%s?%s", tokenURL, values)
+	req, err := retryablehttp.NewRequest("GET", fullURL, nil)
 	if err != nil {
 		return "", err
 	}
 
-	client := &http.Client{Timeout: web.Timeout}
+	client := web.NewHTTPRetryClient()
 	res, err := client.Do(req)
 	if err != nil {
 		return "", err
@@ -60,9 +74,10 @@ func getRegv2Token(image reference.Named) (string, error) {
 	}
 
 	tokenRes := struct {
-		Token  string
+		AccessToken string `json:"access_token"`
-		Expiry string
+		Expiry      int    `json:"expires_in"`
-		Issued string
+		Issued      string `json:"issued_at"`
+		Token       string `json:"token"`
 	}{}
 
 	if err := json.Unmarshal(body, &tokenRes); err != nil {
@@ -73,21 +88,25 @@ func getRegv2Token(image reference.Named) (string, error) {
 }
 
 // GetTagDigest retrieves an image digest from a v2 registry
-func GetTagDigest(image reference.Named) (string, error) {
+func GetTagDigest(cl *client.Client, image reference.Named) (string, error) {
 	img := reference.Path(image)
 	tag := image.(reference.NamedTagged).Tag()
 	manifestURL := fmt.Sprintf("https://index.docker.io/v2/%s/manifests/%s", img, tag)
 
-	req, err := http.NewRequest("GET", manifestURL, nil)
+	req, err := retryablehttp.NewRequest("GET", manifestURL, nil)
 	if err != nil {
 		return "", err
 	}
 
-	token, err := getRegv2Token(image)
+	token, err := getRegv2Token(cl, image)
 	if err != nil {
 		return "", err
 	}
 
+	if token == "" {
+		return "", fmt.Errorf("unable to retrieve registry token?")
+	}
+
 	req.Header = http.Header{
 		"Accept": []string{
 			"application/vnd.docker.distribution.manifest.v2+json",
@@ -96,7 +115,7 @@ func GetTagDigest(image reference.Named) (string, error) {
 		"Authorization": []string{fmt.Sprintf("Bearer %s", token)},
 	}
 
-	client := &http.Client{Timeout: web.Timeout}
+	client := web.NewHTTPRetryClient()
 	res, err := client.Do(req)
 	if err != nil {
 		return "", err

pkg/compose/compose.go

@@ -71,7 +71,7 @@ func UpdateTag(pattern, image, tag, recipeName string) error {
 
 				logrus.Debugf("updating '%s' to '%s' in '%s'", old, new, compose.Filename)
 
-				if err := ioutil.WriteFile(compose.Filename, []byte(replacedBytes), 0644); err != nil {
+				if err := ioutil.WriteFile(compose.Filename, []byte(replacedBytes), 0764); err != nil {
 					return err
 				}
 			}
@@ -88,7 +88,7 @@ func UpdateLabel(pattern, serviceName, label, recipeName string) error {
 		return err
 	}
 
-	logrus.Debugf("considering '%s' config(s) for label update", strings.Join(composeFiles, ", "))
+	logrus.Debugf("considering %s config(s) for label update", strings.Join(composeFiles, ", "))
 
 	for _, composeFile := range composeFiles {
 		opts := stack.Deploy{Composefiles: []string{composeFile}}
@@ -130,19 +130,25 @@ func UpdateLabel(pattern, serviceName, label, recipeName string) error {
 				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), 0644); err != nil {
+				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, cannot continue...")
-			logrus.Fatalf("add '%s' manually, automagic insertion not supported yet", label)
+			logrus.Fatalf("add \"%s\" manually, automagic insertion not supported yet", label)
 		}
-
 	}
 
 	return nil

pkg/config/app.go

@@ -1,7 +1,6 @@
 package config
 
 import (
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -112,17 +111,17 @@ func readAppEnvFile(appFile AppFile, name AppName) (App, error) {
 
 // newApp creates new App object
 func newApp(env AppEnv, name string, appFile AppFile) (App, error) {
-	// Checking for type as it is required - apps wont work without it
 	domain := env["DOMAIN"]
-	apptype, ok := env["TYPE"]
+
-	if !ok {
+	appType, exists := env["TYPE"]
-		return App{}, errors.New("missing TYPE variable")
+	if !exists {
+		return App{}, fmt.Errorf("%s is missing the TYPE env var", name)
 	}
 
 	return App{
 		Name:   name,
 		Domain: domain,
-		Type:   apptype,
+		Type:   appType,
 		Env:    env,
 		Server: appFile.Server,
 		Path:   appFile.Path,
@@ -136,14 +135,14 @@ func LoadAppFiles(servers ...string) (AppFiles, error) {
 		if servers[0] == "" {
 			// Empty servers flag, one string will always be passed
 			var err error
-			servers, err = getAllFoldersInDirectory(ABRA_SERVER_FOLDER)
+			servers, err = GetAllFoldersInDirectory(ABRA_SERVER_FOLDER)
 			if err != nil {
 				return nil, err
 			}
 		}
 	}
 
-	logrus.Debugf("collecting metadata from '%v' servers: '%s'", len(servers), strings.Join(servers, ", "))
+	logrus.Debugf("collecting metadata from %v servers: %s", len(servers), strings.Join(servers, ", "))
 
 	for _, server := range servers {
 		serverDir := path.Join(ABRA_SERVER_FOLDER, server)
@@ -169,7 +168,7 @@ func LoadAppFiles(servers ...string) (AppFiles, error) {
 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)
+		return App{}, fmt.Errorf("cannot find app with name %s", name)
 	}
 
 	app, err := readAppEnvFile(appFile, name)
@@ -249,27 +248,27 @@ func GetAppNames() ([]string, error) {
 }
 
 // TemplateAppEnvSample copies the example env file for the app into the users env files
-func TemplateAppEnvSample(appType, appName, server, domain, recipe string) error {
+func TemplateAppEnvSample(recipe, appName, server, domain string) error {
-	envSamplePath := path.Join(ABRA_DIR, "apps", appType, ".env.sample")
+	envSamplePath := path.Join(ABRA_DIR, "apps", recipe, ".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); err == nil {
+	if _, err := os.Stat(appEnvPath); os.IsExist(err) {
 		return fmt.Errorf("%s already exists?", appEnvPath)
 	}
 
 	envSample = []byte(strings.Replace(string(envSample), fmt.Sprintf("%s.example.com", recipe), domain, -1))
 	envSample = []byte(strings.Replace(string(envSample), "example.com", domain, -1))
 
-	err = ioutil.WriteFile(appEnvPath, envSample, 0755)
+	err = ioutil.WriteFile(appEnvPath, envSample, 0664)
 	if err != nil {
 		return err
 	}
 
-	logrus.Debugf("copied '%s' to '%s'", envSamplePath, appEnvPath)
+	logrus.Debugf("copied %s to %s", envSamplePath, appEnvPath)
 
 	return nil
 }
@@ -325,7 +324,7 @@ func GetAppStatuses(appFiles AppFiles) (map[string]map[string]string, error) {
 		}
 	}
 
-	logrus.Debugf("retrieved app statuses: '%s'", statuses)
+	logrus.Debugf("retrieved app statuses: %s", statuses)
 
 	return statuses, nil
 }
@@ -344,13 +343,13 @@ func GetAppComposeFiles(recipe string, appEnv AppEnv) ([]string, error) {
 
 	composeFileEnvVar := appEnv["COMPOSE_FILE"]
 	envVars := strings.Split(composeFileEnvVar, ":")
-	logrus.Debugf("COMPOSE_FILE detected ('%s'), loading '%s'", composeFileEnvVar, strings.Join(envVars, ", "))
+	logrus.Debugf("COMPOSE_FILE detected (%s), loading %s", composeFileEnvVar, strings.Join(envVars, ", "))
 	for _, file := range strings.Split(composeFileEnvVar, ":") {
 		path := fmt.Sprintf("%s/%s/%s", APPS_DIR, recipe, file)
 		composeFiles = append(composeFiles, path)
 	}
 
-	logrus.Debugf("retrieved '%s' configs for '%s'", strings.Join(composeFiles, ", "), recipe)
+	logrus.Debugf("retrieved %s configs for %s", strings.Join(composeFiles, ", "), recipe)
 
 	return composeFiles, nil
 }
@@ -364,7 +363,7 @@ func GetAppComposeConfig(recipe string, opts stack.Deploy, appEnv AppEnv) (*comp
 		return &composetypes.Config{}, err
 	}
 
-	logrus.Debugf("retrieved '%s' for '%s'", compose.Filename, recipe)
+	logrus.Debugf("retrieved %s for %s", compose.Filename, recipe)
 
 	return compose, nil
 }

pkg/config/env.go

@@ -16,7 +16,7 @@ import (
 
 var ABRA_DIR = os.ExpandEnv("$HOME/.abra")
 var ABRA_SERVER_FOLDER = path.Join(ABRA_DIR, "servers")
-var APPS_JSON = path.Join(ABRA_DIR, "apps.json")
+var APPS_JSON = path.Join(ABRA_DIR, "catalogue", "recipes.json")
 var APPS_DIR = path.Join(ABRA_DIR, "apps")
 var REPOS_BASE_URL = "https://git.coopcloud.tech/coop-cloud"
 
@@ -24,12 +24,12 @@ var REPOS_BASE_URL = "https://git.coopcloud.tech/coop-cloud"
 func GetServers() ([]string, error) {
 	var servers []string
 
-	servers, err := getAllFoldersInDirectory(ABRA_SERVER_FOLDER)
+	servers, err := GetAllFoldersInDirectory(ABRA_SERVER_FOLDER)
 	if err != nil {
 		return servers, err
 	}
 
-	logrus.Debugf("retrieved '%v' servers: '%s'", len(servers), servers)
+	logrus.Debugf("retrieved %v servers: %s", len(servers), servers)
 
 	return servers, nil
 }
@@ -43,20 +43,20 @@ func ReadEnv(filePath string) (AppEnv, error) {
 		return nil, err
 	}
 
-	logrus.Debugf("read '%s' from '%s'", envFile, filePath)
+	logrus.Debugf("read %s from %s", envFile, filePath)
 
 	return envFile, nil
 }
 
 // ReadServerNames retrieves all server names.
 func ReadServerNames() ([]string, error) {
-	serverNames, err := getAllFoldersInDirectory(ABRA_SERVER_FOLDER)
+	serverNames, err := GetAllFoldersInDirectory(ABRA_SERVER_FOLDER)
 
 	if err != nil {
 		return nil, err
 	}
 
-	logrus.Debugf("read '%s' from '%s'", strings.Join(serverNames, ","), ABRA_SERVER_FOLDER)
+	logrus.Debugf("read %s from %s", strings.Join(serverNames, ","), ABRA_SERVER_FOLDER)
 
 	return serverNames, nil
 }
@@ -80,7 +80,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)
+			logrus.Warningf("broken symlink in your abra config folders: %s", filePath)
 		} else {
 			realFile, err := os.Stat(realPath)
 			if err != nil {
@@ -95,8 +95,8 @@ func getAllFilesInDirectory(directory string) ([]fs.FileInfo, error) {
 	return realFiles, nil
 }
 
-// getAllFoldersInDirectory returns both folder and symlink paths
+// GetAllFoldersInDirectory returns both folder and symlink paths
-func getAllFoldersInDirectory(directory string) ([]string, error) {
+func GetAllFoldersInDirectory(directory string) ([]string, error) {
 	var folders []string
 
 	files, err := ioutil.ReadDir(directory)
@@ -104,7 +104,7 @@ func getAllFoldersInDirectory(directory string) ([]string, error) {
 		return nil, err
 	}
 	if len(files) == 0 {
-		return nil, fmt.Errorf("directory is empty: '%s'", directory)
+		return nil, fmt.Errorf("directory is empty: %s", directory)
 	}
 
 	for _, file := range files {
@@ -113,7 +113,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)
+				logrus.Warningf("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())
@@ -127,8 +127,8 @@ func getAllFoldersInDirectory(directory string) ([]string, error) {
 // EnsureAbraDirExists checks for the abra config folder and throws error if not
 func EnsureAbraDirExists() error {
 	if _, err := os.Stat(ABRA_DIR); os.IsNotExist(err) {
-		logrus.Debugf("'%s' does not exist, creating it", ABRA_DIR)
+		logrus.Debugf("%s does not exist, creating it", ABRA_DIR)
-		if err := os.Mkdir(ABRA_DIR, 0777); err != nil {
+		if err := os.Mkdir(ABRA_DIR, 0764); err != nil {
 			return err
 		}
 	}
@@ -161,7 +161,7 @@ func ReadAbraShEnvVars(abraSh string) (map[string]string, error) {
 		}
 	}
 
-	logrus.Debugf("read '%s' from '%s'", envVars, abraSh)
+	logrus.Debugf("read %s from %s", envVars, abraSh)
 
 	return envVars, nil
 }

pkg/container/container.go

@@ -0,0 +1,70 @@
+package container
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	abraFormatter "coopcloud.tech/abra/cli/formatter"
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/client"
+	"github.com/sirupsen/logrus"
+)
+
+// GetContainer retrieves a container. If prompt is true and the retrievd count
+// of containers does not match expectedN, then a prompt is presented to let
+// the user choose.
+func GetContainer(c context.Context, cl *client.Client, filters filters.Args, prompt bool) (types.Container, error) {
+	containerOpts := types.ContainerListOptions{Filters: filters}
+	containers, err := cl.ContainerList(c, containerOpts)
+	if err != nil {
+		return types.Container{}, err
+	}
+
+	if len(containers) == 0 {
+		filter := filters.Get("name")[0]
+		return types.Container{}, fmt.Errorf("no containers matching the %v filter found?", filter)
+	}
+
+	if len(containers) != 1 {
+		var containersRaw []string
+		for _, container := range containers {
+			containerName := strings.Join(container.Names, " ")
+			trimmed := strings.TrimPrefix(containerName, "/")
+			created := abraFormatter.HumanDuration(container.Created)
+			containersRaw = append(containersRaw, fmt.Sprintf("%s (created %v)", trimmed, created))
+		}
+
+		if !prompt {
+			err := fmt.Errorf("expected 1 container but found %v: %s", len(containers), strings.Join(containersRaw, " "))
+			return types.Container{}, err
+		}
+
+		logrus.Warnf("ambiguous container list received, prompting for input")
+
+		var response string
+		prompt := &survey.Select{
+			Message: "which container are you looking for?",
+			Options: containersRaw,
+		}
+
+		if err := survey.AskOne(prompt, &response); err != nil {
+			return types.Container{}, err
+		}
+
+		chosenContainer := strings.TrimSpace(strings.Split(response, " ")[0])
+		for _, container := range containers {
+			containerName := strings.TrimSpace(strings.Join(container.Names, " "))
+			trimmed := strings.TrimPrefix(containerName, "/")
+			if trimmed == chosenContainer {
+				return container, nil
+			}
+		}
+
+		logrus.Panic("failed to match chosen container")
+	}
+
+	return containers[0], nil
+}

pkg/git/clone.go

@@ -47,6 +47,16 @@ func EnsureUpToDate(dir string) error {
 		return err
 	}
 
+	recipeName := filepath.Base(dir)
+	isClean, err := IsClean(recipeName)
+	if err != nil {
+		return err
+	}
+
+	if !isClean {
+		return fmt.Errorf("'%s' has locally unstaged changes", recipeName)
+	}
+
 	branch := "master"
 	if _, err := repo.Branch("master"); err != nil {
 		if _, err := repo.Branch("main"); err != nil {

pkg/git/commit.go

@@ -0,0 +1,65 @@
+package git
+
+import (
+	"fmt"
+
+	"github.com/go-git/go-git/v5"
+	"github.com/sirupsen/logrus"
+)
+
+// Commit runs a git commit
+func Commit(repoPath, glob, commitMessage string, dryRun, push bool) error {
+	if commitMessage == "" {
+		return fmt.Errorf("no commit message specified?")
+	}
+
+	commitRepo, err := git.PlainOpen(repoPath)
+	if err != nil {
+		return err
+	}
+
+	commitWorktree, err := commitRepo.Worktree()
+	if err != nil {
+		return err
+	}
+
+	patterns, err := GetExcludesFiles()
+	if err != nil {
+		return err
+	}
+
+	if len(patterns) > 0 {
+		commitWorktree.Excludes = append(patterns, commitWorktree.Excludes...)
+	}
+
+	if !dryRun {
+		err = commitWorktree.AddGlob(glob)
+		if err != nil {
+			return err
+		}
+		logrus.Debugf("staged %s for commit", glob)
+	} else {
+		logrus.Debugf("dry run: did not stage %s for commit", glob)
+	}
+
+	if !dryRun {
+		_, err = commitWorktree.Commit(commitMessage, &git.CommitOptions{})
+		if err != nil {
+			return err
+		}
+		logrus.Info("changes commited")
+	} else {
+		logrus.Info("dry run: no changes commited")
+	}
+
+	if !dryRun && push {
+		if err := commitRepo.Push(&git.PushOptions{}); err != nil {
+			return err
+		}
+		logrus.Info("changes pushed")
+	} else {
+		logrus.Info("dry run: no changes pushed")
+	}
+
+	return nil
+}

pkg/git/init.go

@@ -24,7 +24,7 @@ func Init(repoPath string, commit bool) error {
 			logrus.Fatal(err)
 		}
 
-		if err := commitWorktree.AddGlob("**"); err != nil {
+		if err := commitWorktree.AddWithOptions(&git.AddOptions{All: true}); err != nil {
 			return err
 		}
 

pkg/git/read.go

@@ -1,11 +1,18 @@
 package git
 
 import (
+	"io/ioutil"
+	"os"
+	"os/user"
 	"path"
+	"path/filepath"
+	"strings"
 
 	"coopcloud.tech/abra/pkg/config"
 	"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"
 )
 
@@ -40,6 +47,15 @@ func IsClean(recipeName string) (bool, error) {
 		return false, err
 	}
 
+	patterns, err := GetExcludesFiles()
+	if err != nil {
+		return false, err
+	}
+
+	if len(patterns) > 0 {
+		worktree.Excludes = append(patterns, worktree.Excludes...)
+	}
+
 	status, err := worktree.Status()
 	if err != nil {
 		return false, err
@@ -53,3 +69,121 @@ func IsClean(recipeName string) (bool, error) {
 
 	return status.IsClean(), nil
 }
+
+// GetExcludesFiles reads the exlude files from a global gitignore
+func GetExcludesFiles() ([]gitignore.Pattern, error) {
+	var err error
+	var patterns []gitignore.Pattern
+
+	cfg, err := parseGitConfig()
+	if err != nil {
+		return patterns, err
+	}
+
+	excludesfile := getExcludesFile(cfg)
+	patterns, err = parseExcludesFile(excludesfile)
+	if err != nil {
+		return patterns, err
+	}
+
+	return patterns, nil
+}
+
+func parseGitConfig() (*gitConfigPkg.Config, error) {
+	cfg := gitConfigPkg.NewConfig()
+
+	usr, err := user.Current()
+	if err != nil {
+		return nil, err
+	}
+
+	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)
+			return cfg, nil
+		}
+		return cfg, err
+	}
+
+	b, err := ioutil.ReadFile(globalGitConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := cfg.Unmarshal(b); err != nil {
+		return nil, err
+	}
+
+	return cfg, err
+}
+
+func getExcludesFile(cfg *gitConfigPkg.Config) string {
+	for _, sec := range cfg.Raw.Sections {
+		if sec.Name == "core" {
+			for _, opt := range sec.Options {
+				if opt.Key == "excludesfile" {
+					return opt.Value
+				}
+			}
+		}
+	}
+
+	return "~/.gitignore"
+}
+
+func parseExcludesFile(excludesfile string) ([]gitignore.Pattern, error) {
+	var ps []gitignore.Pattern
+
+	excludesfile, err := expandTilde(excludesfile)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, err := os.Stat(excludesfile); err != nil {
+		if os.IsNotExist(err) {
+			logrus.Debugf("no %s exists, skipping reading gitignore paths", excludesfile)
+			return ps, nil
+		}
+		return ps, err
+	}
+
+	data, err := ioutil.ReadFile(excludesfile)
+	if err != nil {
+		return nil, err
+	}
+
+	var pathsRaw []string
+	for _, s := range strings.Split(string(data), "\n") {
+		if !strings.HasPrefix(s, "#") && len(strings.TrimSpace(s)) > 0 {
+			pathsRaw = append(pathsRaw, s)
+			ps = append(ps, gitignore.ParsePattern(s, nil))
+		}
+	}
+
+	logrus.Debugf("read global ignore paths: %s", strings.Join(pathsRaw, " "))
+
+	return ps, nil
+}
+
+func expandTilde(path string) (string, error) {
+	if !strings.HasPrefix(path, "~") {
+		return path, nil
+	}
+
+	var paths []string
+	u, err := user.Current()
+	if err != nil {
+		return "", err
+	}
+
+	for _, p := range strings.Split(path, string(filepath.Separator)) {
+		if p == "~" {
+			paths = append(paths, u.HomeDir)
+		} else {
+			paths = append(paths, p)
+		}
+	}
+
+	return filepath.Join(paths...), nil
+}

pkg/recipe/recipe.go

@@ -25,9 +25,9 @@ type Recipe struct {
 }
 
 // UpdateLabel updates a recipe label
-func (r Recipe) UpdateLabel(serviceName, label string) error {
+func (r Recipe) UpdateLabel(pattern, serviceName, label string) error {
-	pattern := fmt.Sprintf("%s/%s/compose**yml", config.APPS_DIR, r.Name)
+	fullPattern := fmt.Sprintf("%s/%s/%s", config.APPS_DIR, r.Name, pattern)
-	if err := compose.UpdateLabel(pattern, serviceName, label, r.Name); err != nil {
+	if err := compose.UpdateLabel(fullPattern, serviceName, label, r.Name); err != nil {
 		return err
 	}
 	return nil
@@ -81,10 +81,14 @@ func Get(recipeName string) (Recipe, error) {
 		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.ABRA_DIR, "apps", recipeName, ".env.sample")
 	sampleEnv, err := config.ReadEnv(envSamplePath)
 	if err != nil {
-		logrus.Fatal(err)
+		return Recipe{}, err
 	}
 
 	opts := stack.Deploy{Composefiles: composeFiles}
@@ -154,10 +158,11 @@ func EnsureVersion(recipeName, version string) error {
 		return err
 	}
 
-	logrus.Debugf("read '%s' as tags for recipe '%s'", strings.Join(parsedTags, ", "), recipeName)
+	logrus.Debugf("read %s as tags for recipe %s", strings.Join(parsedTags, ", "), recipeName)
 
 	if tagRef.String() == "" {
-		return fmt.Errorf("%s is not available?", version)
+		logrus.Warnf("%s recipe has no local tag: %s? this recipe version is not released?", recipeName, version)
+		return nil
 	}
 
 	worktree, err := repo.Worktree()
@@ -174,7 +179,7 @@ func EnsureVersion(recipeName, version string) error {
 		return err
 	}
 
-	logrus.Debugf("successfully checked '%s' out to '%s' in '%s'", recipeName, tagRef.Short(), recipeDir)
+	logrus.Debugf("successfully checked %s out to %s in %s", recipeName, tagRef.Short(), recipeDir)
 
 	return nil
 }
@@ -189,14 +194,14 @@ func EnsureLatest(recipeName string) error {
 	}
 
 	if !isClean {
-		return fmt.Errorf("'%s' has locally unstaged changes", recipeName)
+		return fmt.Errorf("%s has locally unstaged changes", recipeName)
 	}
 
 	if err := gitPkg.EnsureGitRepo(recipeDir); err != nil {
 		return err
 	}
 
-	logrus.Debugf("attempting to open git repository in '%s'", recipeDir)
+	logrus.Debugf("attempting to open git repository in %s", recipeDir)
 
 	repo, err := git.PlainOpen(recipeDir)
 	if err != nil {
@@ -211,7 +216,7 @@ func EnsureLatest(recipeName string) error {
 	branch := "master"
 	if _, err := repo.Branch("master"); err != nil {
 		if _, err := repo.Branch("main"); err != nil {
-			logrus.Debugf("failed to select branch in '%s'", path.Join(config.APPS_DIR, recipeName))
+			logrus.Debugf("failed to select branch in %s", path.Join(config.APPS_DIR, recipeName))
 			return err
 		}
 		branch = "main"
@@ -225,7 +230,7 @@ func EnsureLatest(recipeName string) error {
 	}
 
 	if err := worktree.Checkout(checkOutOpts); err != nil {
-		logrus.Debugf("failed to check out '%s' in '%s'", branch, recipeDir)
+		logrus.Debugf("failed to check out %s in %s", branch, recipeDir)
 		return err
 	}
 
@@ -254,3 +259,34 @@ func ChaosVersion(recipeName string) (string, error) {
 
 	return version, nil
 }
+
+// GetRecipesLocal retrieves all local recipe directories
+func GetRecipesLocal() ([]string, error) {
+	var recipes []string
+
+	recipes, err := config.GetAllFoldersInDirectory(config.APPS_DIR)
+	if err != nil {
+		return recipes, err
+	}
+
+	return recipes, nil
+}
+
+// GetVersionLabelLocal retrieves the version label on the local recipe config
+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") {
+				return value, nil
+			}
+		}
+	}
+
+	if label == "" {
+		return label, fmt.Errorf("unable to retrieve synced version label for %s", recipe.Name)
+	}
+
+	return label, nil
+}

pkg/secret/secret.go

@@ -140,7 +140,12 @@ func GenerateSecrets(secretEnvVars map[string]string, appName, server string) (m
 					return
 				}
 				if err := client.StoreSecret(secretRemoteName, passwords[0], server); err != nil {
-					ch <- err
+					if strings.Contains(err.Error(), "AlreadyExists") {
+						logrus.Warnf("%s already exists, moving on...", secretRemoteName)
+						ch <- nil
+					} else {
+						ch <- err
+					}
 					return
 				}
 				secrets[secretName] = passwords[0]
@@ -151,7 +156,13 @@ func GenerateSecrets(secretEnvVars map[string]string, appName, server string) (m
 					return
 				}
 				if err := client.StoreSecret(secretRemoteName, passphrases[0], server); err != nil {
-					ch <- err
+					if strings.Contains(err.Error(), "AlreadyExists") {
+						logrus.Warnf("%s already exists, moving on...", secretRemoteName)
+						ch <- nil
+					} else {
+						ch <- err
+					}
+					return
 				}
 				secrets[secretName] = passphrases[0]
 			}

pkg/server/server.go

@@ -12,7 +12,7 @@ import (
 func CreateServerDir(serverName string) error {
 	serverPath := path.Join(config.ABRA_DIR, "servers", serverName)
 
-	if err := os.Mkdir(serverPath, 0755); err != nil {
+	if err := os.Mkdir(serverPath, 0764); err != nil {
 		if !os.IsExist(err) {
 			return err
 		}

pkg/ssh/ssh.go

@@ -111,7 +111,7 @@ type sudoWriter struct {
 
 // Write satisfies the write interface for sudoWriter
 func (w *sudoWriter) Write(p []byte) (int, error) {
-	if string(p) == "sudo_password" {
+	if strings.Contains(string(p), "sudo_password") {
 		w.stdin.Write([]byte(w.pw + "\n"))
 		w.pw = ""
 		return len(p), nil
@@ -131,11 +131,9 @@ func RunSudoCmd(cmd, passwd string, cl *Client) error {
 	}
 	defer session.Close()
 
-	cmd = "sudo -p " + "sudo_password" + " -S " + cmd
+	sudoCmd := fmt.Sprintf("SSH_ASKPASS=/usr/bin/ssh-askpass; sudo -p sudo_password -S %s", cmd)
 
-	w := &sudoWriter{
+	w := &sudoWriter{pw: passwd}
-		pw: passwd,
-	}
 	w.stdin, err = session.StdinPipe()
 	if err != nil {
 		return err
@@ -144,79 +142,19 @@ func RunSudoCmd(cmd, passwd string, cl *Client) error {
 	session.Stdout = w
 	session.Stderr = w
 
-	done := make(chan struct{})
+	modes := ssh.TerminalModes{
-	scanner := bufio.NewScanner(session.Stdin)
+		ssh.ECHO:          0,
-
+		ssh.TTY_OP_ISPEED: 14400,
-	go func() {
+		ssh.TTY_OP_OSPEED: 14400,
-		for scanner.Scan() {
-			line := scanner.Text()
-			fmt.Println(line)
-		}
-		done <- struct{}{}
-	}()
-
-	if err := session.Start(cmd); err != nil {
-		return err
 	}
 
-	<-done
+	err = session.RequestPty("xterm", 80, 40, modes)
-
-	if err := session.Wait(); err != nil {
-		return err
-	}
-
-	return err
-}
-
-// Exec runs a command on a remote and streams output
-func Exec(cmd string, cl *Client) error {
-	session, err := cl.SSHClient.NewSession()
-	if err != nil {
-		return err
-	}
-	defer session.Close()
-
-	stdout, err := session.StdoutPipe()
 	if err != nil {
 		return err
 	}
 
-	stderr, err := session.StdoutPipe()
+	if err := session.Run(sudoCmd); err != nil {
-	if err != nil {
+		return fmt.Errorf("%s", string(w.b.Bytes()))
-		return err
-	}
-
-	stdoutDone := make(chan struct{})
-	stdoutScanner := bufio.NewScanner(stdout)
-
-	go func() {
-		for stdoutScanner.Scan() {
-			line := stdoutScanner.Text()
-			fmt.Println(line)
-		}
-		stdoutDone <- struct{}{}
-	}()
-
-	stderrDone := make(chan struct{})
-	stderrScanner := bufio.NewScanner(stderr)
-
-	go func() {
-		for stderrScanner.Scan() {
-			line := stderrScanner.Text()
-			fmt.Println(line)
-		}
-		stderrDone <- struct{}{}
-	}()
-
-	if err := session.Start(cmd); err != nil {
-		return err
-	}
-
-	<-stdoutDone
-	<-stderrDone
-
-	if err := session.Wait(); err != nil {
-		return err
 	}
 
 	return nil
@@ -320,7 +258,7 @@ func HostKeyAddCallback(hostnameAndPort string, remote net.Addr, pubKey ssh.Publ
 
 	if exists {
 		hostname := strings.Split(hostnameAndPort, ":")[0]
-		logrus.Debugf("server SSH host key found for %s, moving on", hostname)
+		logrus.Debugf("server SSH host key found for %s", hostname)
 		return nil
 	}
 
@@ -330,9 +268,9 @@ func HostKeyAddCallback(hostnameAndPort string, remote net.Addr, pubKey ssh.Publ
 
 		fmt.Printf(fmt.Sprintf(`
 You are attempting to make an SSH connection to a server but there is no entry
-in your ~/.ssh/known_hosts file which confirms that this is indeed the server
+in your ~/.ssh/known_hosts file which confirms that you have already validated
-you want to connect to. Please take a moment to validate the following SSH host
+that this is indeed the server you want to connect to. Please take a moment to
-key, it is important.
+validate the following SSH host key, it is important.
 
     Host:        %s
     Fingerprint: %s

pkg/upstream/stack/loader.go

@@ -13,6 +13,11 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+// DontSkipValidation ensures validation is done for compose file loading
+func DontSkipValidation(opts *loader.Options) {
+	opts.SkipValidation = false
+}
+
 // LoadComposefile parse the composefile specified in the cli and returns its Config and version.
 func LoadComposefile(opts Deploy, appEnv map[string]string) (*composetypes.Config, error) {
 	configDetails, err := getConfigDetails(opts.Composefiles, appEnv)
@@ -21,26 +26,25 @@ func LoadComposefile(opts Deploy, appEnv map[string]string) (*composetypes.Confi
 	}
 
 	dicts := getDictsFrom(configDetails.ConfigFiles)
-	config, err := loader.Load(configDetails)
+	config, err := loader.Load(configDetails, DontSkipValidation)
 	if err != nil {
 		if fpe, ok := err.(*loader.ForbiddenPropertiesError); ok {
-			return nil, fmt.Errorf("compose file contains unsupported options:\n\n%s",
+			return nil, fmt.Errorf("compose file contains unsupported options: %s",
 				propertyWarnings(fpe.Properties))
 		}
-
 		return nil, err
 	}
 
 	unsupportedProperties := loader.GetUnsupportedProperties(dicts...)
 	if len(unsupportedProperties) > 0 {
-		logrus.Warnf("Ignoring unsupported options: %s\n\n",
+		logrus.Warnf("%s: ignoring unsupported options: %s",
-			strings.Join(unsupportedProperties, ", "))
+			appEnv["TYPE"], strings.Join(unsupportedProperties, ", "))
 	}
 
 	deprecatedProperties := loader.GetDeprecatedProperties(dicts...)
 	if len(deprecatedProperties) > 0 {
-		logrus.Warnf("Ignoring deprecated options:\n\n%s\n\n",
+		logrus.Warnf("%s: ignoring deprecated options: %s",
-			propertyWarnings(deprecatedProperties))
+			appEnv["TYPE"], propertyWarnings(deprecatedProperties))
 	}
 	return config, nil
 }

pkg/upstream/stack/stack.go

@@ -158,7 +158,7 @@ func pruneServices(ctx context.Context, cl *dockerclient.Client, namespace conve
 }
 
 // RunDeploy is the swarm implementation of docker stack deploy
-func RunDeploy(cl *dockerclient.Client, opts Deploy, cfg *composetypes.Config) error {
+func RunDeploy(cl *dockerclient.Client, opts Deploy, cfg *composetypes.Config, recipeName string) error {
 	ctx := context.Background()
 
 	if err := validateResolveImageFlag(&opts); err != nil {
@@ -170,7 +170,7 @@ func RunDeploy(cl *dockerclient.Client, opts Deploy, cfg *composetypes.Config) e
 		opts.ResolveImage = ResolveImageNever
 	}
 
-	return deployCompose(ctx, cl, opts, cfg)
+	return deployCompose(ctx, cl, opts, cfg, recipeName)
 }
 
 // validateResolveImageFlag validates the opts.resolveImage command line option
@@ -183,7 +183,7 @@ func validateResolveImageFlag(opts *Deploy) error {
 	}
 }
 
-func deployCompose(ctx context.Context, cl *dockerclient.Client, opts Deploy, config *composetypes.Config) error {
+func deployCompose(ctx context.Context, cl *dockerclient.Client, opts Deploy, config *composetypes.Config, recipeName string) error {
 	namespace := convert.NewNamespace(opts.Namespace)
 
 	if opts.Prune {
@@ -224,7 +224,7 @@ func deployCompose(ctx context.Context, cl *dockerclient.Client, opts Deploy, co
 		return err
 	}
 
-	return deployServices(ctx, cl, services, namespace, opts.SendRegistryAuth, opts.ResolveImage)
+	return deployServices(ctx, cl, services, namespace, opts.SendRegistryAuth, opts.ResolveImage, recipeName)
 }
 
 func getServicesDeclaredNetworks(serviceConfigs []composetypes.ServiceConfig) map[string]struct{} {
@@ -339,7 +339,8 @@ func deployServices(
 	services map[string]swarm.ServiceSpec,
 	namespace convert.Namespace,
 	sendAuth bool,
-	resolveImage string) error {
+	resolveImage string,
+	recipeName string) error {
 	existingServices, err := GetStackServices(ctx, cl, namespace.Name())
 	if err != nil {
 		return err
@@ -350,7 +351,7 @@ func deployServices(
 		existingServiceMap[service.Spec.Name] = service
 	}
 
-	var serviceIDs []string
+	serviceIDs := make(map[string]string)
 	for internalName, serviceSpec := range services {
 		var (
 			name        = namespace.Scope(internalName)
@@ -410,7 +411,7 @@ func deployServices(
 				return errors.Wrapf(err, "failed to update service %s", name)
 			}
 
-			serviceIDs = append(serviceIDs, service.ID)
+			serviceIDs[service.ID] = name
 
 			for _, warning := range response.Warnings {
 				logrus.Warn(warning)
@@ -430,18 +431,22 @@ func deployServices(
 				return errors.Wrapf(err, "failed to create service %s", name)
 			}
 
-			serviceIDs = append(serviceIDs, serviceCreateResponse.ID)
+			serviceIDs[serviceCreateResponse.ID] = name
 		}
 	}
 
-	logrus.Infof("waiting for services to converge: %s", strings.Join(serviceIDs, ", "))
+	var serviceNames []string
+	for _, serviceName := range serviceIDs {
+		serviceNames = append(serviceNames, serviceName)
+	}
+	logrus.Infof("waiting for services to converge: %s", strings.Join(serviceNames, ", "))
 
 	ch := make(chan error, len(serviceIDs))
-	for _, serviceID := range serviceIDs {
+	for serviceID, serviceName := range serviceIDs {
-		logrus.Debugf("waiting on %s to converge", serviceID)
+		logrus.Debugf("waiting on %s to converge", serviceName)
-		go func(s string) {
+		go func(sID, sName, rName string) {
-			ch <- waitOnService(ctx, cl, s)
+			ch <- waitOnService(ctx, cl, sID, sName, rName)
-		}(serviceID)
+		}(serviceID, serviceName, recipeName)
 	}
 
 	for _, serviceID := range serviceIDs {
@@ -471,7 +476,7 @@ func getStackConfigs(ctx context.Context, dockerclient client.APIClient, namespa
 
 // https://github.com/docker/cli/blob/master/cli/command/service/helpers.go
 // https://github.com/docker/cli/blob/master/cli/command/service/progress/progress.go
-func waitOnService(ctx context.Context, cl *dockerclient.Client, serviceID string) error {
+func waitOnService(ctx context.Context, cl *dockerclient.Client, serviceID, serviceName, recipeName string) error {
 	errChan := make(chan error, 1)
 	pipeReader, pipeWriter := io.Pipe()
 
@@ -487,6 +492,21 @@ func waitOnService(ctx context.Context, cl *dockerclient.Client, serviceID strin
 	case err := <-errChan:
 		return err
 	case <-time.After(timeout):
-		return fmt.Errorf("%s has still not converged (%s second timeout)?", serviceID, timeout)
+		return fmt.Errorf(fmt.Sprintf(`
+%s has still not converged (%s second timeout reached)
+
+This does not necessarily mean your deployment has failed, it may just be that
+the app is taking longer to deploy based on your server resources or network
+latency. Please run the following the inspect the logs of your deployed app:
+
+    abra app logs %s
+
+If a service is failing to even start (run "abra app ps %s" to see what
+services are running) there could be a few things. The follow command will
+try to smoke those out for you:
+
+    abra app errors %s
+
+`, recipeName, timeout, recipeName, recipeName, recipeName))
 	}
 }

pkg/web/client.go

@@ -0,0 +1,25 @@
+package web
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/go-retryablehttp"
+	"github.com/sirupsen/logrus"
+)
+
+// customLeveledLogger is custom logger with logrus baked in
+type customLeveledLogger struct {
+	retryablehttp.Logger
+}
+
+// Printf wires up logrus into the custom retryablehttp logger
+func (l customLeveledLogger) Printf(msg string, args ...interface{}) {
+	logrus.Debugf(fmt.Sprintf(msg, args...))
+}
+
+// NewHTTPRetryClient instantiates a new http client with retries baked in
+func NewHTTPRetryClient() *retryablehttp.Client {
+	retryClient := retryablehttp.NewClient()
+	retryClient.Logger = customLeveledLogger{}
+	return retryClient
+}

pkg/web/web.go

@@ -3,7 +3,10 @@ package web
 
 import (
 	"encoding/json"
+	"fmt"
+	"io"
 	"net/http"
+	"os"
 	"time"
 )
 
@@ -13,7 +16,7 @@ const Timeout = 10 * time.Second
 
 // ReadJSON reads JSON and parses it into your chosen interface pointer
 func ReadJSON(url string, target interface{}) error {
-	httpClient := &http.Client{Timeout: Timeout}
+	httpClient := NewHTTPRetryClient()
 	res, err := httpClient.Get(url)
 	if err != nil {
 		return err
@@ -21,3 +24,29 @@ func ReadJSON(url string, target interface{}) error {
 	defer res.Body.Close()
 	return json.NewDecoder(res.Body).Decode(target)
 }
+
+// GetFile downloads a file and saves it to a filepath
+func GetFile(filepath string, url string) (err error) {
+	out, err := os.Create(filepath)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("bad status: %s", resp.Status)
+	}
+
+	_, err = io.Copy(out, resp.Body)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

scripts/installer/installer

@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 
-ABRA_VERSION="0.3.0-alpha"
+ABRA_VERSION="0.4.0-alpha"
 ABRA_RELEASE_URL="https://git.coopcloud.tech/api/v1/repos/coop-cloud/abra/releases/tags/$ABRA_VERSION"
-RC_VERSION="0.3.1-alpha-rc2"
+RC_VERSION="0.4.0-alpha"
 RC_VERSION_URL="https://git.coopcloud.tech/api/v1/repos/coop-cloud/abra/releases/tags/$RC_VERSION"
 
 for arg in "$@"; do
@@ -28,7 +28,7 @@ function show_banner {
 }
 
 function print_checksum_error {
-      echo "$(tput setaf 1)ERROR: the checksum of downloaded file doesn't match the checksum in release!!! Either the file was corrupted during download or the file has been changed during transport!$(tput sgr0)"
+      echo "$(tput setaf 1)ERROR: the checksum of downloaded file doesn't match the checksum in release! Either the file was corrupted during download or the file has been changed during transport$(tput sgr0)"
       echo "expected checksum: $checksum"
       echo "checksum of downloaded file: $localsum"
       echo "abra was NOT installed/upgraded"
@@ -76,17 +76,19 @@ function install_abra_release {
       p=$HOME/.local/bin
       com="echo PATH=\$PATH:$p"
       if [[ $SHELL =~ "bash" ]]; then
-          echo "echo $com >> $HOME/.bashrc"
+          echo "$com >> $HOME/.bashrc"
       elif [[ $SHELL =~ "fizsh" ]]; then
-          echo "echo $com >> $HOME/.fizsh/.fizshrc"
+          echo "$com >> $HOME/.fizsh/.fizshrc"
       elif [[ $SHELL =~ "zsh" ]]; then
-          echo "echo $com >> $HOME/.zshrc"
+          echo "$com >> $HOME/.zshrc"
       else
-          echo "echo $com >> $HOME/.profile"
+          echo "$com >> $HOME/.profile"
       fi
   fi
 
   echo "abra installed to $HOME/.local/bin/abra"
+  echo "test your installation is working by running \"abra\" on your command-line"
+  echo "run \"abra autocomplete -h\" to see how to set up command-line autocompletion"
 }