refactor: urfave v3

cli/app/cmd.go

@@ -1,6 +1,7 @@
 package app
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"os"
@@ -14,61 +15,53 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
-	"github.com/urfave/cli/v2"
+	"coopcloud.tech/abra/pkg/recipe"
+	"github.com/urfave/cli/v3"
 )
 
 var appCmdCommand = cli.Command{
-	Name:    "command",
-	Aliases: []string{"cmd"},
-	Usage:   "Run app commands",
+	Name:      "command",
+	Aliases:   []string{"cmd"},
+	Usage:     "Run app commands",
+	UsageText: "abra app cmd <domain> [<service>] <cmd> [<cmd-args>] [options]",
 	Description: `Run an app specific command.
 
 These commands are bash functions, defined in the abra.sh of the recipe itself.
 They can be run within the context of a service (e.g. app) or locally on your
-work station by passing "--local". Arguments can be passed into these functions
-using the "-- <args>" syntax.
-
-**WARNING**: options must be passed directly after the sub-command "cmd".
-
-EXAMPLE:
-
-  abra app cmd --local example.com app create_user -- me@example.com`,
-	ArgsUsage: "<domain> [<service>] <command> [-- <args>]",
+work station by passing "--local".`,
 	Flags: []cli.Flag{
-		internal.DebugFlag,
 		internal.LocalCmdFlag,
 		internal.RemoteUserFlag,
 		internal.TtyFlag,
-		internal.OfflineFlag,
 		internal.ChaosFlag,
 	},
 	Before: internal.SubCommandBefore,
-	Subcommands: []*cli.Command{
+	Commands: []*cli.Command{
 		&appCmdListCommand,
 	},
-	BashComplete: func(ctx *cli.Context) {
-		args := ctx.Args()
+	ShellComplete: func(ctx context.Context, cmd *cli.Command) {
+		args := cmd.Args()
 		switch args.Len() {
 		case 0:
-			autocomplete.AppNameComplete(ctx)
+			autocomplete.AppNameComplete(ctx, cmd)
 		case 1:
 			autocomplete.ServiceNameComplete(args.Get(0))
 		case 2:
 			cmdNameComplete(args.Get(0))
 		}
 	},
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	Action: func(ctx context.Context, cmd *cli.Command) error {
+		app := internal.ValidateApp(cmd)
 
 		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
 
 		if internal.LocalCmd && internal.RemoteUser != "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("cannot use --local & --user together"))
+			internal.ShowSubcommandHelpAndError(cmd, errors.New("cannot use --local & --user together"))
 		}
 
-		hasCmdArgs, parsedCmdArgs := parseCmdArgs(c.Args().Slice(), internal.LocalCmd)
+		hasCmdArgs, parsedCmdArgs := parseCmdArgs(cmd.Args().Slice(), internal.LocalCmd)
 
 		if _, err := os.Stat(app.Recipe.AbraShPath); err != nil {
 			if os.IsNotExist(err) {
@@ -78,11 +71,11 @@ EXAMPLE:
 		}
 
 		if internal.LocalCmd {
-			if !(c.Args().Len() >= 2) {
-				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
+			if !(cmd.Args().Len() >= 2) {
+				internal.ShowSubcommandHelpAndError(cmd, errors.New("missing arguments"))
 			}
 
-			cmdName := c.Args().Get(1)
+			cmdName := cmd.Args().Get(1)
 			if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
 				log.Fatal(err)
 			}
@@ -114,13 +107,13 @@ EXAMPLE:
 				log.Fatal(err)
 			}
 		} else {
-			if !(c.Args().Len() >= 3) {
-				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
+			if !(cmd.Args().Len() >= 3) {
+				internal.ShowSubcommandHelpAndError(cmd, errors.New("missing arguments"))
 			}
 
-			targetServiceName := c.Args().Get(1)
+			targetServiceName := cmd.Args().Get(1)
 
-			cmdName := c.Args().Get(2)
+			cmdName := cmd.Args().Get(2)
 			if err := internal.EnsureCommand(app.Recipe.AbraShPath, app.Recipe.Name, cmdName); err != nil {
 				log.Fatal(err)
 			}
@@ -200,16 +193,16 @@ var appCmdListCommand = cli.Command{
 	Name:      "list",
 	Aliases:   []string{"ls"},
 	Usage:     "List all available commands",
-	ArgsUsage: "<domain>",
+	UsageText: "abra app cmd ls <domain> [options]",
 	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OfflineFlag,
 		internal.ChaosFlag,
 	},
-	BashComplete: autocomplete.AppNameComplete,
-	Before:       internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+	ShellComplete: autocomplete.AppNameComplete,
+	Before:        internal.SubCommandBefore,
+	HideHelp:      true,
+	Action: func(ctx context.Context, cmd *cli.Command) error {
+		app := internal.ValidateApp(cmd)
+		r := recipe.Get(app.Recipe.Name)
 
 		if err := app.Recipe.EnsureExists(); err != nil {
 			log.Fatal(err)