refactor: introduce config.Env type with Merge/ToSlice methods

Author: klaidliadon

config/config.go

@@ -2,19 +2,37 @@ package config
 
 import (
 	"fmt"
+	"maps"
 	"os"
 	"path/filepath"
 
 	"gopkg.in/yaml.v3"
 )
 
+// Env is a string-to-string map of environment variables.
+type Env map[string]string
+
+// Merge copies all entries from other into e. Existing keys are overwritten.
+func (e Env) Merge(other Env) {
+	maps.Copy(e, other)
+}
+
+// ToSlice converts to the []string format expected by exec.Cmd.Env.
+func (e Env) ToSlice() []string {
+	s := make([]string, 0, len(e))
+	for k, v := range e {
+		s = append(s, k+"="+v)
+	}
+	return s
+}
+
 type Config struct {
-	Name      string            `yaml:"name"`
-	Env       map[string]string `yaml:"env"`
-	Bootstrap []BootstrapStep   `yaml:"bootstrap"`
-	Deps      Map[Dep]          `yaml:"deps"`
-	Hooks     Hooks             `yaml:"hooks"`
-	Services  Map[Service]      `yaml:"services"`
+	Name      string          `yaml:"name"`
+	Env       Env             `yaml:"env"`
+	Bootstrap []BootstrapStep `yaml:"bootstrap"`
+	Deps      Map[Dep]        `yaml:"deps"`
+	Hooks     Hooks           `yaml:"hooks"`
+	Services  Map[Service]    `yaml:"services"`
 }
 
 type BootstrapStep struct {
@@ -23,6 +41,7 @@ type BootstrapStep struct {
 	Check  string `yaml:"check"`
 	Run    string `yaml:"run"`
 	Prompt string `yaml:"prompt"`
+	Env    Env    `yaml:"env"`
 }
 
 type Dep struct {
@@ -41,16 +60,17 @@ type Hook struct {
 	Dir     string `yaml:"dir"`
 	Run     string `yaml:"run"`
 	EnvFile string `yaml:"env_file"`
+	Env     Env    `yaml:"env"`
 }
 
 type Service struct {
-	Dir       string            `yaml:"dir"`
-	Run       string            `yaml:"run"`
-	Port      int               `yaml:"port"`
-	Color     string            `yaml:"color"`
-	Timestamp *bool             `yaml:"timestamp"`
-	Env       map[string]string `yaml:"env"`
-	EnvFile   string            `yaml:"env_file"`
+	Dir       string `yaml:"dir"`
+	Run       string `yaml:"run"`
+	Port      int    `yaml:"port"`
+	Color     string `yaml:"color"`
+	Timestamp *bool  `yaml:"timestamp"`
+	Env       Env    `yaml:"env"`
+	EnvFile   string `yaml:"env_file"`
 }
 
 func (s Service) TimestampEnabled() bool {

engine/bootstrap.go

@@ -18,16 +18,17 @@ import (
 func RunBootstrap(ctx context.Context, dir string, steps []config.BootstrapStep, env []string) error {
 	for _, step := range steps {
 		d := stepDir(dir, step.Dir)
-		if CheckShell(ctx, d, step.Check, env) {
+		resolved := ResolveEnv(step.Env, env)
+		stepEnv := MergeSlice(env, resolved)
+		if CheckShell(ctx, d, step.Check, stepEnv) {
 			continue
 		}
-		stepEnv := env
 		if step.Prompt != "" {
 			extra, err := handlePrompt(step)
 			if err != nil {
 				return fmt.Errorf("bootstrap %q: %w", step.Name, err)
 			}
-			stepEnv = append(append([]string{}, env...), extra...)
+			stepEnv = append(stepEnv, extra...)
 		}
 		if err := RunShell(ctx, d, step.Run, stepEnv); err != nil {
 			return fmt.Errorf("bootstrap %q: %w", step.Name, err)

engine/engine.go

@@ -47,10 +47,12 @@ func (e *Engine) Preflight(ctx context.Context) error {
 func (e *Engine) Start() error {
 	var started []string
 	err := e.cfg.Services.EachErr(func(name string, svc config.Service) error {
-		env, err := BuildEnv(e.cfg.Env, svc.EnvFile, svc.Env)
+		baseEnv, err := BuildEnv(e.cfg.Env, svc.EnvFile, nil)
 		if err != nil {
 			return fmt.Errorf("service %q: %w", name, err)
 		}
+		resolved := ResolveEnv(svc.Env, baseEnv)
+		env := MergeSlice(baseEnv, resolved)
 		if err := e.pm.Start(name, svc, env); err != nil {
 			return err
 		}

engine/env.go

@@ -3,60 +3,89 @@ package engine
 import (
 	"bufio"
 	"fmt"
+	"log/slog"
 	"os"
+	"os/exec"
 	"strings"
+
+	"github.com/warriorscode/deck/config"
 )
 
 // BuildEnv builds a combined environment from the OS env, global config env,
 // an optional env file, and per-step env overrides.
 // Precedence (highest wins): step env > env file > global env > OS env.
-func BuildEnv(globalEnv map[string]string, envFile string, stepEnv map[string]string) ([]string, error) {
-	env := make(map[string]string, len(globalEnv)+len(stepEnv))
+func BuildEnv(globalEnv config.Env, envFile string, stepEnv config.Env) ([]string, error) {
+	env := make(config.Env, len(globalEnv)+len(stepEnv))
 
-	// Start with OS environment.
 	for _, e := range os.Environ() {
 		k, v, _ := strings.Cut(e, "=")
 		env[k] = v
 	}
+	env.Merge(globalEnv)
 
-	// Layer global config env.
-	for k, v := range globalEnv {
-		env[k] = v
-	}
-
-	// Layer env file if specified.
 	if envFile != "" {
 		fileEnv, err := ParseEnvFile(envFile)
 		if err != nil {
 			return nil, err
 		}
-		for k, v := range fileEnv {
-			env[k] = v
-		}
+		env.Merge(fileEnv)
 	}
 
-	// Layer step-level env (highest priority).
-	for k, v := range stepEnv {
-		env[k] = v
+	env.Merge(stepEnv)
+	return env.ToSlice(), nil
+}
+
+// MergeSlice overlays resolved env vars onto a base env slice.
+// Overlay values win on conflict.
+func MergeSlice(base []string, overlay config.Env) []string {
+	if len(overlay) == 0 {
+		return base
 	}
+	merged := make(config.Env, len(base)+len(overlay))
+	for _, e := range base {
+		k, v, _ := strings.Cut(e, "=")
+		merged[k] = v
+	}
+	merged.Merge(overlay)
+	return merged.ToSlice()
+}
 
-	result := make([]string, 0, len(env))
-	for k, v := range env {
-		result = append(result, k+"="+v)
+// ResolveEnv evaluates an env map, interpolating $(…) shell expressions.
+// Values without $(…) are used as-is. If a shell command fails, the value is set
+// to empty string and a warning is logged.
+func ResolveEnv(raw config.Env, baseEnv []string) config.Env {
+	if len(raw) == 0 {
+		return nil
+	}
+	resolved := make(config.Env, len(raw))
+	for k, v := range raw {
+		if !strings.Contains(v, "$(") {
+			resolved[k] = v
+			continue
+		}
+		cmd := exec.Command("sh", "-c", "printf '%s' "+v)
+		cmd.Env = baseEnv
+		out, err := cmd.Output()
+		if err != nil {
+			slog.Warn("env interpolation failed", "key", k, "error", err)
+			resolved[k] = ""
+			continue
+		}
+		resolved[k] = string(out)
 	}
-	return result, nil
+	return resolved
 }
 
 // ParseEnvFile reads a simple KEY=VALUE env file.
 // Supports comments (#), empty lines, and single/double quoted values.
-func ParseEnvFile(path string) (map[string]string, error) {
+func ParseEnvFile(path string) (config.Env, error) {
 	f, err := os.Open(path)
 	if err != nil {
 		return nil, fmt.Errorf("opening env file %s: %w", path, err)
 	}
 	defer f.Close()
 
-	env := make(map[string]string)
+	env := make(config.Env)
 	scanner := bufio.NewScanner(f)
 	for scanner.Scan() {
 		line := strings.TrimSpace(scanner.Text())
@@ -69,7 +98,6 @@ func ParseEnvFile(path string) (map[string]string, error) {
 		}
 		k = strings.TrimSpace(k)
 		v = strings.TrimSpace(v)
-		// Strip surrounding quotes.
 		if len(v) >= 2 && ((v[0] == '\'' && v[len(v)-1] == '\'') || (v[0] == '"' && v[len(v)-1] == '"')) {
 			v = v[1 : len(v)-1]
 		}

engine/env_test.go

@@ -7,6 +7,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	"github.com/warriorscode/deck/config"
 )
 
 func TestParseEnvFile(t *testing.T) {
@@ -41,53 +43,82 @@ func TestBuildEnvPrecedence(t *testing.T) {
 	envFile := filepath.Join(dir, "test.env")
 	require.NoError(t, os.WriteFile(envFile, []byte("A=from_file\nB=from_file\n"), 0644))
 
-	globalEnv := map[string]string{"A": "from_global", "B": "from_global", "C": "from_global"}
-	stepEnv := map[string]string{"A": "from_step"}
+	globalEnv := config.Env{"A": "from_global", "B": "from_global", "C": "from_global"}
+	stepEnv := config.Env{"A": "from_step"}
 
 	result, err := BuildEnv(globalEnv, envFile, stepEnv)
 	require.NoError(t, err)
 
-	envMap := make(map[string]string, len(result))
-	for _, e := range result {
-		k, v, _ := cutString(e, "=")
-		envMap[k] = v
-	}
-
-	// Step env wins over everything.
+	envMap := toMap(result)
 	assert.Equal(t, "from_step", envMap["A"])
-	// Env file wins over global.
 	assert.Equal(t, "from_file", envMap["B"])
-	// Global fills in the rest.
 	assert.Equal(t, "from_global", envMap["C"])
 }
 
+func toMap(envSlice []string) map[string]string {
+	m := make(map[string]string, len(envSlice))
+	for _, e := range envSlice {
+		if k, v, ok := cutString(e, "="); ok {
+			m[k] = v
+		}
+	}
+	return m
+}
+
 func cutString(s, sep string) (string, string, bool) {
-	i := 0
-	for i < len(s) {
+	for i := range len(s) {
 		if s[i:i+len(sep)] == sep {
 			return s[:i], s[i+len(sep):], true
 		}
-		i++
 	}
 	return s, "", false
 }
 
 func TestBuildEnvNoFile(t *testing.T) {
-	globalEnv := map[string]string{"FOO": "bar"}
+	globalEnv := config.Env{"FOO": "bar"}
 	result, err := BuildEnv(globalEnv, "", nil)
 	require.NoError(t, err)
-
-	envMap := make(map[string]string, len(result))
-	for _, e := range result {
-		k, v, _ := cutString(e, "=")
-		envMap[k] = v
-	}
-	assert.Equal(t, "bar", envMap["FOO"])
+	assert.Equal(t, "bar", toMap(result)["FOO"])
 }
 
 func TestBuildEnvNilEverything(t *testing.T) {
 	result, err := BuildEnv(nil, "", nil)
 	require.NoError(t, err)
-	// Should at least have OS environment.
 	assert.NotEmpty(t, result)
 }
+
+func TestResolveEnvLiteral(t *testing.T) {
+	resolved := ResolveEnv(config.Env{"FOO": "bar", "BAZ": "qux"}, nil)
+	assert.Equal(t, "bar", resolved["FOO"])
+	assert.Equal(t, "qux", resolved["BAZ"])
+}
+
+func TestResolveEnvInterpolation(t *testing.T) {
+	resolved := ResolveEnv(config.Env{"GREETING": "$(echo hello)"}, nil)
+	assert.Equal(t, "hello", resolved["GREETING"])
+}
+
+func TestResolveEnvFailedCommand(t *testing.T) {
+	resolved := ResolveEnv(config.Env{"MISSING": "$(cat /nonexistent/file/xxx)"}, nil)
+	assert.Equal(t, "", resolved["MISSING"])
+}
+
+func TestResolveEnvNil(t *testing.T) {
+	assert.Nil(t, ResolveEnv(nil, nil))
+}
+
+func TestMergeSlice(t *testing.T) {
+	base := []string{"A=1", "B=2"}
+	step := config.Env{"B": "override", "C": "3"}
+	merged := MergeSlice(base, step)
+
+	m := toMap(merged)
+	assert.Equal(t, "1", m["A"])
+	assert.Equal(t, "override", m["B"])
+	assert.Equal(t, "3", m["C"])
+}
+
+func TestMergeSliceEmpty(t *testing.T) {
+	base := []string{"A=1"}
+	assert.Equal(t, base, MergeSlice(base, nil))
+}

engine/hooks.go

@@ -20,6 +20,8 @@ func RunHooks(ctx context.Context, dir string, hooks []config.Hook, bestEffort b
 			}
 			return fmt.Errorf("hook %q: %w", hook.Name, err)
 		}
+		resolved := ResolveEnv(hook.Env, env)
+		env = MergeSlice(env, resolved)
 		d := stepDir(dir, hook.Dir)
 		if err := RunShell(ctx, d, hook.Run, env); err != nil {
 			if bestEffort {