Build root command from factory (#440)

Instantiates the Cobra singleton `rootCmd` from a function that builds it out, instead of directly building the singleton inside of the module.

---

Pulled this out of a too-big PR for [GROW-2118: PG Create](https://linear.app/render-com/issue/GROW-2118/pg-create).

I want to be able to instantiate the application inside of a test, instead of executing commands against the rootCmd singleton.

When we execute commands against the rootCmd singleton, it holds on to global state that the real production application would never hold on to, such as the flags set.

This makes it easier to write tests _and_ better simulates production!

The singleton works fine in production because a CLI process executes once, but in tests we run many command executions in the same Go process. Cobra command objects hold mutable state, including parsed flag values, changed flags, output writers, args, and context. That means tests can accidentally share state that the production CLI would never share.

There are a couple levels of testing we can choose from. The smallest unit test is to call a command’s `RunE` directly:

```go
cmd := newPgCreateCmd(deps)
cmd.RunE(cmd, nil)
```

That can be useful for narrow command behavior, but it skips some of the CLI surface a user actually exercises: command routing, argument parsing, persistent flags, persistent hooks, and dependency setup.

For higher-fidelity tests, I want to pass args into the CLI and let Cobra execute the command:

Before:

```go
rootCmd.SetArgs([]string{"ea", "pg", "create", "--output", "json"})
err := rootCmd.Execute()
```

That reuses the global command tree and has to be careful about resetting flags and other state.

Today, that often means tests need cleanup like this between executions:

```go
rootCmd.SetArgs(nil)

rootCmd.PersistentFlags().VisitAll(func(f *pflag.Flag) {
    f.Changed = false
    f.Value.Set(f.DefValue)
})

pgCreateCmd.Flags().VisitAll(func(f *pflag.Flag) {
    f.Changed = false
    f.Value.Set(f.DefValue)
})
```

An example of state persisting between executions:

```go
// Test A
rootCmd.SetArgs([]string{"ea", "pg", "create", "--output", "json"})
_ = rootCmd.Execute()

// Test B
rootCmd.SetArgs([]string{"ea", "pg", "create"})
_ = rootCmd.Execute()
```

If both tests reuse the same Cobra command objects, Test B can accidentally observe state mutated by Test A, such as a flag still being marked as changed. A real user running `render ea pg create` would get a fresh process and a fresh command tree.

After:

```go
// In the ideal state, we would just need to do: app = newApplication
// Today, because we have a mix of ways that commands get attached to rootCmd,
// Tests need to build out their own command tree
// which does lower the fidelity a bit
root := newRootCmd()
setupPGCommands(root, deps)
setupRootCmdPersistentRun(root, deps)

root.SetArgs([]string{"ea", "pg", "create", "--output", "json"})
err := root.Execute()
```

Each test can build a fresh command tree, closer to how a real CLI invocation starts from a clean process.

There is still a mix of command construction styles today. Some commands are already factories:

```go
cmd := NewRunListCmd(deps)
cmd := NewLogsCmd(deps)
cmd := newLogoutCmd()
```

Many others are still package-level singletons:

```go
var kvCreateCmd = &cobra.Command{...}
var EarlyAccessCmd = &cobra.Command{...}
var servicesCmd = &cobra.Command{...}
```

Moving the root command to a factory does not require converting every command all at once. It gives us a better place to opt individual command subtrees into the factory pattern when we want the testing benefits. If this direction feels good, I can keep migrating commands over time instead of doing one giant refactor.

The end-state could be even cleaner: once the commands are factory-built, tests should not need to know about `setupPGCommands` or any other command-specific setup function. We could have something like:

```go
root := newApplication(deps)
root.SetArgs([]string{"ea", "pg", "create", "--output", "json"})
err := root.Execute()
```

`newApplication()` would build the root command, attach all commands, wire dependencies, and return the full CLI app ready to execute. That gets us the production-shaped test harness without forcing every test to hand-pick command subtrees.

One nice side effect: this should also make `t.Parallel()` possible for command tests. If every test gets its own command tree, tests are no longer racing over shared Cobra state like args, flag values, output writers, and command context. We still need each test to isolate other process-level things like env vars, config paths, and fake API servers, but this removes one of the biggest shared-state blockers.

GitOrigin-RevId: d1ee179e985c936a15e8ae737ad4b2593e9bcefe

Author: davidharting

cmd/root.go

@@ -29,53 +29,76 @@ The CLI's default interactive mode provides intuitive, menu-based navigation.
 To use in non-interactive mode (such as in a script), set each command's --output option to either json or yaml for structured responses. The CLI also detects non-TTY stdout and automatically switches to text output.
 `
 
-// rootCmd represents the base command when called without any subcommands
-var rootCmd = &cobra.Command{
-	Use: "render",
-
-	Short: "Interact with resources on Render",
-	Long:  longHelp,
-	Example: `  # List services in the active workspace
+// rootCmd represents the base command when called without any subcommands.
+var rootCmd = newRootCmd()
+
+func newRootCmd() *cobra.Command {
+	root := &cobra.Command{
+		Use:   "render",
+		Short: "Interact with resources on Render",
+		Long:  longHelp,
+		Example: `  # List services in the active workspace
   render services
 
   # Output services as JSON
   render services --output json`,
 
-	PersistentPostRunE: func(cmd *cobra.Command, args []string) error {
-		ctx := cmd.Context()
-		deps := dependencies.GetFromContext(ctx)
+		PersistentPostRunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+			deps := dependencies.GetFromContext(ctx)
 
-		output := command.GetFormatFromContext(ctx)
-		if output.Interactive() {
-			stack := tui.GetStackFromContext(ctx)
-			if stack.IsEmpty() {
-				return nil
-			}
+			output := command.GetFormatFromContext(ctx)
+			if output.Interactive() {
+				stack := tui.GetStackFromContext(ctx)
+				if stack.IsEmpty() {
+					return nil
+				}
 
-			var m tea.Model = stack
+				var m tea.Model = stack
 
-			local := isLocalCommand(cmd)
+				local := isLocalCommand(cmd)
 
-			if !local && cmd.Name() != deps.Commands.WorkspaceSetCmd().Name() {
-				if !config.IsWorkspaceSet() {
-					m = tui.NewConfigWrapper(m, "Set Workspace", views.NewWorkspaceView(ctx, views.ListWorkspaceInput{}))
+				if !local && cmd.Name() != deps.Commands.WorkspaceSetCmd().Name() {
+					if !config.IsWorkspaceSet() {
+						m = tui.NewConfigWrapper(m, "Set Workspace", views.NewWorkspaceView(ctx, views.ListWorkspaceInput{}))
+					}
 				}
-			}
 
-			if !local && cmd.Name() != loginCmd.Name() {
-				m = tui.NewConfigWrapper(m, "Login", views.NewLoginView(ctx))
-			}
+				if !local && cmd.Name() != loginCmd.Name() {
+					m = tui.NewConfigWrapper(m, "Login", views.NewLoginView(ctx))
+				}
 
-			p := tea.NewProgram(m, tea.WithAltScreen())
-			_, err := p.Run()
-			if err != nil {
-				panic(fmt.Sprintf("Failed to initialize interface. Use -o to specify a non-interactive output mode: %v", err))
+				p := tea.NewProgram(m, tea.WithAltScreen())
+				_, err := p.Run()
+				if err != nil {
+					panic(fmt.Sprintf("Failed to initialize interface. Use -o to specify a non-interactive output mode: %v", err))
+				}
+				return nil
 			}
+
 			return nil
-		}
+		},
+	}
 
-		return nil
-	},
+	root.AddGroup(AllGroups...)
+	root.SetHelpTemplate(CustomHelpTemplate)
+	root.Version = cfg.Version
+	root.CompletionOptions.DisableDefaultCmd = true
+	root.PersistentFlags().StringP("output", "o", "interactive", "Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY")
+	setAnnotationBestEffort(root.PersistentFlags(), "output", command.FlagPlaceholderAnnotation, []string{command.OutputPlaceholder})
+	root.PersistentFlags().Bool(command.ConfirmFlag, false, "Skip all confirmation prompts")
+
+	// Flags from the old CLI that we error with a helpful message.
+	root.PersistentFlags().Bool("pretty-json", false, "")
+	if err := root.PersistentFlags().MarkHidden("pretty-json"); err != nil {
+		panic(err)
+	}
+	root.PersistentFlags().Bool("json-record-per-line", false, "")
+	if err := root.PersistentFlags().MarkHidden("json-record-per-line"); err != nil {
+		panic(err)
+	}
+
+	return root
 }
 
 func isLocalCommand(cmd *cobra.Command) bool {
@@ -149,13 +172,13 @@ func SetupCommands() error {
 	setupWorkflowCommands(deps)
 	setupLogCommands(deps)
 	setupWorkspaceCommands(deps)
-	setupRootCmdPersistentRun(deps)
+	setupRootCmdPersistentRun(rootCmd, deps)
 
 	return nil
 }
 
-func setupRootCmdPersistentRun(deps *dependencies.Dependencies) {
-	rootCmd.PersistentPreRunE = rootPersistentPreRun(deps)
+func setupRootCmdPersistentRun(root *cobra.Command, deps *dependencies.Dependencies) {
+	root.PersistentPreRunE = rootPersistentPreRun(deps)
 }
 
 func rootPersistentPreRun(deps *dependencies.Dependencies) func(cmd *cobra.Command, args []string) error {
@@ -293,12 +316,8 @@ func Execute() {
 }
 
 func init() {
-	// Here you will define your flags and configuration settings.
-	// Cobra supports persistent flags, which, if defined here,
-	// will be global for your application.
-	rootCmd.AddGroup(AllGroups...)
-
-	// Add custom template functions
+	// Template functions are global to cobra. Help template registration is
+	// per-command and lives in newRootCmd.
 	cobra.AddTemplateFunc("combinedFlagUsages", CombinedFlagUsages)
 	cobra.AddTemplateFunc("wrapText", wrapText)
 	cobra.AddTemplateFunc("cliVersion", cliVersion)
@@ -308,25 +327,6 @@ func init() {
 	cobra.AddTemplateFunc("hasVisibleGroupCommands", hasVisibleGroupCommands)
 	cobra.AddTemplateFunc("trimPeriod", trimTrailingPeriod)
 	cobra.AddTemplateFunc("groupHeader", groupHeaderText)
-
-	// Set custom help template
-	rootCmd.SetHelpTemplate(CustomHelpTemplate)
-
-	rootCmd.Version = cfg.Version
-	rootCmd.CompletionOptions.DisableDefaultCmd = true
-	rootCmd.PersistentFlags().StringP("output", "o", "interactive", "Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY")
-	setAnnotationBestEffort(rootCmd.PersistentFlags(), "output", command.FlagPlaceholderAnnotation, []string{command.OutputPlaceholder})
-	rootCmd.PersistentFlags().Bool(command.ConfirmFlag, false, "Skip all confirmation prompts")
-
-	// Flags from the old CLI that we error with a helpful message
-	rootCmd.PersistentFlags().Bool("pretty-json", false, "")
-	if err := rootCmd.PersistentFlags().MarkHidden("pretty-json"); err != nil {
-		panic(err)
-	}
-	rootCmd.PersistentFlags().Bool("json-record-per-line", false, "")
-	if err := rootCmd.PersistentFlags().MarkHidden("json-record-per-line"); err != nil {
-		panic(err)
-	}
 }
 
 // checkForDeprecatedFlagUsage checks for usage of deprecated flags and returns an error with the new flag if found.