command

var P = track.P

var RootCmd = &cobra.Command{
	SilenceUsage:  true,
	SilenceErrors: true,
	Use:           "defang",
	Args:          cobra.NoArgs,
	Short:         "Defang CLI is used to take your app from Docker Compose to a secure and scalable deployment on your favorite cloud in minutes.",
	PersistentPreRunE: func(cmd *cobra.Command, args []string) (err error) {

		if isCompletionCommand(cmd) {

			if cwd := getCwd(os.Args); cwd != "" {
				return os.Chdir(cwd)
			}
			return nil
		}

		track.Tracker = cli.Connect(global.Cluster, global.Tenant)

		ctx := cmd.Context()
		term.SetDebug(global.Debug)

		defer func() {
			var errString = ""
			if err != nil {
				errString = err.Error()
			}

			track.Cmd(cmd, "Invoked", P("args", args), P("err", errString), P("non-interactive", global.NonInteractive), P("provider", global.Stack.Provider))
		}()

		switch global.ColorMode {
		case ColorNever:
			term.ForceColor(false)
		case ColorAlways:
			term.ForceColor(true)
		}

		if cwd, _ := cmd.Flags().GetString("cwd"); cwd != "" {

			if err = os.Chdir(cwd); err != nil {
				return err
			}
		}

		global.Client, err = cli.ConnectWithTenant(ctx, global.Cluster, global.Tenant)
		if err != nil {
			if connect.CodeOf(err) != connect.CodeUnauthenticated {
				return err
			}
			term.Debug("Using existing token failed; continuing to allow login/ToS flow:", err)
		}

		track.Tracker = global.Client

		if v, err := global.Client.GetVersions(ctx); err == nil {
			version := cmd.Root().Version
			term.Debug("Fabric:", v.Fabric, "CLI:", version, "CLI-Min:", v.CliMin)
			if global.HasTty && isNewer(version, v.CliMin) && !isUpgradeCommand(cmd) {
				term.Warn("Your CLI version is outdated. Please upgrade to the latest version by running:\n\n  defang upgrade\n")
				global.HideUpdate = true
			}
		}

		if _, ok := cmd.Annotations[authNeeded]; !ok {
			return nil
		}

		if global.NonInteractive {
			err = global.Client.CheckLoginAndToS(ctx)
		} else {
			err = login.InteractiveRequireLoginAndToS(ctx, global.Client, global.Cluster)
		}

		return err
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		if global.NonInteractive {
			return cmd.Help()
		}

		ctx := cmd.Context()
		err := login.InteractiveRequireLoginAndToS(ctx, global.Client, global.Cluster)
		if err != nil {
			return err
		}

		prompt := "Welcome to Defang. I can help you deploy your project to the cloud."
		ag, err := agent.New(ctx, global.Cluster, &global.Stack)
		if err != nil {
			return err
		}
		return ag.StartWithUserPrompt(ctx, prompt)
	},
}