1package config
  2
  3import (
  4	"fmt"
  5	"maps"
  6	"os"
  7	"path/filepath"
  8	"slices"
  9	"strings"
 10	"testing"
 11
 12	"github.com/charmbracelet/crush/internal/env"
 13	"github.com/stretchr/testify/require"
 14)
 15
 16// These tests exercise the full shell-expansion path (no mocks,
 17// no injected Expander) to catch regressions that only surface when
 18// internal/shell actually runs the value. Table-level unit tests with
 19// fake expanders live in resolve_test.go.
 20
 21// realShellResolver builds a resolver backed by a shell env that
 22// contains PATH + the caller-supplied overrides. Production callers
 23// get PATH for free via env.New(); these tests need it so $(cat ...)
 24// and similar inner commands can resolve.
 25func realShellResolver(vars map[string]string) VariableResolver {
 26	m := map[string]string{"PATH": os.Getenv("PATH")}
 27	maps.Copy(m, vars)
 28	return NewShellVariableResolver(env.NewFromMap(m))
 29}
 30
 31func writeTempFile(t *testing.T, content string) string {
 32	t.Helper()
 33	dir := t.TempDir()
 34	p := filepath.Join(dir, "secret")
 35	require.NoError(t, os.WriteFile(p, []byte(content), 0o600))
 36	return p
 37}
 38
 39// TestResolvedEnv_RealShell_Success covers the shell constructs the
 40// PLAN calls out: $(cat tempfile) with and without trailing newline,
 41// ${VAR:-default} for unset vars, literal-space preservation around
 42// $(...), nested parens, quoted args inside $(echo ...), and a
 43// glob-like literal round-tripping unchanged.
 44func TestResolvedEnv_RealShell_Success(t *testing.T) {
 45	t.Parallel()
 46
 47	// filepath.ToSlash so Windows temp paths (C:\Users\...) survive
 48	// being injected into a shell command string — the embedded shell
 49	// treats backslashes as escapes, forward slashes work on every OS.
 50	withNL := filepath.ToSlash(writeTempFile(t, "token-with-nl\n"))
 51	noNL := filepath.ToSlash(writeTempFile(t, "token-no-nl"))
 52
 53	m := MCPConfig{
 54		Env: map[string]string{
 55			// POSIX strips exactly one trailing newline from $(...)
 56			// output, so both forms land on the same value.
 57			"TOK_NL": fmt.Sprintf("$(cat %s)", withNL),
 58			"TOK_NO": fmt.Sprintf("$(cat %s)", noNL),
 59
 60			// ${VAR:-default} must not error on unset: this is the
 61			// opt-in escape hatch for "empty is fine".
 62			"FALLBACK": "${MCP_MISSING:-fallback}",
 63
 64			// Leading/trailing literal spaces around $(...) must be
 65			// preserved — single-value contract, no field splitting.
 66			"PADDED": "  $(echo v)  ",
 67
 68			// ")" inside a quoted arg to echo is a regression guard
 69			// for the old hand-rolled paren matcher.
 70			"PAREN": `$(echo ")")`,
 71
 72			// Embedded space inside a quoted arg must survive
 73			// verbatim; no word-splitting side effect.
 74			"SPACEY": `$(echo "a b")`,
 75
 76			// Glob-like literals must not expand.
 77			"GLOB": "*.go",
 78		},
 79	}
 80
 81	got, err := m.ResolvedEnv(realShellResolver(nil))
 82	require.NoError(t, err)
 83
 84	// ResolvedEnv returns "KEY=value" sorted by key.
 85	want := []string{
 86		"FALLBACK=fallback",
 87		"GLOB=*.go",
 88		"PADDED=  v  ",
 89		"PAREN=)",
 90		"SPACEY=a b",
 91		"TOK_NL=token-with-nl",
 92		"TOK_NO=token-no-nl",
 93	}
 94	require.Equal(t, want, got)
 95}
 96
 97// TestResolvedEnv_RealShell_DoesNotMutate pins that both success and
 98// failure paths leave m.Env untouched. Prior behaviour rewrote the
 99// value in place on error; that was the exact mechanism that shipped
100// empty credentials to MCP servers.
101func TestResolvedEnv_RealShell_DoesNotMutate(t *testing.T) {
102	t.Parallel()
103
104	t.Run("success path leaves Env untouched", func(t *testing.T) {
105		t.Parallel()
106		m := MCPConfig{Env: map[string]string{"TOKEN": "$(echo shh)"}}
107		orig := maps.Clone(m.Env)
108
109		_, err := m.ResolvedEnv(realShellResolver(nil))
110		require.NoError(t, err)
111		require.Equal(t, orig, m.Env)
112	})
113
114	t.Run("failure path leaves Env untouched", func(t *testing.T) {
115		t.Parallel()
116		m := MCPConfig{Env: map[string]string{"BROKEN": "$(false)"}}
117		orig := maps.Clone(m.Env)
118
119		_, err := m.ResolvedEnv(realShellResolver(nil))
120		require.Error(t, err)
121		require.Equal(t, orig, m.Env, "map must be preserved on error")
122	})
123}
124
125// TestResolvedEnv_RealShell_Idempotent pins the pure-function contract:
126// two calls on the same config return deeply-equal slices.
127func TestResolvedEnv_RealShell_Idempotent(t *testing.T) {
128	t.Parallel()
129
130	m := MCPConfig{
131		Env: map[string]string{
132			"A": "$(echo one)",
133			"B": "$(echo two)",
134			"C": "literal",
135		},
136	}
137	r := realShellResolver(nil)
138
139	first, err := m.ResolvedEnv(r)
140	require.NoError(t, err)
141	second, err := m.ResolvedEnv(r)
142	require.NoError(t, err)
143	require.Equal(t, first, second)
144}
145
146// TestResolvedEnv_RealShell_Deterministic guards against Go's
147// randomized map iteration leaking into the returned slice order.
148func TestResolvedEnv_RealShell_Deterministic(t *testing.T) {
149	t.Parallel()
150
151	m := MCPConfig{Env: map[string]string{
152		"Z": "z",
153		"A": "a",
154		"M": "m",
155	}}
156
157	got, err := m.ResolvedEnv(realShellResolver(nil))
158	require.NoError(t, err)
159	require.True(t, slices.IsSorted(got), "env slice must be sorted; got %v", got)
160}
161
162// TestResolvedEnv_RealShell_NounsetRegression is the single most
163// important assertion in this file: an unset variable is an error, not
164// an empty expansion. Swapping the hand-rolled parser for mvdan's
165// default-expansion behaviour without nounset would re-introduce
166// Defect 1 via a typo'd variable name.
167func TestResolvedEnv_RealShell_NounsetRegression(t *testing.T) {
168	t.Parallel()
169
170	m := MCPConfig{Env: map[string]string{
171		// Intentional typo: user meant $FORGEJO_TOKEN.
172		"FORGEJO_ACCESS_TOKEN": "$FORGJO_TOKEN",
173	}}
174	got, err := m.ResolvedEnv(realShellResolver(nil))
175	require.Error(t, err, "unset var must not silently expand to empty")
176	require.Nil(t, got)
177	require.Contains(t, err.Error(), "FORGEJO_ACCESS_TOKEN")
178	require.Contains(t, err.Error(), "$FORGJO_TOKEN")
179}
180
181// TestResolvedEnv_RealShell_FailureDetail pins that a failing inner
182// command surfaces enough detail (exit code + stderr on POSIX, the
183// underlying OS error on Windows where coreutils runs in-process) to
184// diagnose without forcing the user to re-run the command by hand.
185// Also verifies the template is included so they know which Env
186// entry blew up.
187func TestResolvedEnv_RealShell_FailureDetail(t *testing.T) {
188	t.Parallel()
189
190	// Forward slashes so the path survives shell-string injection on
191	// Windows; see TestResolvedEnv_RealShell_Success for the same note.
192	missing := filepath.ToSlash(filepath.Join(t.TempDir(), "definitely-not-here"))
193	m := MCPConfig{Env: map[string]string{
194		"FORGEJO_ACCESS_TOKEN": fmt.Sprintf("$(cat %s)", missing),
195	}}
196
197	_, err := m.ResolvedEnv(realShellResolver(nil))
198	require.Error(t, err)
199	msg := err.Error()
200	require.Contains(t, msg, "FORGEJO_ACCESS_TOKEN", "must identify the failing env var")
201	require.Contains(t, msg, missing, "must include the template so users see what failed")
202
203	// Inner diagnostic detail must survive. POSIX surfaces "exit
204	// status N" + stderr; Windows' in-process coreutils surfaces the
205	// Go OS error instead. Accept either shape so the test is
206	// portable without weakening the intent.
207	lower := strings.ToLower(msg)
208	hasDetail := strings.Contains(lower, "exit status") ||
209		strings.Contains(lower, "no such file") ||
210		strings.Contains(lower, "cannot find")
211	require.True(t, hasDetail, "must surface inner error detail: %s", msg)
212}
213
214// TestResolvedHeaders_RealShell_FailurePreservesOriginal pins two
215// invariants simultaneously: on failure the returned map is nil (not
216// a partially-populated map) and the receiver's Headers map is
217// unchanged. A test that only asserted on the returned value could
218// hide an in-place mutation regression.
219func TestResolvedHeaders_RealShell_FailurePreservesOriginal(t *testing.T) {
220	t.Parallel()
221
222	m := MCPConfig{Headers: map[string]string{
223		"Authorization": "Bearer $(false)",
224		"X-Static":      "kept",
225	}}
226	orig := maps.Clone(m.Headers)
227
228	got, err := m.ResolvedHeaders(realShellResolver(nil))
229	require.Error(t, err)
230	require.Nil(t, got, "headers map must be nil on failure")
231	require.Contains(t, err.Error(), "header Authorization")
232	require.Equal(t, orig, m.Headers, "receiver Headers must be preserved")
233}
234
235// TestResolvedArgs_RealShell exercises both success and failure for
236// m.Args symmetrically with Env. Args are ordered so error messages
237// must identify a positional index, not a key.
238func TestResolvedArgs_RealShell(t *testing.T) {
239	t.Parallel()
240
241	t.Run("success expands each element", func(t *testing.T) {
242		t.Parallel()
243		m := MCPConfig{Args: []string{"--token", "$(echo shh)", "--host", "example.com"}}
244		got, err := m.ResolvedArgs(realShellResolver(nil))
245		require.NoError(t, err)
246		require.Equal(t, []string{"--token", "shh", "--host", "example.com"}, got)
247	})
248
249	t.Run("failure identifies offending index", func(t *testing.T) {
250		t.Parallel()
251		m := MCPConfig{Args: []string{"--token", "$(false)"}}
252		orig := slices.Clone(m.Args)
253
254		got, err := m.ResolvedArgs(realShellResolver(nil))
255		require.Error(t, err)
256		require.Nil(t, got)
257		require.Contains(t, err.Error(), "arg 1")
258		require.Equal(t, orig, m.Args, "receiver Args must be preserved")
259	})
260
261	t.Run("nil args returns nil, no error", func(t *testing.T) {
262		t.Parallel()
263		m := MCPConfig{}
264		got, err := m.ResolvedArgs(realShellResolver(nil))
265		require.NoError(t, err)
266		require.Nil(t, got)
267	})
268}
269
270// TestMCPConfig_IdentityResolver pins the client-mode contract: every
271// Resolved* method round-trips the template verbatim and never errors
272// on unset variables. Local expansion would double-expand when the
273// server does its own — this has to stay a pure pass-through.
274func TestMCPConfig_IdentityResolver(t *testing.T) {
275	t.Parallel()
276
277	m := MCPConfig{
278		Command: "$CMD",
279		Args:    []string{"--token", "$MCP_MISSING_TOKEN", "$(vault read -f secret)"},
280		Env: map[string]string{
281			"TOKEN": "$(cat /run/secrets/x)",
282			"HOST":  "$MCP_MISSING_HOST",
283		},
284		Headers: map[string]string{
285			"Authorization": "Bearer $(vault read -f token)",
286		},
287		URL: "https://$MCP_HOST/$(vault read -f path)",
288	}
289	r := IdentityResolver()
290
291	args, err := m.ResolvedArgs(r)
292	require.NoError(t, err)
293	require.Equal(t, m.Args, args)
294
295	envs, err := m.ResolvedEnv(r)
296	require.NoError(t, err)
297	// Sorted "KEY=value".
298	require.Equal(t, []string{
299		"HOST=$MCP_MISSING_HOST",
300		"TOKEN=$(cat /run/secrets/x)",
301	}, envs)
302
303	headers, err := m.ResolvedHeaders(r)
304	require.NoError(t, err)
305	require.Equal(t, m.Headers, headers)
306
307	u, err := m.ResolvedURL(r)
308	require.NoError(t, err)
309	require.Equal(t, m.URL, u)
310}