fix: mxcli new fails on macOS with exec format error (Studio Pro lookup)

CDN mxbuild downloads are Linux ELF binaries. On macOS they fail with
"exec format error" when used as the mx binary for create-project.

Root causes:
1. ResolveStudioProDir() returned "" on all non-Windows platforms,
   so cmd_new.go always fell through to the CDN download path.
2. mendixSearchPaths() for darwin used /Applications/Mendix/*/modeler/
   but Studio Pro on macOS installs to
   /Applications/Mendix Studio Pro X.Y.Z*.app/Contents/modeler/.
3. versionFromPath() couldn't extract the version from macOS .app paths.

Fixes:
- ResolveStudioProDir() now handles darwin via resolveStudioProDirMacOS(),
  which globs /Applications/Mendix Studio Pro *.app and extracts the
  base version (major.minor.patch) from the bundle name via regex,
  so "11.10.0-rc.7 Beta" correctly matches a request for "11.10.0".
- mendixSearchPaths() darwin pattern updated to match real install layout.
- versionFromPath() checks for macOS .app bundle paths first.
- Adds ResolveMxForNewProject() helper that tries Studio Pro / cache
  before downloading; cmd_new.go uses it instead of inlining the logic.
- Adds a helpful error message on macOS when no Studio Pro is found.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: ako

cmd/mxcli/cmd_new.go

@@ -57,27 +57,17 @@ Examples:
 			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.
+		// Step 1: Resolve mx binary.
+		// On Windows and macOS, Studio Pro ships a native mx binary — prefer it.
+		// CDN downloads contain Linux ELF binaries that cannot run on those platforms.
+		// On Linux (CI, devcontainers), download mxbuild from CDN and derive mx.
 		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
-		mxPath, err := docker.ResolveMx(mxbuildPath)
+		mxPath, err := docker.ResolveMxForNewProject(mendixVersion, os.Stdout)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: could not find mx binary: %v\n", err)
+			fmt.Fprintf(os.Stderr, "Error: could not find mx binary for version %s: %v\n", mendixVersion, err)
+			if runtime.GOOS == "darwin" {
+				fmt.Fprintf(os.Stderr, "  On macOS, install Mendix Studio Pro %s from the Mendix Marketplace.\n", mendixVersion)
+			}
 			os.Exit(1)
 		}
 

cmd/mxcli/docker/check.go

@@ -179,6 +179,24 @@ func ResolveMxForVersion(mxbuildPath, preferredVersion string) (string, error) {
 	return "", fmt.Errorf("mx not found; specify --mxbuild-path pointing to Mendix installation directory")
 }
 
+// ResolveMxForNewProject finds the mx binary for use by mxcli new.
+// On Windows and macOS it prefers an installed Studio Pro to avoid downloading
+// Linux CDN binaries that won't execute on those platforms. On Linux (and as a
+// fallback) it downloads mxbuild from the CDN and derives mx from the same dir.
+func ResolveMxForNewProject(version string, progressWriter io.Writer) (string, error) {
+	// Fast path: Studio Pro or cached download already present
+	if mxPath, err := ResolveMxForVersion("", version); err == nil {
+		return mxPath, nil
+	}
+	// Slow path: download mxbuild from CDN (works on Linux; on macOS/Windows
+	// this is only reached if Studio Pro is not installed)
+	mxbuildPath, err := DownloadMxBuild(version, progressWriter)
+	if err != nil {
+		return "", err
+	}
+	return ResolveMx(mxbuildPath)
+}
+
 func CachedMxPath(version string) string {
 	cacheDir, err := MxBuildCacheDir(version)
 	if err != nil {

cmd/mxcli/docker/detect.go

@@ -9,13 +9,17 @@
 // 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.
+// On macOS, Studio Pro installs to "/Applications/Mendix Studio Pro X.Y.Z.app/".
+// CDN downloads are Linux ELF binaries and also cannot run on macOS.
+// Studio Pro installations are therefore preferred on macOS as well.
+//
+// On Linux (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)
+//  3. OS-specific known locations (Studio Pro on Windows and macOS)
 //  4. Cached CDN downloads (~/.mxcli/mxbuild/)
 //
 // Path discovery on Windows must NOT hardcode drive letters. Use environment
@@ -136,16 +140,40 @@ func resolveMxBuild(explicitPath string, preferredVersion ...string) (string, er
 }
 
 // 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.
+// Mendix version. Returns the installation root on Windows (e.g.,
+// "D:\Program Files\Mendix\11.6.4") or the app Contents directory on macOS
+// (e.g., "/Applications/Mendix Studio Pro 11.10.0.app/Contents").
+// Returns empty string if not found or on Linux.
 func ResolveStudioProDir(version string) string {
-	if runtime.GOOS != "windows" {
-		return ""
+	switch runtime.GOOS {
+	case "windows":
+		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
+			}
+		}
+	case "darwin":
+		return resolveStudioProDirMacOS(version)
 	}
-	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 ""
+}
+
+// resolveStudioProDirMacOS finds an installed Studio Pro on macOS that matches
+// the requested version. App bundles are named "Mendix Studio Pro X.Y.Z*.app"
+// where X.Y.Z is the base version (e.g., "11.10.0-rc.7 Beta" for 11.10.0).
+// Returns the bundle's Contents directory, or "" if not found.
+func resolveStudioProDirMacOS(version string) string {
+	matches, _ := filepath.Glob("/Applications/Mendix Studio Pro *.app")
+	re := regexp.MustCompile(`^Mendix Studio Pro (\d+\.\d+\.\d+)`)
+	for _, match := range matches {
+		base := strings.TrimSuffix(filepath.Base(match), ".app")
+		m := re.FindStringSubmatch(base)
+		if m == nil || m[1] != version {
+			continue
+		}
+		candidate := filepath.Join(match, "Contents")
+		if _, err := os.Stat(filepath.Join(candidate, "modeler", "mx")); err == nil {
 			return candidate
 		}
 	}
@@ -189,7 +217,7 @@ func mendixSearchPaths(binaryName string) []string {
 		}
 		return paths
 	case "darwin":
-		return []string{filepath.Join("/Applications/Mendix/*/modeler", binaryName)}
+		return []string{"/Applications/Mendix Studio Pro *.app/Contents/modeler/" + binaryName}
 	default: // linux
 		paths := []string{filepath.Join("/opt/mendix/*/modeler", binaryName)}
 		if home, err := os.UserHomeDir(); err == nil {

cmd/mxcli/docker/detect_test.go

@@ -197,12 +197,24 @@ func TestJdkSearchPaths_NoHardcodedDriveLetter(t *testing.T) {
 	}
 }
 
-func TestResolveStudioProDir_NotWindows(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("non-windows test")
+func TestResolveStudioProDir_Linux(t *testing.T) {
+	if runtime.GOOS != "linux" {
+		t.Skip("linux-only test")
 	}
 	if dir := ResolveStudioProDir("11.6.4"); dir != "" {
-		t.Errorf("expected empty on non-windows, got %s", dir)
+		t.Errorf("expected empty on linux, got %s", dir)
+	}
+}
+
+func TestResolveStudioProDir_MacOS_FakeInstall(t *testing.T) {
+	if runtime.GOOS != "darwin" {
+		t.Skip("macOS-only test")
+	}
+	// Simulate a Studio Pro .app bundle in a temp Applications directory.
+	// resolveStudioProDirMacOS is hard-coded to /Applications, so we test
+	// it indirectly by confirming that a non-existent version returns "".
+	if dir := resolveStudioProDirMacOS("0.0.0"); dir != "" {
+		t.Errorf("expected empty for non-existent version, got %s", dir)
 	}
 }
 

cmd/mxcli/docker/download.go

@@ -12,6 +12,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"strconv"
+	"regexp"
 	"strings"
 )
 
@@ -137,6 +138,10 @@ func NewestVersionedPath(paths []string) string {
 }
 
 func versionFromPath(path string) string {
+	// macOS Studio Pro bundles: .../Mendix Studio Pro X.Y.Z*.app/Contents/modeler/<binary>
+	if m := regexp.MustCompile(`Mendix Studio Pro (\d+\.\d+\.\d+)`).FindStringSubmatch(path); m != nil {
+		return m[1]
+	}
 	versionDir := filepath.Dir(filepath.Dir(path))
 	return filepath.Base(versionDir)
 }

cmd/mxcli/docker/download_test.go

@@ -194,3 +194,24 @@ func TestResolveMxBuild_FindsCachedVersion(t *testing.T) {
 		}
 	}
 }
+
+func TestVersionFromPath_MacOSAppBundle(t *testing.T) {
+	path := "/Applications/Mendix Studio Pro 11.10.0.app/Contents/modeler/mx"
+	if got := versionFromPath(path); got != "11.10.0" {
+		t.Errorf("versionFromPath(%q) = %q; want %q", path, got, "11.10.0")
+	}
+}
+
+func TestVersionFromPath_MacOSAppBundle_RC(t *testing.T) {
+	path := "/Applications/Mendix Studio Pro 11.10.0-rc.7 Beta.app/Contents/modeler/mx"
+	if got := versionFromPath(path); got != "11.10.0" {
+		t.Errorf("versionFromPath(%q) = %q; want %q", path, got, "11.10.0")
+	}
+}
+
+func TestVersionFromPath_CachedLinux(t *testing.T) {
+	path := "/home/user/.mxcli/mxbuild/11.9.0/modeler/mxbuild"
+	if got := versionFromPath(path); got != "11.9.0" {
+		t.Errorf("versionFromPath(%q) = %q; want %q", path, got, "11.9.0")
+	}
+}