refactor(setup): move orchestration out of the wizard UI

cmd/root.go

@@ -22,11 +22,11 @@ import (
 	flagscmd "github.com/launchdarkly/ldcli/cmd/flags"
 	logincmd "github.com/launchdarkly/ldcli/cmd/login"
 	memberscmd "github.com/launchdarkly/ldcli/cmd/members"
-	sdkactivecmd "github.com/launchdarkly/ldcli/cmd/sdk_active"
 	resourcecmd "github.com/launchdarkly/ldcli/cmd/resources"
+	sdkactivecmd "github.com/launchdarkly/ldcli/cmd/sdk_active"
+	setupcmd "github.com/launchdarkly/ldcli/cmd/setup"
 	signupcmd "github.com/launchdarkly/ldcli/cmd/signup"
 	sourcemapscmd "github.com/launchdarkly/ldcli/cmd/sourcemaps"
-	symbolscmd "github.com/launchdarkly/ldcli/cmd/symbols"
 	whoamicmd "github.com/launchdarkly/ldcli/cmd/whoami"
 	"github.com/launchdarkly/ldcli/internal/analytics"
 	"github.com/launchdarkly/ldcli/internal/config"
@@ -37,6 +37,7 @@ import (
 	"github.com/launchdarkly/ldcli/internal/members"
 	"github.com/launchdarkly/ldcli/internal/projects"
 	"github.com/launchdarkly/ldcli/internal/resources"
+	"github.com/launchdarkly/ldcli/internal/setup"
 )
 
 type APIClients struct {
@@ -46,6 +47,8 @@ type APIClients struct {
 	MembersClient      members.Client
 	ProjectsClient     projects.Client
 	ResourcesClient    resources.Client
+	Detector           setup.Detector
+	Installer          setup.Installer
 }
 
 type Command interface {
@@ -100,6 +103,33 @@ func forceTTYDefaultOutput(getenv func(string) string) bool {
 	return lookup("FORCE_TTY") != "" || lookup("LD_FORCE_TTY") != ""
 }
 
+// authExemptCommands are commands (and their subcommands) that don't call the
+// LaunchDarkly API and so don't require --access-token.
+var authExemptCommands = map[string]bool{
+	"completion": true,
+	"config":     true,
+	"help":       true,
+	"login":      true,
+	"setup":      true,
+	"signup":     true,
+	"whoami":     true,
+}
+
+// clearAccessTokenRequirement drops the "required" annotation on --access-token
+// for auth-exempt commands, so cobra's required-flag check doesn't reject them.
+// We clear the annotation rather than setting DisableFlagParsing, which would
+// also suppress validation of the subcommand's own required flags.
+func clearAccessTokenRequirement(cmd *cobra.Command) {
+	for c := cmd; c != nil; c = c.Parent() {
+		if authExemptCommands[c.Name()] {
+			if f := cmd.Flags().Lookup(cliflags.AccessTokenFlag); f != nil {
+				delete(f.Annotations, cobra.BashCompOneRequiredFlag)
+			}
+			return
+		}
+	}
+}
+
 // NewRootCommand constructs the ldcli root command tree.
 //
 // isTerminal must be non-nil; it should reflect whether stdout is a TTY (see Execute). When it
@@ -126,23 +156,7 @@ func NewRootCommand(
 		Long:    "LaunchDarkly CLI to control your feature flags",
 		Version: version,
 		PersistentPreRun: func(cmd *cobra.Command, args []string) {
-			// disable required flags when running certain commands
-			for _, name := range []string{
-				"completion",
-				"config",
-				"help",
-				"login",
-				"signup",
-				"whoami",
-			} {
-				if cmd.HasParent() && cmd.Parent().Name() == name {
-					cmd.DisableFlagParsing = true
-				}
-				if cmd.Name() == name {
-					cmd.DisableFlagParsing = true
-				}
-			}
-
+			clearAccessTokenRequirement(cmd)
 		},
 		Annotations: make(map[string]string),
 		// Handle errors differently based on type.
@@ -254,13 +268,35 @@ func NewRootCommand(
 
 	configCmd := configcmd.NewConfigCmd(configService, analyticsTrackerFn)
 	cmd.AddCommand(configCmd.Cmd())
-	cmd.AddCommand(NewQuickStartCmd(analyticsTrackerFn, clients.EnvironmentsClient, clients.FlagsClient))
+	detector := clients.Detector
+	if detector == nil {
+		detector = setup.FileDetector{}
+	}
+	installer := clients.Installer
+	if installer == nil {
+		installer = setup.PackageInstaller{}
+	}
+	cmd.AddCommand(setupcmd.NewSetupCmd(
+		analyticsTrackerFn,
+		setup.Clients{
+			Projects:     clients.ProjectsClient,
+			Environments: clients.EnvironmentsClient,
+			Flags:        clients.FlagsClient,
+			Resources:    clients.ResourcesClient,
+		},
+		detector,
+		installer,
+	))
+	quickStartCmd := NewQuickStartCmd(analyticsTrackerFn, clients.EnvironmentsClient, clients.FlagsClient)
+	quickStartCmd.Use = "quickstart"
+	quickStartCmd.Hidden = true
+	quickStartCmd.Deprecated = "use 'ldcli setup' for the new guided setup experience"
+	cmd.AddCommand(quickStartCmd)
 	cmd.AddCommand(logincmd.NewLoginCmd(clients.ResourcesClient))
 	cmd.AddCommand(signupcmd.NewSignupCmd(analyticsTrackerFn))
 	cmd.AddCommand(resourcecmd.NewResourcesCmd())
 	cmd.AddCommand(devcmd.NewDevServerCmd(clients.ResourcesClient, analyticsTrackerFn, clients.DevClient))
 	cmd.AddCommand(sourcemapscmd.NewSourcemapsCmd(clients.ResourcesClient, analyticsTrackerFn))
-	cmd.AddCommand(symbolscmd.NewSymbolsCmd(clients.ResourcesClient, analyticsTrackerFn))
 	cmd.AddCommand(whoamicmd.NewWhoAmICmd(clients.ResourcesClient))
 	resourcecmd.AddAllResourceCmds(cmd, clients.ResourcesClient, analyticsTrackerFn)
 

cmd/setup/commands.go

@@ -0,0 +1,124 @@
+package setup
+
+import (
+	"os"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/launchdarkly/ldcli/internal/setup"
+)
+
+func (m wizardModel) fetchProjects() tea.Cmd {
+	return func() tea.Msg {
+		ps, err := m.svc.ListProjects(m.auth)
+		if err != nil {
+			return wizardErrMsg{err: err}
+		}
+		projects := make([]projectItem, len(ps))
+		for i, p := range ps {
+			projects[i] = projectItem{key: p.Key, name: p.Name}
+		}
+		return projectsFetchedMsg{projects: projects}
+	}
+}
+
+func (m wizardModel) fetchEnvironments() tea.Cmd {
+	return func() tea.Msg {
+		es, err := m.svc.ListEnvironments(m.auth, m.selectedProject)
+		if err != nil {
+			return wizardErrMsg{err: err}
+		}
+		envs := make([]envItem, len(es))
+		for i, e := range es {
+			envs[i] = envItem{key: e.Key, name: e.Name}
+		}
+		return envsFetchedMsg{environments: envs}
+	}
+}
+
+func (m wizardModel) fetchEnvDetails() tea.Cmd {
+	return func() tea.Msg {
+		keys, err := m.svc.EnvKeys(m.auth, m.selectedProject, m.selectedEnv)
+		if err != nil {
+			return wizardErrMsg{err: err}
+		}
+		return envDetailsFetchedMsg{
+			sdkKey:       keys.SDKKey,
+			clientSideID: keys.ClientSideID,
+			mobileKey:    keys.MobileKey,
+		}
+	}
+}
+
+func (m wizardModel) runDetect() tea.Cmd {
+	return func() tea.Msg {
+		dir, err := os.Getwd()
+		if err != nil {
+			return wizardErrMsg{err: err}
+		}
+		result, err := m.svc.Detect(dir)
+		if err != nil {
+			return detectFailedMsg{}
+		}
+		return detectDoneMsg{result: result}
+	}
+}
+
+func (m wizardModel) runInstall() tea.Cmd {
+	return func() tea.Msg {
+		dir, err := os.Getwd()
+		if err != nil {
+			return wizardErrMsg{err: err}
+		}
+		result, err := m.svc.Install(dir, m.detectResult)
+		if err != nil {
+			// Don't dead-end the interactive flow on a failed auto-install (e.g.
+			// Ruby gem perms, no network): surface the command to run by hand.
+			args, _ := setup.InstallArgs(m.detectResult.SDKID, m.detectResult.PackageManager)
+			return installDoneMsg{result: &setup.InstallResult{
+				SDKID:         m.detectResult.SDKID,
+				Command:       strings.Join(args, " "),
+				Failed:        true,
+				FailureReason: err.Error(),
+			}}
+		}
+		return installDoneMsg{result: result}
+	}
+}
+
+func (m wizardModel) runCreateFlag() tea.Cmd {
+	return func() tea.Msg {
+		key, err := m.svc.CreateFlag(m.auth, m.selectedProject, "my-new-flag", "My New Flag")
+		if err != nil {
+			return wizardErrMsg{err: err}
+		}
+		return flagCreatedMsg{key: key}
+	}
+}
+
+func (m wizardModel) runInit() tea.Cmd {
+	return func() tea.Msg {
+		cfg := setup.InitConfig{
+			SDKKey:       m.sdkKey,
+			ClientSideID: m.clientSideID,
+			MobileKey:    m.mobileKey,
+			FlagKey:      m.flagKey,
+		}
+		result, err := m.svc.Inject(m.detectResult.SDKID, m.detectResult.EntryPoint, cfg)
+		if err != nil {
+			return wizardErrMsg{err: err}
+		}
+		return initDoneMsg{result: result}
+	}
+}
+
+func (m wizardModel) runVerify() tea.Cmd {
+	return func() tea.Msg {
+		result, err := m.svc.Verify(m.auth, m.selectedProject, m.selectedEnv)
+		if err != nil {
+			return wizardErrMsg{err: err}
+		}
+		return verifyDoneMsg{result: result}
+	}
+}

cmd/setup/detect.go

@@ -0,0 +1,66 @@
+package setup
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/launchdarkly/ldcli/cmd/cliflags"
+	"github.com/launchdarkly/ldcli/internal/setup"
+)
+
+const pathFlag = "path"
+
+func newDetectCmd(svc setup.Service) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:    "detect",
+		Short:  "Detect language, framework, and recommended SDK for a project",
+		Hidden: true,
+		RunE:   runDetect(svc),
+	}
+
+	cmd.Flags().String(pathFlag, "", "Path to the project directory (defaults to current directory)")
+
+	return cmd
+}
+
+func runDetect(svc setup.Service) func(*cobra.Command, []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		dir, _ := cmd.Flags().GetString(pathFlag)
+		if dir == "" {
+			var err error
+			dir, err = os.Getwd()
+			if err != nil {
+				return err
+			}
+		}
+
+		result, err := svc.Detect(dir)
+		if err != nil {
+			return err
+		}
+
+		outputKind := cliflags.GetOutputKind(cmd)
+		if outputKind == "json" {
+			data, _ := json.Marshal(result)
+			fmt.Fprintln(cmd.OutOrStdout(), string(data))
+			return nil
+		}
+
+		fmt.Fprintf(cmd.OutOrStdout(), "Language: %s\n", result.Language)
+		if result.Framework != "" {
+			fmt.Fprintf(cmd.OutOrStdout(), "Framework: %s\n", result.Framework)
+		}
+		fmt.Fprintf(cmd.OutOrStdout(), "Package Manager: %s\n", result.PackageManager)
+		fmt.Fprintf(cmd.OutOrStdout(), "Recommended SDK: %s\n", result.SDKID)
+		if result.EntryPointExists {
+			fmt.Fprintf(cmd.OutOrStdout(), "Entry Point: %s\n", result.EntryPoint)
+		} else {
+			fmt.Fprintf(cmd.OutOrStdout(), "Entry Point: %s (suggested, does not exist)\n", result.EntryPoint)
+		}
+
+		return nil
+	}
+}