[BE-1876] Integrate nixpkgs plugin

integrationtests/toolprovider/mise/install_nixpkgs_ruby_test.go

@@ -0,0 +1,64 @@
+//go:build linux_and_mac
+// +build linux_and_mac
+
+package mise
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/bitrise-io/bitrise/v2/toolprovider/mise"
+	"github.com/bitrise-io/bitrise/v2/toolprovider/provider"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMiseInstallNixpkgsRuby(t *testing.T) {
+	tests := []struct {
+		name               string
+		requestedVersion   string
+		resolutionStrategy provider.ResolutionStrategy
+		expectedVersion    string
+	}{
+		{"Install specific version", "3.3.9", provider.ResolutionStrategyStrict, "3.3.9"},
+	}
+
+	for _, tt := range tests {
+		miseInstallDir := t.TempDir()
+		miseDataDir := t.TempDir()
+		miseProvider, err := mise.NewToolProvider(miseInstallDir, miseDataDir)
+		require.NoError(t, err)
+
+		err = miseProvider.Bootstrap()
+		require.NoError(t, err)
+
+		t.Run(tt.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
+			defer cancel()
+
+			done := make(chan bool)
+			var result provider.ToolInstallResult
+			var installErr error
+
+			go func() {
+				request := provider.ToolRequest{
+					ToolName:           "ruby",
+					UnparsedVersion:    tt.requestedVersion,
+					ResolutionStrategy: tt.resolutionStrategy,
+				}
+				result, installErr = miseProvider.InstallTool(request)
+				done <- true
+			}()
+
+			select {
+			case <-done:
+				require.NoError(t, installErr)
+				require.Equal(t, provider.ToolID("ruby"), result.ToolName)
+				require.Equal(t, tt.expectedVersion, result.ConcreteVersion)
+				require.False(t, result.IsAlreadyInstalled)
+			case <-ctx.Done():
+				t.Fatal("Test exceeded 1 minute timeout, installation was too slow for nixpkgs ruby")
+			}
+		})
+	}
+}

toolprovider/asdf/install_plugin.go

@@ -46,7 +46,7 @@ func (a *AsdfToolProvider) InstallPlugin(tool provider.ToolRequest) error {
 		log.Warnf("Failed to check if plugin is already installed: %v", err)
 	}
 	if installed {
-		log.Debugf("Tool plugin %s is already installed, skipping installation.", tool.ToolName)
+		log.Debugf("[TOOLPROVIDER] Tool plugin %s is already installed, skipping installation.", tool.ToolName)
 		return nil
 	}
 

toolprovider/mise/install_plugin.go

@@ -44,7 +44,7 @@ func (m *MiseToolProvider) InstallPlugin(tool provider.ToolRequest) error {
 	}
 	if plugin == nil {
 		// No plugin installation needed (either core tool or registry tool).
-		log.Debugf("No plugin installation needed for tool %s", tool.ToolName)
+		log.Debugf("[TOOLPROVIDER] No plugin installation needed for tool %s", tool.ToolName)
 		return nil
 	}
 
@@ -53,7 +53,7 @@ func (m *MiseToolProvider) InstallPlugin(tool provider.ToolRequest) error {
 		log.Warnf("Failed to check if plugin is already installed: %v", err)
 	}
 	if installed {
-		log.Debugf("Tool plugin %s is already installed, skipping installation.", tool.ToolName)
+		log.Debugf("[TOOLPROVIDER] Tool plugin %s is already installed, skipping installation.", tool.ToolName)
 		return nil
 	}
 

toolprovider/mise/install_test.go

@@ -76,6 +76,16 @@ func TestMiseVersionString(t *testing.T) {
 			want:    "",
 			wantErr: true,
 		},
+		{
+			name: "strict resolution with nixpkgs backend",
+			tool: provider.ToolRequest{
+				ToolName:           "nixpkgs:ruby",
+				UnparsedVersion:    "3.3.0",
+				ResolutionStrategy: provider.ResolutionStrategyStrict,
+			},
+			want:    "nixpkgs:[email protected]",
+			wantErr: false,
+		},
 	}
 
 	for _, tt := range tests {

toolprovider/mise/mise.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 
@@ -40,6 +41,11 @@ var miseStableChecksums = map[string]string{
 	"macos-arm64": "0b5893de7c8c274736867b7c4c7ed565b4429f4d6272521ace802f8a21422319",
 }
 
+const (
+	nixpkgsPluginGitURL = "https://github.com/bitrise-io/mise-nixpkgs-plugin.git"
+	nixpkgsPluginName   = "mise-nixpkgs-plugin"
+)
+
 type MiseToolProvider struct {
 	ExecEnv execenv.ExecEnv
 }
@@ -102,25 +108,34 @@ func (m *MiseToolProvider) Bootstrap() error {
 }
 
 func (m *MiseToolProvider) InstallTool(tool provider.ToolRequest) (provider.ToolInstallResult, error) {
-	err := m.InstallPlugin(tool)
-	if err != nil {
-		return provider.ToolInstallResult{}, fmt.Errorf("install tool plugin %s: %w", tool.ToolName, err)
+	useNix := m.shouldUseNixPkgs(tool)
+
+	if useNix {
+		tool.ToolName = provider.ToolID(fmt.Sprintf("nixpkgs:%s", tool.ToolName))
+	} else {
+		err := m.InstallPlugin(tool)
+		if err != nil {
+			return provider.ToolInstallResult{}, fmt.Errorf("install tool plugin %s: %w", tool.ToolName, err)
+		}
 	}
 
 	isAlreadyInstalled, err := isAlreadyInstalled(tool, m.resolveToLatestInstalled)
 	if err != nil {
 		return provider.ToolInstallResult{}, err
 	}
 
-	versionExists, err := m.versionExists(tool.ToolName, tool.UnparsedVersion)
-	if err != nil {
-		return provider.ToolInstallResult{}, fmt.Errorf("check if version exists: %w", err)
-	}
-	if !versionExists {
-		return provider.ToolInstallResult{}, provider.ToolInstallError{
-			ToolName:         tool.ToolName,
-			RequestedVersion: tool.UnparsedVersion,
-			Cause:            fmt.Sprintf("no match for requested version %s", tool.UnparsedVersion),
+	if !useNix {
+		// Nix already checks version existence previously
+		versionExists, err := m.versionExists(tool.ToolName, tool.UnparsedVersion)
+		if err != nil {
+			return provider.ToolInstallResult{}, fmt.Errorf("check if version exists: %w", err)
+		}
+		if !versionExists {
+			return provider.ToolInstallResult{}, provider.ToolInstallError{
+				ToolName:         tool.ToolName,
+				RequestedVersion: tool.UnparsedVersion,
+				Cause:            fmt.Sprintf("no match for requested version %s", tool.UnparsedVersion),
+			}
 		}
 	}
 
@@ -160,7 +175,7 @@ func isEdgeStack() (isEdge bool) {
 	} else {
 		isEdge = false
 	}
-	log.Debugf("Mise: Stack is edge: %s", isEdge)
+	log.Debugf("[TOOLPROVIDER] Stack is edge: %s", isEdge)
 	return
 }
 
@@ -179,3 +194,112 @@ func GetMiseChecksums() map[string]string {
 	// Fallback to stable version for non-edge stacks
 	return miseStableChecksums
 }
+
+func useNixPkgs(tool provider.ToolRequest) bool {
+	// Note: Add other tools here if needed
+	if tool.ToolName != "ruby" {
+		log.Debugf("[TOOLPROVIDER] Nix packages are only supported for ruby tool, current tool: %s", tool.ToolName)
+		return false
+	}
+
+	if value, variablePresent := os.LookupEnv("BITRISEIO_MISE_LEGACY_INSTALL"); variablePresent && strings.Contains(value, "1") {
+		log.Debugf("[TOOLPROVIDER] Using legacy install (non-nix) for tool: %s", tool.ToolName)
+		return false
+	}
+
+	return true
+}
+
+// shouldUseNixPkgs checks if Nix packages should be used for the tool installation.
+// It validates that the tool is eligible for Nix, the plugin is available, and the version exists in the index.
+// Returns false and logs a warning if any validation fails, falling back to legacy installation.
+func (m *MiseToolProvider) shouldUseNixPkgs(tool provider.ToolRequest) bool {
+	if !useNixPkgs(tool) {
+		return false
+	}
+
+	if err := m.getNixpkgsPlugin(); err != nil {
+		log.Warnf("Failed to link nixpkgs plugin: %v. Falling back to legacy installation.", err)
+		return false
+	}
+
+	nameWithBackend := provider.ToolID(fmt.Sprintf("nixpkgs:%s", tool.ToolName))
+
+	available, err := m.versionExists(nameWithBackend, tool.UnparsedVersion)
+	if err != nil || !available {
+		log.Warnf("Failed to check nixpkgs index for %s@%s: %v. Falling back to legacy installation.", tool.ToolName, tool.UnparsedVersion, err)
+		return false
+	}
+
+	return true
+}
+
+// findPluginPath finds the nixpkgs plugin directory relative to the bitrise executable.
+// It first checks next to the binary, then tries a dev location one directory up.
+// Returns the path if found, otherwise returns an error.
+func findPluginPath() (string, error) {
+	execPath, err := os.Executable()
+	if err != nil {
+		return "", fmt.Errorf("get executable path: %w", err)
+	}
+
+	execDir := filepath.Dir(execPath)
+	pluginPath := filepath.Join(execDir, nixpkgsPluginName)
+
+	// Check if the plugin exists besides the binary
+	if _, err := os.Stat(pluginPath); os.IsNotExist(err) {
+		// Try dev location
+		pluginPath = filepath.Join(execDir, "..", nixpkgsPluginName)
+		if _, err := os.Stat(pluginPath); os.IsNotExist(err) {
+			return "", fmt.Errorf("%s not found", nixpkgsPluginName)
+		}
+	}
+
+	return pluginPath, nil
+}
+
+// getNixpkgsPlugin clones or updates the nixpkgs backend plugin and links it to mise.
+// If the plugin directory doesn't exist, it clones from the git URL.
+// If it exists, it checks out the specified commit/branch.
+func (m *MiseToolProvider) getNixpkgsPlugin() error {
+	pluginPath, err := findPluginPath()
+	needsClone := false
+	if err != nil {
+		// Plugin doesn't exist, we need to clone it
+		needsClone = true
+		execPath, execErr := os.Executable()
+		if execErr != nil {
+			return fmt.Errorf("get executable path: %w", execErr)
+		}
+		pluginPath = filepath.Join(filepath.Dir(execPath), nixpkgsPluginName)
+	}
+
+	if needsClone {
+		if err := cloneGitRepo(nixpkgsPluginGitURL, pluginPath); err != nil {
+			return fmt.Errorf("clone nixpkgs plugin: %w", err)
+		}
+	}
+
+	// Link the plugin using mise plugin link
+	_, err = m.ExecEnv.RunMisePlugin("link", "--force", "nixpkgs", pluginPath)
+	if err != nil {
+		return fmt.Errorf("link nixpkgs plugin: %w", err)
+	}
+
+	// Enable experimental settings for custom backend
+	if _, err := m.ExecEnv.RunMise("settings", "experimental=true"); err != nil {
+		return fmt.Errorf("enable experimental settings: %w", err)
+	}
+
+	return nil
+}
+
+// cloneGitRepo clones a git repository to the specified path with minimal history.
+func cloneGitRepo(repoURL, destPath string) error {
+	cmd := exec.Command("git", "clone", "--depth", "1", "--no-tags", repoURL, destPath)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("git clone failed: %w: %s", err, string(output))
+	}
+	return nil
+}