Script Compiler Pathing

internal/pipeline/build.go

@@ -286,6 +286,10 @@ func compileReferencedScripts(p *project.Project) ([]erf.Resource, error) {
 	if err != nil {
 		return nil, err
 	}
+	compilerEnv, err := resolveScriptCompilerEnvironment()
+	if err != nil {
+		return nil, err
+	}
 
 	tmpDir, err := os.MkdirTemp("", "sow-script-compile-*")
 	if err != nil {
@@ -302,7 +306,7 @@ func compileReferencedScripts(p *project.Project) ([]erf.Resource, error) {
 		}
 		outputPath := filepath.Join(tmpDir, resref+".ncs")
 		cmd := exec.Command(compiler, "--dirs", scriptsDir, "-o", outputPath, sourcePath)
-		cmd.Env = os.Environ()
+		cmd.Env = compilerEnv
 		output, err := cmd.CombinedOutput()
 		if err != nil {
 			message := strings.TrimSpace(string(output))

internal/pipeline/pipeline_test.go

@@ -358,12 +358,17 @@ while [ "$#" -gt 0 ]; do
 done
 [ -n "$out" ]
 [ -n "$src" ]
-printf 'compiled:%s\n' "$(basename "$src")" > "$out"
+printf 'compiled:%s\nNWN_ROOT=%s\nNWN_HOME=%s\nNWN_USER_DIRECTORY=%s\n' "$(basename "$src")" "${NWN_ROOT-}" "${NWN_HOME-}" "${NWN_USER_DIRECTORY-}" > "$out"
 `)
 	if err := os.Chmod(compiler, 0o755); err != nil {
 		t.Fatalf("chmod fake compiler: %v", err)
 	}
 	t.Setenv("SOW_NWN_SCRIPT_COMPILER", compiler)
+	installRoot := filepath.Join(root, "nwn-install")
+	mustMkdir(t, filepath.Join(installRoot, "data"))
+	t.Setenv("SOW_NWN_ROOT", installRoot)
+	userDir := filepath.Join(root, "nwn-user")
+	t.Setenv("SOW_NWN_USER_DIRECTORY", userDir)
 
 	p, err := project.Load(root)
 	if err != nil {
@@ -409,6 +414,15 @@ printf 'compiled:%s\n' "$(basename "$src")" > "$out"
 				if !strings.Contains(string(resource.Data), "compiled:use_thing.nss") {
 					t.Fatalf("unexpected compiled payload: %q", string(resource.Data))
 				}
+				if !strings.Contains(string(resource.Data), "NWN_ROOT="+installRoot) {
+					t.Fatalf("compiled payload missing NWN_ROOT: %q", string(resource.Data))
+				}
+				if !strings.Contains(string(resource.Data), "NWN_HOME="+userDir) {
+					t.Fatalf("compiled payload missing NWN_HOME: %q", string(resource.Data))
+				}
+				if !strings.Contains(string(resource.Data), "NWN_USER_DIRECTORY="+userDir) {
+					t.Fatalf("compiled payload missing NWN_USER_DIRECTORY: %q", string(resource.Data))
+				}
 			}
 		}
 	}
@@ -419,6 +433,9 @@ printf 'compiled:%s\n' "$(basename "$src")" > "$out"
 	if !foundCompiled {
 		t.Fatalf("expected compiled script resource in archive")
 	}
+	if _, err := os.Stat(userDir); err != nil {
+		t.Fatalf("expected build to prepare NWN user directory: %v", err)
+	}
 
 	compareResult, err := Compare(p)
 	if err != nil {
@@ -429,6 +446,31 @@ printf 'compiled:%s\n' "$(basename "$src")" > "$out"
 	}
 }
 
+func TestParseSteamLibraryFolders(t *testing.T) {
+	root := t.TempDir()
+	vdf := filepath.Join(root, "libraryfolders.vdf")
+	mustWriteFile(t, vdf, `"libraryfolders"
+{
+  "0"
+  {
+    "path" "/mnt/games/Steam"
+  }
+  "1" "D:\\SteamLibrary"
+}
+`)
+
+	got := parseSteamLibraryFolders(vdf)
+	if len(got) != 2 {
+		t.Fatalf("expected 2 library roots, got %d (%v)", len(got), got)
+	}
+	if got[0] != filepath.Clean("/mnt/games/Steam") {
+		t.Fatalf("unexpected first library root: %q", got[0])
+	}
+	if got[1] != filepath.Clean(`D:\SteamLibrary`) {
+		t.Fatalf("unexpected second library root: %q", got[1])
+	}
+}
+
 func TestBuildBuildsTopPackageAndInjectsHAKList(t *testing.T) {
 	root := t.TempDir()
 	mustMkdir(t, filepath.Join(root, "src", "module"))

internal/pipeline/script_compiler_env.go

@@ -0,0 +1,285 @@
+package pipeline
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+)
+
+func resolveScriptCompilerEnvironment() ([]string, error) {
+	env := os.Environ()
+
+	userDir, err := resolveNWNUserDirectory()
+	if err != nil {
+		return nil, err
+	}
+	env = upsertEnv(env, "NWN_HOME", userDir)
+	env = upsertEnv(env, "NWN_USER_DIRECTORY", userDir)
+
+	root, err := resolveNWNRoot()
+	if err != nil {
+		return nil, err
+	}
+	if root != "" {
+		env = upsertEnv(env, "NWN_ROOT", root)
+	}
+
+	return env, nil
+}
+
+func resolveNWNUserDirectory() (string, error) {
+	for _, key := range []string{"SOW_NWN_USER_DIRECTORY", "NWN_HOME", "NWN_USER_DIRECTORY"} {
+		if value := strings.TrimSpace(os.Getenv(key)); value != "" {
+			path := filepath.Clean(expandUserPath(value))
+			if err := os.MkdirAll(path, 0o755); err != nil {
+				return "", fmt.Errorf("prepare NWN user directory %s from %s: %w", path, key, err)
+			}
+			return path, nil
+		}
+	}
+
+	path, err := defaultNWNUserDirectory()
+	if err != nil {
+		return "", err
+	}
+	if err := os.MkdirAll(path, 0o755); err != nil {
+		return "", fmt.Errorf("prepare default NWN user directory %s: %w", path, err)
+	}
+	return path, nil
+}
+
+func defaultNWNUserDirectory() (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("resolve user home directory: %w", err)
+	}
+
+	switch runtime.GOOS {
+	case "windows", "darwin":
+		return filepath.Join(home, "Documents", "Neverwinter Nights"), nil
+	default:
+		base := strings.TrimSpace(os.Getenv("XDG_DATA_HOME"))
+		if base == "" {
+			base = filepath.Join(home, ".local", "share")
+		}
+		return filepath.Join(base, "Neverwinter Nights"), nil
+	}
+}
+
+func resolveNWNRoot() (string, error) {
+	for _, key := range []string{"SOW_NWN_ROOT", "NWN_ROOT"} {
+		if value := strings.TrimSpace(os.Getenv(key)); value != "" {
+			path := filepath.Clean(expandUserPath(value))
+			if !looksLikeNWNInstall(path) {
+				return "", fmt.Errorf("%s does not point to a Neverwinter Nights install root: %s", key, path)
+			}
+			return path, nil
+		}
+	}
+
+	for _, root := range candidateNWNInstallRoots() {
+		if looksLikeNWNInstall(root) {
+			return root, nil
+		}
+	}
+
+	return "", nil
+}
+
+func candidateNWNInstallRoots() []string {
+	candidates := make([]string, 0, 8)
+	for _, library := range steamLibraryRoots() {
+		candidates = append(candidates, filepath.Join(library, "steamapps", "common", "Neverwinter Nights"))
+	}
+
+	switch runtime.GOOS {
+	case "windows":
+		for _, base := range []string{
+			strings.TrimSpace(os.Getenv("PROGRAMFILES(X86)")),
+			strings.TrimSpace(os.Getenv("PROGRAMFILES")),
+		} {
+			if base == "" {
+				continue
+			}
+			candidates = append(candidates, filepath.Join(base, "Steam", "steamapps", "common", "Neverwinter Nights"))
+		}
+	case "darwin":
+		if home, err := os.UserHomeDir(); err == nil {
+			candidates = append(candidates, filepath.Join(home, "Library", "Application Support", "Steam", "steamapps", "common", "Neverwinter Nights"))
+		}
+	default:
+		if home, err := os.UserHomeDir(); err == nil {
+			candidates = append(candidates,
+				filepath.Join(home, ".local", "share", "Steam", "steamapps", "common", "Neverwinter Nights"),
+				filepath.Join(home, ".steam", "steam", "steamapps", "common", "Neverwinter Nights"),
+				filepath.Join(home, ".var", "app", "com.valvesoftware.Steam", ".local", "share", "Steam", "steamapps", "common", "Neverwinter Nights"),
+			)
+		}
+	}
+
+	return dedupePaths(candidates)
+}
+
+func steamLibraryRoots() []string {
+	steamRoots := defaultSteamRoots()
+	roots := make([]string, 0, len(steamRoots)+4)
+	roots = append(roots, steamRoots...)
+	for _, steamRoot := range steamRoots {
+		roots = append(roots, parseSteamLibraryFolders(filepath.Join(steamRoot, "steamapps", "libraryfolders.vdf"))...)
+	}
+	return dedupePaths(roots)
+}
+
+func defaultSteamRoots() []string {
+	roots := make([]string, 0, 6)
+	if runtime.GOOS == "windows" {
+		roots = append(roots, detectWindowsSteamRoot())
+		roots = append(roots,
+			filepath.Join(strings.TrimSpace(os.Getenv("PROGRAMFILES(X86)")), "Steam"),
+			filepath.Join(strings.TrimSpace(os.Getenv("PROGRAMFILES")), "Steam"),
+		)
+		return dedupePaths(filterNonEmpty(roots))
+	}
+
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil
+	}
+
+	switch runtime.GOOS {
+	case "darwin":
+		roots = append(roots, filepath.Join(home, "Library", "Application Support", "Steam"))
+	default:
+		roots = append(roots,
+			filepath.Join(home, ".local", "share", "Steam"),
+			filepath.Join(home, ".steam", "steam"),
+			filepath.Join(home, ".var", "app", "com.valvesoftware.Steam", ".local", "share", "Steam"),
+		)
+	}
+	return dedupePaths(filterNonEmpty(roots))
+}
+
+func detectWindowsSteamRoot() string {
+	for _, args := range [][]string{
+		{"query", `HKCU\Software\Valve\Steam`, "/v", "SteamPath"},
+		{"query", `HKLM\SOFTWARE\WOW6432Node\Valve\Steam`, "/v", "InstallPath"},
+		{"query", `HKLM\SOFTWARE\Valve\Steam`, "/v", "InstallPath"},
+	} {
+		out, err := exec.Command("reg", args...).CombinedOutput()
+		if err != nil {
+			continue
+		}
+		if path := parseWindowsRegistryPath(string(out)); path != "" {
+			return filepath.Clean(path)
+		}
+	}
+	return ""
+}
+
+func parseWindowsRegistryPath(raw string) string {
+	index := strings.Index(raw, "REG_SZ")
+	if index == -1 {
+		return ""
+	}
+	return strings.TrimSpace(raw[index+len("REG_SZ"):])
+}
+
+func parseSteamLibraryFolders(path string) []string {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return nil
+	}
+
+	pathPattern := regexp.MustCompile(`"path"\s*"([^"]+)"`)
+	legacyPattern := regexp.MustCompile(`^\s*"\d+"\s*"([^"]+)"\s*$`)
+
+	roots := make([]string, 0, 8)
+	scanner := bufio.NewScanner(strings.NewReader(string(raw)))
+	for scanner.Scan() {
+		line := scanner.Text()
+		if match := pathPattern.FindStringSubmatch(line); len(match) == 2 {
+			roots = append(roots, normalizeSteamPath(match[1]))
+			continue
+		}
+		if match := legacyPattern.FindStringSubmatch(line); len(match) == 2 {
+			roots = append(roots, normalizeSteamPath(match[1]))
+		}
+	}
+
+	return dedupePaths(filterNonEmpty(roots))
+}
+
+func normalizeSteamPath(value string) string {
+	value = strings.TrimSpace(value)
+	value = strings.ReplaceAll(value, `\\`, `\`)
+	return filepath.Clean(expandUserPath(value))
+}
+
+func looksLikeNWNInstall(path string) bool {
+	if strings.TrimSpace(path) == "" {
+		return false
+	}
+	info, err := os.Stat(filepath.Join(path, "data"))
+	return err == nil && info.IsDir()
+}
+
+func expandUserPath(path string) string {
+	if path == "" || path[0] != '~' {
+		return path
+	}
+
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return path
+	}
+	if path == "~" {
+		return home
+	}
+	if path[1] == '/' || path[1] == '\\' {
+		return filepath.Join(home, path[2:])
+	}
+	return path
+}
+
+func upsertEnv(env []string, key, value string) []string {
+	prefix := key + "="
+	for i, entry := range env {
+		if strings.HasPrefix(entry, prefix) {
+			env[i] = prefix + value
+			return env
+		}
+	}
+	return append(env, prefix+value)
+}
+
+func dedupePaths(paths []string) []string {
+	seen := make(map[string]struct{}, len(paths))
+	out := make([]string, 0, len(paths))
+	for _, path := range paths {
+		if strings.TrimSpace(path) == "" {
+			continue
+		}
+		clean := filepath.Clean(path)
+		if _, ok := seen[clean]; ok {
+			continue
+		}
+		seen[clean] = struct{}{}
+		out = append(out, clean)
+	}
+	return out
+}
+
+func filterNonEmpty(values []string) []string {
+	out := make([]string, 0, len(values))
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			out = append(out, value)
+		}
+	}
+	return out
+}