feat: add ${VAR} environment variable expansion in mcp.json (#2)

Expands ${VAR} references in all string fields (command, args, url,
headers, env values) during config loading. Fails fast if a referenced
variable is not set. Bare $VAR syntax is not expanded.

Author: kurtisvg

internal/config/config.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"regexp"
 )
 
 type TransportType string
@@ -51,9 +52,73 @@ func Load(path string) (*Config, error) {
 		return nil, fmt.Errorf("parsing config file: %w", err)
 	}
 
+	if err := cfg.expandEnvVars(); err != nil {
+		return nil, err
+	}
+
 	return &cfg, nil
 }
 
+// envVarPattern matches ${VAR} references in config values.
+var envVarPattern = regexp.MustCompile(`\$\{([^}]+)\}`)
+
+// expandString replaces all ${VAR} references with their environment variable
+// values. Returns an error if a referenced variable is not set.
+func expandString(s string) (string, error) {
+	var expandErr error
+	result := envVarPattern.ReplaceAllStringFunc(s, func(match string) string {
+		varName := envVarPattern.FindStringSubmatch(match)[1]
+		val, ok := os.LookupEnv(varName)
+		if !ok {
+			expandErr = fmt.Errorf("environment variable %q is not set", varName)
+			return match
+		}
+		return val
+	})
+	if expandErr != nil {
+		return "", expandErr
+	}
+	return result, nil
+}
+
+// expandStringMap expands env vars in all values of a map.
+func expandStringMap(m map[string]string) error {
+	for k, v := range m {
+		expanded, err := expandString(v)
+		if err != nil {
+			return err
+		}
+		m[k] = expanded
+	}
+	return nil
+}
+
+// expandEnvVars expands ${VAR} references across all string fields in the config.
+func (c *Config) expandEnvVars() error {
+	for name, srv := range c.MCPServers {
+		var err error
+		if srv.Command, err = expandString(srv.Command); err != nil {
+			return fmt.Errorf("server %q command: %w", name, err)
+		}
+		if srv.URL, err = expandString(srv.URL); err != nil {
+			return fmt.Errorf("server %q url: %w", name, err)
+		}
+		for i, arg := range srv.Args {
+			if srv.Args[i], err = expandString(arg); err != nil {
+				return fmt.Errorf("server %q args[%d]: %w", name, i, err)
+			}
+		}
+		if err := expandStringMap(srv.Env); err != nil {
+			return fmt.Errorf("server %q env: %w", name, err)
+		}
+		if err := expandStringMap(srv.Headers); err != nil {
+			return fmt.Errorf("server %q headers: %w", name, err)
+		}
+		c.MCPServers[name] = srv
+	}
+	return nil
+}
+
 func (c *Config) Validate() error {
 	for name, srv := range c.MCPServers {
 		tt, err := srv.TransportType()

internal/config/config_test.go

@@ -221,3 +221,87 @@ func TestLoadedFieldValues(t *testing.T) {
 		t.Errorf("api.TransportType() = %q, %v; want http", tt, err)
 	}
 }
+
+func TestEnvVarExpansion(t *testing.T) {
+	t.Setenv("TEST_CMD", "my-server")
+	t.Setenv("TEST_ARG", "--verbose")
+	t.Setenv("TEST_URL", "https://api.example.com")
+	t.Setenv("TEST_TOKEN", "secret123")
+	t.Setenv("TEST_ENV_VAL", "debug-mode")
+
+	json := `{
+		"mcpServers": {
+			"s1": {
+				"command": "${TEST_CMD}",
+				"args": ["${TEST_ARG}", "literal"],
+				"env": {"MODE": "${TEST_ENV_VAL}"}
+			},
+			"s2": {
+				"type": "http",
+				"url": "${TEST_URL}/mcp",
+				"headers": {"Authorization": "Bearer ${TEST_TOKEN}"}
+			}
+		}
+	}`
+	path := writeTestConfig(t, json)
+	cfg, err := Load(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	s1 := cfg.MCPServers["s1"]
+	if s1.Command != "my-server" {
+		t.Errorf("command = %q, want 'my-server'", s1.Command)
+	}
+	if s1.Args[0] != "--verbose" {
+		t.Errorf("args[0] = %q, want '--verbose'", s1.Args[0])
+	}
+	if s1.Args[1] != "literal" {
+		t.Errorf("args[1] = %q, want 'literal'", s1.Args[1])
+	}
+	if s1.Env["MODE"] != "debug-mode" {
+		t.Errorf("env[MODE] = %q, want 'debug-mode'", s1.Env["MODE"])
+	}
+
+	s2 := cfg.MCPServers["s2"]
+	if s2.URL != "https://api.example.com/mcp" {
+		t.Errorf("url = %q, want 'https://api.example.com/mcp'", s2.URL)
+	}
+	if s2.Headers["Authorization"] != "Bearer secret123" {
+		t.Errorf("header = %q, want 'Bearer secret123'", s2.Headers["Authorization"])
+	}
+}
+
+func TestEnvVarExpansionMissingVar(t *testing.T) {
+	json := `{
+		"mcpServers": {
+			"s1": {
+				"type": "http",
+				"url": "${THIS_VAR_DOES_NOT_EXIST}/mcp"
+			}
+		}
+	}`
+	path := writeTestConfig(t, json)
+	_, err := Load(path)
+	if err == nil {
+		t.Fatal("expected error for missing env var")
+	}
+}
+
+func TestEnvVarNoExpansionWithoutBraces(t *testing.T) {
+	json := `{
+		"mcpServers": {
+			"s1": {
+				"command": "$NOT_EXPANDED"
+			}
+		}
+	}`
+	path := writeTestConfig(t, json)
+	cfg, err := Load(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cfg.MCPServers["s1"].Command != "$NOT_EXPANDED" {
+		t.Errorf("bare $VAR should not expand, got %q", cfg.MCPServers["s1"].Command)
+	}
+}