fix(init): refuse symlinked parent components under .mdsmith/

The prior guard only refused a symlinked top-level .mdsmith; an
intermediate symlink (.mdsmith/wordlists -> /tmp/out) would still let
MkdirAll/WriteFile resolve a pack file out of tree. refuseSymlinkedParents
now Lstats every existing component from .mdsmith down to the file's
parent and refuses any symlink before creating or writing anything.
Covered by TestRefuseSymlinkedParents and
TestWriteScaffolds_RefusesSymlinkedIntermediateDir.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012fET55utKej7P3VWhiNnLW

Author: claude

cmd/mdsmith/main.go

@@ -460,19 +460,17 @@ func applyPacks(names []string, w io.Writer) error {
 // Existence is checked with statTarget, which refuses a symlinked target
 // rather than following it — a planted link must not divert the write
 // outside the pack directory. Each path is validated against the pack
-// contract (relative, under .mdsmith/) first, and a symlinked .mdsmith
-// directory is refused up front, so a buggy or hostile pack cannot write
-// out of tree. Progress lines go to w.
+// contract (relative, under .mdsmith/) and every existing parent
+// component is checked for a symlink first, so a buggy or hostile pack
+// cannot write out of tree. Progress lines go to w.
 func writeScaffolds(files []pack.File, w io.Writer) error {
-	// A symlinked .mdsmith directory would let MkdirAll/WriteFile follow it
-	// and land pack files wherever it points; refuse it before any write.
-	if info, err := os.Lstat(mdsmithDir); err == nil && info.Mode()&fs.ModeSymlink != 0 {
-		return fmt.Errorf("%s is a symlink; refusing to write pack files through it", mdsmithDir)
-	}
 	for _, f := range files {
 		if err := validatePackPath(f.Path); err != nil {
 			return err
 		}
+		if err := refuseSymlinkedParents(f.Path); err != nil {
+			return err
+		}
 		if dir := filepath.Dir(f.Path); dir != "." {
 			if err := os.MkdirAll(dir, 0o755); err != nil {
 				return fmt.Errorf("creating %s: %w", dir, err)
@@ -494,6 +492,35 @@ func writeScaffolds(files []pack.File, w io.Writer) error {
 	return nil
 }
 
+// refuseSymlinkedParents fails if any existing directory component of p —
+// from the top-level .mdsmith down to its immediate parent — is a
+// symlink. A symlinked component (.mdsmith itself, or an intermediate
+// like .mdsmith/wordlists -> /tmp/out) would let the following MkdirAll
+// and WriteFile resolve p to a location outside .mdsmith/, so pack writes
+// must refuse it before touching the filesystem. Components that do not
+// exist yet are fine: MkdirAll creates them as real directories, and once
+// a component is absent everything below it is absent too.
+func refuseSymlinkedParents(p string) error {
+	dir := filepath.Dir(p)
+	if dir == "." {
+		return nil
+	}
+	components := strings.Split(dir, string(filepath.Separator))
+	for i := range components {
+		prefix := filepath.Join(components[:i+1]...)
+		info, err := os.Lstat(prefix)
+		switch {
+		case errors.Is(err, fs.ErrNotExist):
+			return nil
+		case err != nil:
+			return fmt.Errorf("checking %s: %w", prefix, err)
+		case info.Mode()&fs.ModeSymlink != 0:
+			return fmt.Errorf("%s is a symlink; refusing to write pack files through it", prefix)
+		}
+	}
+	return nil
+}
+
 // mdsmithDir is the workspace subdirectory every additive pack writes
 // under; validatePackPath keeps pack files confined to it.
 const mdsmithDir = ".mdsmith"

cmd/mdsmith/main_unit_test.go

@@ -1269,8 +1269,8 @@ func TestRunInit_Add_UnknownPack_ExitsTwo(t *testing.T) {
 func TestRunInit_Add_ScaffoldError(t *testing.T) {
 	dir := t.TempDir()
 	t.Chdir(dir)
-	// .mdsmith is a regular file, so the pack's MkdirAll fails and runInit
-	// must surface it as exit 2.
+	// .mdsmith is a regular file, so the pack's parent-directory checks
+	// fail and runInit must surface the scaffold error as exit 2.
 	require.NoError(t, os.WriteFile(".mdsmith", []byte("x"), 0o644))
 
 	captureStderr(func() {
@@ -1344,14 +1344,18 @@ func TestWriteScaffolds_WritesAndSkips(t *testing.T) {
 func TestWriteScaffolds_MkdirError(t *testing.T) {
 	dir := t.TempDir()
 	t.Chdir(dir)
-	// .mdsmith is a regular file, so MkdirAll(.mdsmith/wordlists) fails
-	// with ENOTDIR — driving the directory-creation error branch.
-	require.NoError(t, os.WriteFile(".mdsmith", []byte("x"), 0o644))
+	// .mdsmith is a real directory, but .mdsmith/wordlists is a regular
+	// file. The parent chain has no symlink, so refuseSymlinkedParents
+	// passes and MkdirAll(.mdsmith/wordlists) then fails because the target
+	// already exists as a file — driving the directory-creation error
+	// branch.
+	require.NoError(t, os.Mkdir(".mdsmith", 0o755))
+	require.NoError(t, os.WriteFile(filepath.Join(".mdsmith", "wordlists"), []byte("x"), 0o644))
 
 	files := []pack.File{{Path: filepath.Join(".mdsmith", "wordlists", "a.yaml"), Data: []byte("entries:\n  - x\n")}}
 	err := writeScaffolds(files, io.Discard)
 	require.Error(t, err)
-	assert.Contains(t, err.Error(), filepath.Join(".mdsmith", "wordlists"))
+	assert.Contains(t, err.Error(), "creating "+filepath.Join(".mdsmith", "wordlists"))
 }
 
 func TestWriteScaffolds_RefusesSymlink(t *testing.T) {
@@ -1482,6 +1486,53 @@ func TestWriteScaffolds_RefusesSymlinkedMdsmithDir(t *testing.T) {
 	assert.True(t, os.IsNotExist(statErr), "nothing written through the symlinked .mdsmith")
 }
 
+func TestWriteScaffolds_RefusesSymlinkedIntermediateDir(t *testing.T) {
+	dir := t.TempDir()
+	t.Chdir(dir)
+	require.NoError(t, os.Mkdir(".mdsmith", 0o755))
+	target := filepath.Join(dir, "elsewhere")
+	require.NoError(t, os.Mkdir(target, 0o755))
+	// .mdsmith is a real directory, but an intermediate component
+	// (.mdsmith/wordlists) is a symlink out of tree. The write must still
+	// be refused rather than following it.
+	require.NoError(t, os.Symlink(target, filepath.Join(".mdsmith", "wordlists")))
+
+	files := []pack.File{{Path: filepath.Join(".mdsmith", "wordlists", "a.yaml"), Data: []byte("x")}}
+	err := writeScaffolds(files, io.Discard)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "symlink")
+	_, statErr := os.Stat(filepath.Join(target, "a.yaml"))
+	assert.True(t, os.IsNotExist(statErr), "nothing written through the intermediate symlink")
+}
+
+func TestRefuseSymlinkedParents(t *testing.T) {
+	dir := t.TempDir()
+	t.Chdir(dir)
+
+	// A path whose parent is the cwd (dir == ".") has nothing to check.
+	require.NoError(t, refuseSymlinkedParents("a.yaml"))
+
+	// Parents that don't exist yet are fine — MkdirAll makes them real.
+	require.NoError(t, refuseSymlinkedParents(filepath.Join(".mdsmith", "wordlists", "a.yaml")))
+
+	// A fully real parent chain passes.
+	require.NoError(t, os.MkdirAll(filepath.Join(".mdsmith", "wordlists"), 0o755))
+	require.NoError(t, refuseSymlinkedParents(filepath.Join(".mdsmith", "wordlists", "a.yaml")))
+
+	// A symlinked component is refused.
+	require.NoError(t, os.Symlink(dir, filepath.Join(".mdsmith", "link")))
+	err := refuseSymlinkedParents(filepath.Join(".mdsmith", "link", "a.yaml"))
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "symlink")
+
+	// A non-ENOENT lstat error — a component is a file, so ENOTDIR — is
+	// surfaced as a checking error.
+	require.NoError(t, os.WriteFile(filepath.Join(".mdsmith", "afile"), []byte("x"), 0o644))
+	err = refuseSymlinkedParents(filepath.Join(".mdsmith", "afile", "child", "a.yaml"))
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "checking")
+}
+
 // --- runHelp ---
 
 func TestRunHelp_NoArgs_ExitsZero(t *testing.T) {