feat: Add global env section to atmos.yaml

cmd/auth_exec.go

@@ -14,6 +14,7 @@ import (
 
 	errUtils "github.com/cloudposse/atmos/errors"
 	cfg "github.com/cloudposse/atmos/pkg/config"
+	envpkg "github.com/cloudposse/atmos/pkg/env"
 	log "github.com/cloudposse/atmos/pkg/logger"
 	"github.com/cloudposse/atmos/pkg/schema"
 )
@@ -106,8 +107,9 @@ func executeAuthExecCommandCore(cmd *cobra.Command, args []string) error {
 	}
 
 	// Prepare shell environment with file-based credentials.
-	// Start with current OS environment and let PrepareShellEnvironment configure auth.
-	envList, err := authManager.PrepareShellEnvironment(ctx, identityName, os.Environ())
+	// Start with current OS environment + global env from atmos.yaml and let PrepareShellEnvironment configure auth.
+	baseEnv := envpkg.MergeGlobalEnv(os.Environ(), atmosConfig.Env)
+	envList, err := authManager.PrepareShellEnvironment(ctx, identityName, baseEnv)
 	if err != nil {
 		return fmt.Errorf("failed to prepare command environment: %w", err)
 	}

cmd/cmd_utils.go

@@ -24,6 +24,7 @@ import (
 	"github.com/cloudposse/atmos/pkg/auth/credentials"
 	"github.com/cloudposse/atmos/pkg/auth/validation"
 	cfg "github.com/cloudposse/atmos/pkg/config"
+	envpkg "github.com/cloudposse/atmos/pkg/env"
 	l "github.com/cloudposse/atmos/pkg/list"
 	log "github.com/cloudposse/atmos/pkg/logger"
 	"github.com/cloudposse/atmos/pkg/perf"
@@ -549,8 +550,8 @@ func executeCustomCommand(
 
 		// Prepare ENV vars
 		// ENV var values support Go templates and have access to {{ .ComponentConfig.xxx.yyy.zzz }} Go template variables
-		// Start with current environment to inherit PATH and other variables.
-		env := os.Environ()
+		// Start with current environment + global env from atmos.yaml to inherit PATH and other variables.
+		env := envpkg.MergeGlobalEnv(os.Environ(), atmosConfig.Env)
 		for _, v := range commandConfig.Env {
 			key := strings.TrimSpace(v.Key)
 			value := v.Value
@@ -576,7 +577,7 @@ func executeCustomCommand(
 			}
 
 			// Add or update the environment variable in the env slice
-			env = u.UpdateEnvVar(env, key, value)
+			env = envpkg.UpdateEnvVar(env, key, value)
 		}
 
 		if len(commandConfig.Env) > 0 && commandConfig.Verbose {

cmd/env/env.go

@@ -0,0 +1,285 @@
+package env
+
+import (
+	"fmt"
+	"os"
+	"slices"
+	"sort"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/cloudposse/atmos/cmd/internal"
+	errUtils "github.com/cloudposse/atmos/errors"
+	cfg "github.com/cloudposse/atmos/pkg/config"
+	"github.com/cloudposse/atmos/pkg/data"
+	"github.com/cloudposse/atmos/pkg/flags"
+	"github.com/cloudposse/atmos/pkg/flags/compat"
+	"github.com/cloudposse/atmos/pkg/schema"
+	u "github.com/cloudposse/atmos/pkg/utils"
+)
+
+const (
+	// DefaultFileMode is the file mode for output files.
+	defaultFileMode = 0o644
+)
+
+// SupportedFormats lists all supported output formats.
+var SupportedFormats = []string{"bash", "json", "dotenv", "github"}
+
+// envParser handles flag parsing with Viper precedence.
+var envParser *flags.StandardParser
+
+// envCmd outputs environment variables from atmos.yaml.
+var envCmd = &cobra.Command{
+	Use:   "env",
+	Short: "Output environment variables configured in atmos.yaml",
+	Long:  `Outputs environment variables from the 'env' section of atmos.yaml in various formats suitable for shell evaluation, .env files, JSON consumption, or GitHub Actions workflows.`,
+	Args:  cobra.NoArgs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		// Parse flags using Viper (respects precedence: flags > env > config > defaults).
+		v := viper.GetViper()
+		if err := envParser.BindFlagsToViper(cmd, v); err != nil {
+			return err
+		}
+
+		// Get output format.
+		format := v.GetString("format")
+		if !slices.Contains(SupportedFormats, format) {
+			return errUtils.Build(errUtils.ErrInvalidArgumentError).
+				WithExplanationf("Invalid --format value %q.", format).
+				WithHintf("Supported formats: %s.", strings.Join(SupportedFormats, ", ")).
+				Err()
+		}
+
+		// Get output file path.
+		output := v.GetString("output")
+
+		// Build ConfigAndStacksInfo with CLI overrides (--config, --config-path, --base-path).
+		// These are persistent flags inherited from the root command.
+		configAndStacksInfo := schema.ConfigAndStacksInfo{}
+		if bp, _ := cmd.Flags().GetString("base-path"); bp != "" {
+			configAndStacksInfo.BasePath = bp
+		}
+		if cfgFiles, _ := cmd.Flags().GetStringSlice("config"); len(cfgFiles) > 0 {
+			configAndStacksInfo.AtmosConfigFilesFromArg = cfgFiles
+		}
+		if cfgDirs, _ := cmd.Flags().GetStringSlice("config-path"); len(cfgDirs) > 0 {
+			configAndStacksInfo.AtmosConfigDirsFromArg = cfgDirs
+		}
+
+		// Load atmos configuration (processStacks=false since env command doesn't require stack manifests).
+		atmosConfig, err := cfg.InitCliConfig(configAndStacksInfo, false)
+		if err != nil {
+			return errUtils.Build(errUtils.ErrMissingAtmosConfig).
+				WithCause(err).
+				WithExplanation("Failed to load atmos configuration.").
+				WithHint("Ensure atmos.yaml exists and is properly formatted.").
+				Err()
+		}
+
+		// Get env vars with original case preserved (Viper lowercases all YAML map keys).
+		envVars := atmosConfig.GetCaseSensitiveMap("env")
+		if envVars == nil {
+			envVars = make(map[string]string)
+		}
+
+		// Handle GitHub format special case.
+		if format == "github" {
+			if output == "" {
+				// GITHUB_ENV is an external CI environment variable set by GitHub Actions,
+				// not an Atmos configuration variable, so os.Getenv is appropriate here.
+				//nolint:forbidigo // GITHUB_ENV is an external CI env var, not Atmos config
+				output = os.Getenv("GITHUB_ENV")
+				if output == "" {
+					return errUtils.Build(errUtils.ErrRequiredFlagNotProvided).
+						WithExplanation("--format=github requires GITHUB_ENV environment variable to be set, or use --output to specify a file path.").
+						Err()
+				}
+			}
+			return writeEnvToFile(envVars, output, formatGitHub)
+		}
+
+		// Handle file output for other formats.
+		if output != "" {
+			var formatter func(map[string]string) string
+			switch format {
+			case "bash":
+				formatter = formatBash
+			case "dotenv":
+				formatter = formatDotenv
+			case "json":
+				// For JSON file output, use the utility function.
+				return u.WriteToFileAsJSON(output, envVars, defaultFileMode)
+			default:
+				formatter = formatBash
+			}
+			return writeEnvToFile(envVars, output, formatter)
+		}
+
+		// Output to stdout.
+		switch format {
+		case "json":
+			return outputEnvAsJSON(&atmosConfig, envVars)
+		case "bash":
+			return outputEnvAsBash(envVars)
+		case "dotenv":
+			return outputEnvAsDotenv(envVars)
+		default:
+			return outputEnvAsBash(envVars)
+		}
+	},
+}
+
+// outputEnvAsJSON outputs environment variables as JSON.
+func outputEnvAsJSON(atmosConfig *schema.AtmosConfiguration, envVars map[string]string) error {
+	return u.PrintAsJSON(atmosConfig, envVars)
+}
+
+// outputEnvAsBash outputs environment variables as shell export statements.
+func outputEnvAsBash(envVars map[string]string) error {
+	return data.Write(formatBash(envVars))
+}
+
+// outputEnvAsDotenv outputs environment variables in .env format.
+func outputEnvAsDotenv(envVars map[string]string) error {
+	return data.Write(formatDotenv(envVars))
+}
+
+// formatBash formats environment variables as shell export statements.
+func formatBash(envVars map[string]string) string {
+	keys := sortedKeys(envVars)
+	var sb strings.Builder
+	for _, key := range keys {
+		value := envVars[key]
+		// Escape single quotes for safe single-quoted shell literals: ' -> '\''.
+		safe := strings.ReplaceAll(value, "'", "'\\''")
+		sb.WriteString(fmt.Sprintf("export %s='%s'\n", key, safe))
+	}
+	return sb.String()
+}
+
+// formatDotenv formats environment variables in .env format.
+func formatDotenv(envVars map[string]string) string {
+	keys := sortedKeys(envVars)
+	var sb strings.Builder
+	for _, key := range keys {
+		value := envVars[key]
+		// Use the same safe single-quoted escaping as bash output.
+		safe := strings.ReplaceAll(value, "'", "'\\''")
+		sb.WriteString(fmt.Sprintf("%s='%s'\n", key, safe))
+	}
+	return sb.String()
+}
+
+// formatGitHub formats environment variables for GitHub Actions $GITHUB_ENV file.
+// Uses KEY=value format without quoting. For multiline values, GitHub uses heredoc syntax.
+func formatGitHub(envVars map[string]string) string {
+	keys := sortedKeys(envVars)
+	var sb strings.Builder
+	for _, key := range keys {
+		value := envVars[key]
+		// Check if value contains newlines - use heredoc syntax.
+		// Use ATMOS_EOF_ prefix to avoid collision with values containing "EOF".
+		if strings.Contains(value, "\n") {
+			sb.WriteString(fmt.Sprintf("%s<<ATMOS_EOF_%s\n%s\nATMOS_EOF_%s\n", key, key, value, key))
+		} else {
+			sb.WriteString(fmt.Sprintf("%s=%s\n", key, value))
+		}
+	}
+	return sb.String()
+}
+
+// writeEnvToFile writes formatted environment variables to a file (append mode).
+func writeEnvToFile(envVars map[string]string, filePath string, formatter func(map[string]string) string) error {
+	// Open file in append mode, create if doesn't exist.
+	f, err := os.OpenFile(filePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, defaultFileMode)
+	if err != nil {
+		return fmt.Errorf("failed to open file '%s': %w", filePath, err)
+	}
+	defer f.Close()
+
+	content := formatter(envVars)
+	if _, err := f.WriteString(content); err != nil {
+		return fmt.Errorf("failed to write to file '%s': %w", filePath, err)
+	}
+	return nil
+}
+
+// sortedKeys returns the keys of a map sorted alphabetically.
+func sortedKeys(m map[string]string) []string {
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+func init() {
+	// Create parser with env-specific flags using functional options.
+	envParser = flags.NewStandardParser(
+		flags.WithStringFlag("format", "f", "bash", "Output format: bash, json, dotenv, github"),
+		flags.WithStringFlag("output", "o", "", "Output file path (default: stdout, or $GITHUB_ENV for github format)"),
+		flags.WithEnvVars("format", "ATMOS_ENV_FORMAT"),
+		flags.WithEnvVars("output", "ATMOS_ENV_OUTPUT"),
+	)
+
+	// Register flags using the standard RegisterFlags method.
+	envParser.RegisterFlags(envCmd)
+
+	// Bind flags to Viper for environment variable support.
+	if err := envParser.BindToViper(viper.GetViper()); err != nil {
+		panic(err)
+	}
+
+	// Register format flag completion.
+	if err := envCmd.RegisterFlagCompletionFunc("format", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		return SupportedFormats, cobra.ShellCompDirectiveNoFileComp
+	}); err != nil {
+		// Silently ignore completion registration errors.
+		_ = err
+	}
+
+	// Register this command with the registry.
+	internal.Register(&EnvCommandProvider{})
+}
+
+// EnvCommandProvider implements the CommandProvider interface.
+type EnvCommandProvider struct{}
+
+// GetCommand returns the env command.
+func (e *EnvCommandProvider) GetCommand() *cobra.Command {
+	return envCmd
+}
+
+// GetName returns the command name.
+func (e *EnvCommandProvider) GetName() string {
+	return "env"
+}
+
+// GetGroup returns the command group for help organization.
+func (e *EnvCommandProvider) GetGroup() string {
+	return "Configuration Management"
+}
+
+// GetFlagsBuilder returns the flags builder for this command.
+func (e *EnvCommandProvider) GetFlagsBuilder() flags.Builder {
+	return envParser
+}
+
+// GetPositionalArgsBuilder returns the positional args builder for this command.
+func (e *EnvCommandProvider) GetPositionalArgsBuilder() *flags.PositionalArgsBuilder {
+	return nil
+}
+
+// GetCompatibilityFlags returns compatibility flags for this command.
+func (e *EnvCommandProvider) GetCompatibilityFlags() map[string]compat.CompatibilityFlag {
+	return nil
+}
+
+// GetAliases returns command aliases.
+func (e *EnvCommandProvider) GetAliases() []internal.CommandAlias {
+	return nil
+}