fix: prefer Studio Pro installation over CDN downloads on Windows

CDN mxbuild downloads are Linux ELF binaries that cannot execute on
Windows. Reorder resolution priority so Studio Pro installations are
found before cached downloads. Unify path discovery through
windowsProgramDirs() to eliminate hardcoded drive letters — paths are
now derived from PROGRAMFILES/PROGRAMW6432/SystemDrive env vars.

Also fixes filepath.Join bug with SystemDrive ("D:" without separator
produced relative paths like "D:Program Files").

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: engalar

cmd/mxcli/cmd_new.go

@@ -57,12 +57,21 @@ Examples:
 			os.Exit(1)
 		}
 
-		// Step 1: Download MxBuild
-		fmt.Printf("Step 1/4: Downloading MxBuild %s...\n", mendixVersion)
-		mxbuildPath, err := docker.DownloadMxBuild(mendixVersion, os.Stdout)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error downloading MxBuild: %v\n", err)
-			os.Exit(1)
+		// Step 1: Resolve MxBuild and mx binary.
+		// On Windows, prefer Studio Pro installation (ships both mxbuild.exe and mx.exe).
+		// Fall back to CDN download on other platforms or when Studio Pro is not installed.
+		fmt.Printf("Step 1/4: Resolving MxBuild %s...\n", mendixVersion)
+		var mxbuildPath string
+		if studioDir := docker.ResolveStudioProDir(mendixVersion); studioDir != "" {
+			mxbuildPath = filepath.Join(studioDir, "modeler", "mxbuild.exe")
+			fmt.Printf("  Using Studio Pro: %s\n", studioDir)
+		} else {
+			var err error
+			mxbuildPath, err = docker.DownloadMxBuild(mendixVersion, os.Stdout)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error downloading MxBuild: %v\n", err)
+				os.Exit(1)
+			}
 		}
 
 		// Resolve mx binary from mxbuild path

cmd/mxcli/docker/build.go

@@ -76,9 +76,12 @@ func Build(opts BuildOptions) error {
 	}
 	fmt.Fprintf(w, "  MxBuild: %s\n", mxbuildPath)
 
-	// Step 2b: Ensure PAD runtime files are linked
-	if err := ensurePADFiles(pv.ProductVersion, w); err != nil {
-		fmt.Fprintf(w, "  Warning: %v\n", err)
+	// Step 2b: Ensure PAD runtime files are linked (only needed for CDN downloads,
+	// Studio Pro installations already have runtime files in place).
+	if ResolveStudioProDir(pv.ProductVersion) == "" {
+		if err := ensurePADFiles(pv.ProductVersion, w); err != nil {
+			fmt.Fprintf(w, "  Warning: %v\n", err)
+		}
 	}
 
 	// Step 3: Resolve JDK 21
@@ -278,27 +281,36 @@ func Run(opts RunOptions) error {
 	reader.Close()
 	fmt.Fprintf(w, "  Mendix version: %s\n", pv.ProductVersion)
 
-	// Step 2: Ensure MxBuild is available
-	fmt.Fprintln(w, "Ensuring MxBuild is available...")
-	_, err = DownloadMxBuild(pv.ProductVersion, w)
-	if err != nil {
-		return fmt.Errorf("setting up mxbuild: %w", err)
-	}
+	// Step 2 & 3: Ensure MxBuild and runtime are available.
+	// On Windows, prefer Studio Pro installation directory — it ships both mxbuild.exe
+	// and runtime/, so no CDN download is needed.
+	studioProDir := ResolveStudioProDir(pv.ProductVersion)
+	if studioProDir != "" {
+		fmt.Fprintf(w, "Using Studio Pro installation: %s\n", studioProDir)
+		// Point MxBuildPath so Build() uses Studio Pro's mxbuild.exe
+		if opts.MxBuildPath == "" {
+			opts.MxBuildPath = studioProDir
+		}
+	} else {
+		fmt.Fprintln(w, "Ensuring MxBuild is available...")
+		_, err = DownloadMxBuild(pv.ProductVersion, w)
+		if err != nil {
+			return fmt.Errorf("setting up mxbuild: %w", err)
+		}
 
-	// Step 3: Ensure runtime is available
-	fmt.Fprintln(w, "Ensuring Mendix runtime is available...")
-	_, err = DownloadRuntime(pv.ProductVersion, w)
-	if err != nil {
-		return fmt.Errorf("setting up runtime: %w", err)
-	}
+		fmt.Fprintln(w, "Ensuring Mendix runtime is available...")
+		_, err = DownloadRuntime(pv.ProductVersion, w)
+		if err != nil {
+			return fmt.Errorf("setting up runtime: %w", err)
+		}
 
-	// Step 3b: Link PAD runtime files into mxbuild directory
-	// MxBuild's PAD builder expects template files at mxbuild/{ver}/runtime/pad/,
-	// but they live in the separately downloaded runtime at runtime/{ver}/runtime/pad/.
-	// Non-fatal: some Mendix versions don't include PAD files in the runtime archive.
-	// The docker build step handles this gracefully by downloading the runtime separately.
-	if err := ensurePADFiles(pv.ProductVersion, w); err != nil {
-		fmt.Fprintf(w, "  Warning: %v\n", err)
+		// Link PAD runtime files into mxbuild directory.
+		// MxBuild's PAD builder expects template files at mxbuild/{ver}/runtime/pad/,
+		// but they live in the separately downloaded runtime at runtime/{ver}/runtime/pad/.
+		// Non-fatal: some Mendix versions don't include PAD files in the runtime archive.
+		if err := ensurePADFiles(pv.ProductVersion, w); err != nil {
+			fmt.Fprintf(w, "  Warning: %v\n", err)
+		}
 	}
 
 	// Step 3c: Ensure demo users exist

cmd/mxcli/docker/check.go

@@ -123,6 +123,14 @@ func ResolveMx(mxbuildPath string) (string, error) {
 		return p, nil
 	}
 
+	// Try OS-specific known locations (Studio Pro on Windows) before cached downloads.
+	for _, pattern := range mendixSearchPaths(mxBinaryName()) {
+		matches, _ := filepath.Glob(pattern)
+		if len(matches) > 0 {
+			return matches[len(matches)-1], nil
+		}
+	}
+
 	// Try cached mxbuild installations (~/.mxcli/mxbuild/*/modeler/mx).
 	// NOTE: lexicographic sort is imperfect for versions (e.g. "9.x" > "10.x"),
 	// but this is a fallback-of-last-resort — in practice users typically have

cmd/mxcli/docker/detect.go

@@ -1,6 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Package docker implements Docker build and deployment support for Mendix projects.
+//
+// # Platform differences for Mendix tool resolution
+//
+// On Windows, Studio Pro installs mxbuild.exe, mx.exe, and the runtime under
+// a Program Files directory (e.g., D:\Program Files\Mendix\11.6.4\).
+// CDN downloads (mxbuild tar.gz) contain Linux ELF binaries that cannot
+// execute on Windows, so Studio Pro installations MUST be preferred.
+//
+// On Linux/macOS (CI, devcontainers), Studio Pro is not available.
+// CDN downloads are the primary source for mxbuild and runtime.
+//
+// Resolution priority (all platforms):
+//   1. Explicit path (--mxbuild-path)
+//   2. PATH lookup
+//   3. OS-specific known locations (Studio Pro on Windows)
+//   4. Cached CDN downloads (~/.mxcli/mxbuild/)
+//
+// Path discovery on Windows must NOT hardcode drive letters. Use environment
+// variables (PROGRAMFILES, PROGRAMW6432, SystemDrive) to locate install dirs.
 package docker
 
 import (
@@ -49,7 +68,9 @@ func findMxBuildInDir(dir string) string {
 }
 
 // resolveMxBuild finds the MxBuild executable.
-// Priority: explicit path > PATH lookup > OS-specific known locations.
+// Priority: explicit path > PATH lookup > OS-specific known locations > cached downloads.
+// On Windows, Studio Pro installations are checked before cached downloads because
+// CDN downloads are Linux binaries that cannot run natively on Windows.
 // The explicit path can be the binary itself or a directory containing it
 // (e.g., a Mendix installation root with modeler/mxbuild inside).
 func resolveMxBuild(explicitPath string) (string, error) {
@@ -73,12 +94,8 @@ func resolveMxBuild(explicitPath string) (string, error) {
 		return p, nil
 	}
 
-	// Try cached downloads (~/.mxcli/mxbuild/*/modeler/mxbuild)
-	if p := AnyCachedMxBuildPath(); p != "" {
-		return p, nil
-	}
-
-	// Try OS-specific known locations
+	// Try OS-specific known locations (Studio Pro on Windows) BEFORE cached downloads.
+	// On Windows, CDN downloads are Linux binaries — Studio Pro's mxbuild.exe is preferred.
 	for _, pattern := range mxbuildSearchPaths() {
 		matches, _ := filepath.Glob(pattern)
 		if len(matches) > 0 {
@@ -87,41 +104,83 @@ func resolveMxBuild(explicitPath string) (string, error) {
 		}
 	}
 
+	// Try cached downloads (~/.mxcli/mxbuild/*/modeler/mxbuild)
+	if p := AnyCachedMxBuildPath(); p != "" {
+		return p, nil
+	}
+
 	return "", fmt.Errorf("mxbuild not found; install Mendix Studio Pro or specify --mxbuild-path")
 }
 
-// mxbuildSearchPaths returns OS-specific glob patterns for MxBuild.
-func mxbuildSearchPaths() []string {
+// ResolveStudioProDir finds the Studio Pro installation directory for a specific
+// Mendix version on Windows. Returns the installation root (e.g.,
+// "D:\Program Files\Mendix\11.6.4") or empty string if not found.
+// On non-Windows platforms, always returns empty string.
+func ResolveStudioProDir(version string) string {
+	if runtime.GOOS != "windows" {
+		return ""
+	}
+	for _, dir := range windowsProgramDirs() {
+		candidate := filepath.Join(dir, "Mendix", version)
+		if info, err := os.Stat(filepath.Join(candidate, "modeler", "mxbuild.exe")); err == nil && !info.IsDir() {
+			return candidate
+		}
+	}
+	return ""
+}
+
+// windowsProgramDirs returns candidate Program Files directories on Windows,
+// derived from environment variables and the system drive letter.
+func windowsProgramDirs() []string {
+	seen := map[string]bool{}
+	var dirs []string
+	add := func(d string) {
+		if d != "" && !seen[d] {
+			seen[d] = true
+			dirs = append(dirs, d)
+		}
+	}
+	for _, env := range []string{"PROGRAMFILES", "PROGRAMW6432", "PROGRAMFILES(X86)"} {
+		add(os.Getenv(env))
+	}
+	// Fallback: derive from SystemDrive (e.g., "D:\Program Files").
+	// SystemDrive returns "D:" without a trailing separator; filepath.Join
+	// treats "D:" as a relative path, producing "D:Program Files" instead of
+	// "D:\Program Files". Append the separator explicitly.
+	if sysDrive := os.Getenv("SystemDrive"); sysDrive != "" {
+		root := sysDrive + string(os.PathSeparator)
+		add(filepath.Join(root, "Program Files"))
+		add(filepath.Join(root, "Program Files (x86)"))
+	}
+	return dirs
+}
+
+// mendixSearchPaths returns OS-specific glob patterns for a Mendix binary
+// (e.g., "mxbuild.exe", "mx.exe", "mxbuild", "mx") inside Studio Pro installations.
+func mendixSearchPaths(binaryName string) []string {
 	switch runtime.GOOS {
 	case "windows":
 		var paths []string
-		// Use environment variables — the system drive is not always C:.
-		for _, env := range []string{"PROGRAMFILES", "PROGRAMW6432", "PROGRAMFILES(X86)"} {
-			if dir := os.Getenv(env); dir != "" {
-				paths = append(paths, filepath.Join(dir, "Mendix", "*", "modeler", "mxbuild.exe"))
-			}
-		}
-		if len(paths) == 0 {
-			// Fallback if env vars are missing (unlikely but safe).
-			paths = []string{`C:\Program Files\Mendix\*\modeler\mxbuild.exe`}
+		for _, dir := range windowsProgramDirs() {
+			paths = append(paths, filepath.Join(dir, "Mendix", "*", "modeler", binaryName))
 		}
 		return paths
 	case "darwin":
-		return []string{
-			"/Applications/Mendix/*/modeler/mxbuild",
-		}
+		return []string{filepath.Join("/Applications/Mendix/*/modeler", binaryName)}
 	default: // linux
-		home, _ := os.UserHomeDir()
-		paths := []string{
-			"/opt/mendix/*/modeler/mxbuild",
-		}
-		if home != "" {
-			paths = append(paths, filepath.Join(home, ".mendix/*/modeler/mxbuild"))
+		paths := []string{filepath.Join("/opt/mendix/*/modeler", binaryName)}
+		if home, err := os.UserHomeDir(); err == nil {
+			paths = append(paths, filepath.Join(home, ".mendix/*/modeler", binaryName))
 		}
 		return paths
 	}
 }
 
+// mxbuildSearchPaths returns OS-specific glob patterns for MxBuild.
+func mxbuildSearchPaths() []string {
+	return mendixSearchPaths(mxbuildBinaryName())
+}
+
 // resolveJDK21 finds a JDK 21 installation.
 // Priority: JAVA_HOME (verify version) > macOS java_home > java in PATH (verify version) > OS-specific known locations.
 func resolveJDK21() (string, error) {
@@ -183,17 +242,12 @@ func jdkSearchPaths() []string {
 	switch runtime.GOOS {
 	case "windows":
 		var paths []string
-		for _, env := range []string{"PROGRAMFILES", "PROGRAMW6432"} {
-			if dir := os.Getenv(env); dir != "" {
-				paths = append(paths,
-					filepath.Join(dir, "Eclipse Adoptium", "jdk-21*"),
-					filepath.Join(dir, "Java", "jdk-21*"),
-					filepath.Join(dir, "Microsoft", "jdk-21*"),
-				)
-			}
-		}
-		if len(paths) == 0 {
-			paths = []string{`C:\Program Files\Eclipse Adoptium\jdk-21*`}
+		for _, dir := range windowsProgramDirs() {
+			paths = append(paths,
+				filepath.Join(dir, "Eclipse Adoptium", "jdk-21*"),
+				filepath.Join(dir, "Java", "jdk-21*"),
+				filepath.Join(dir, "Microsoft", "jdk-21*"),
+			)
 		}
 		return paths
 	case "darwin":