Simplify things

- Do not clone + link the plugin, use the `mise plugin install ID URL` command instead
- Move as much nix plugin specific logic to install.go as possible

Author: ofalvai

toolprovider/mise/install.go

@@ -4,10 +4,51 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/bitrise-io/bitrise/v2/log"
 	"github.com/bitrise-io/bitrise/v2/toolprovider/mise/execenv"
+	"github.com/bitrise-io/bitrise/v2/toolprovider/mise/nixpkgs"
 	"github.com/bitrise-io/bitrise/v2/toolprovider/provider"
 )
 
+func installRequest(toolRequest provider.ToolRequest, useNix bool) provider.ToolRequest {
+	if useNix {
+		return provider.ToolRequest{
+			// Use Mise's backend plugin convention of pluginID:toolID
+			ToolName:           provider.ToolID(fmt.Sprintf("%s:%s", nixpkgs.PluginName,toolRequest.ToolName)),
+			UnparsedVersion:    toolRequest.UnparsedVersion,
+			ResolutionStrategy: toolRequest.ResolutionStrategy,
+			PluginURL:          nil, // Not relevant when using nixpkgs backend plugin
+		}
+	} else {
+		return toolRequest
+	}
+}
+
+func (m *MiseToolProvider) canBeInstalledWithNix(tool provider.ToolRequest) (bool, error) {
+	if !nixpkgs.ShouldUseBackend(tool) {
+		return false, nil
+	}
+
+	output, err := m.ExecEnv.RunMisePlugin("install", nixpkgs.PluginName, nixpkgs.PluginGitURL)
+	if err != nil {
+		return false, fmt.Errorf("install %s: %s", nixpkgs.PluginGitURL, output)
+	}
+
+	nameWithBackend := provider.ToolID(fmt.Sprintf("nixpkgs:%s", tool.ToolName))
+
+	available, err := m.versionExists(nameWithBackend, tool.UnparsedVersion)
+	if err != nil {
+		log.Warnf("Error while checking nixpkgs index for %s@%s: %v. Falling back to core plugin installation.", tool.ToolName, tool.UnparsedVersion, err)
+		return false, nil
+	}
+	if !available {
+		log.Warnf("%s@%s not found in nixpkgs index, doing a source build. This may take some time...", tool.ToolName, tool.UnparsedVersion)
+		return false, nil
+	}
+
+	return true, nil
+}
+
 func (m *MiseToolProvider) installToolVersion(tool provider.ToolRequest) error {
 	versionString, err := miseVersionString(tool, m.resolveToLatestInstalled)
 	if err != nil {

toolprovider/mise/install_test.go

@@ -86,6 +86,7 @@ func TestMiseVersionString(t *testing.T) {
 			want:    "nixpkgs:[email protected]",
 			wantErr: false,
 		},
+		// TODO: more test cases?
 	}
 
 	for _, tt := range tests {

toolprovider/mise/mise.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
 
@@ -41,11 +40,6 @@ 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
 }
@@ -108,24 +102,25 @@ func (m *MiseToolProvider) Bootstrap() error {
 }
 
 func (m *MiseToolProvider) InstallTool(tool provider.ToolRequest) (provider.ToolInstallResult, error) {
-	useNix := m.shouldUseNixPkgs(tool)
+	useNix, err := m.canBeInstalledWithNix(tool)
+	if err != nil {
+		return provider.ToolInstallResult{}, err
+	}
 
-	if useNix {
-		tool.ToolName = provider.ToolID(fmt.Sprintf("nixpkgs:%s", tool.ToolName))
-	} else {
-		err := m.InstallPlugin(tool)
+	if !useNix {
+		err = m.InstallPlugin(tool)
 		if err != nil {
 			return provider.ToolInstallResult{}, fmt.Errorf("install tool plugin %s: %w", tool.ToolName, err)
 		}
-	}
+	} // else: nixpkgs plugin is already installed in ShouldInstallWithNix()
 
-	isAlreadyInstalled, err := isAlreadyInstalled(tool, m.resolveToLatestInstalled)
+	installRequest := installRequest(tool, useNix)
+	isAlreadyInstalled, err := isAlreadyInstalled(installRequest, m.resolveToLatestInstalled)
 	if err != nil {
 		return provider.ToolInstallResult{}, err
 	}
 
 	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)
@@ -137,20 +132,23 @@ func (m *MiseToolProvider) InstallTool(tool provider.ToolRequest) (provider.Tool
 				Cause:            fmt.Sprintf("no match for requested version %s", tool.UnparsedVersion),
 			}
 		}
-	}
+	} // else: version existence is already checked in canBeInstalledWithNix()
 
-	err = m.installToolVersion(tool)
+	err = m.installToolVersion(installRequest)
 	if err != nil {
 		return provider.ToolInstallResult{}, err
 	}
 
-	concreteVersion, err := m.resolveToConcreteVersionAfterInstall(tool)
+	concreteVersion, err := m.resolveToConcreteVersionAfterInstall(installRequest)
 	if err != nil {
 		return provider.ToolInstallResult{}, fmt.Errorf("resolve exact version after install: %w", err)
 	}
 
 	return provider.ToolInstallResult{
-		ToolName:           tool.ToolName,
+		// Note: we return installRequest.ToolName instead of the original tool.ToolName.
+		// This is because installRequest might use a custom backend plugin and the value returned here
+		// is what gets used in ActivateEnv(), the two should be consistent.
+		ToolName:           installRequest.ToolName,
 		IsAlreadyInstalled: isAlreadyInstalled,
 		ConcreteVersion:    concreteVersion,
 	}, nil
@@ -194,112 +192,3 @@ 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
-}

toolprovider/mise/nixpkgs/nixpkgs.go

@@ -0,0 +1,31 @@
+package nixpkgs
+
+import (
+	"os"
+	"strings"
+
+	"github.com/bitrise-io/bitrise/v2/log"
+	"github.com/bitrise-io/bitrise/v2/toolprovider/provider"
+)
+
+const (
+	PluginGitURL = "https://github.com/bitrise-io/mise-nixpkgs-plugin.git"
+	PluginName   = "mise-nixpkgs-plugin"
+)
+
+// TODO: check if Nix works at all
+
+func ShouldUseBackend(request provider.ToolRequest) bool {
+	if request.ToolName != "ruby" {
+		log.Debugf("[TOOLPROVIDER] The mise-nixpkgs backend is only enabled for Ruby for now. Using core plugin to install %s", request.ToolName)
+		return false
+	}
+
+	value, ok := os.LookupEnv("BITRISE_TOOLSETUP_FAST_INSTALL")
+	if ok && strings.TrimSpace(value) == "1" {
+		log.Debugf("[TOOLPROVIDER] Using nixpkgs backend for %s as BITRISE_TOOLSETUP_FAST_INSTALL is set", request.ToolName)
+		return true
+	}
+	log.Debugf("[TOOLPROVIDER] Using core plugin for %s", request.ToolName)
+	return false
+}

toolprovider/mise/resolve.go

@@ -103,19 +103,19 @@ func versionExists(executor MiseExecutor, toolName provider.ToolID, version stri
 		// Fallback: no installed versions found, fall through to remote (ls-remote) existence check.
 	}
 
-	search := string(toolName)
+	versionString := string(toolName)
 	if version != "" && version != "latest" && version != "installed" {
-		search = fmt.Sprintf("%s@%s", toolName, version)
+		versionString = fmt.Sprintf("%s@%s", toolName, version)
 	}
 
 	// Notes:
 	// - ls-remote accepts both fuzzy and concrete versions
 	// - it can return multiple versions (one per line) when a fuzzy version is provided
 	// - in case of no matching version, the exit code is still 0, just there is no output
 	// - in case of a non-existing tool, the exit code is 1, but a non-existing tool ID fails earlier than this check
-	output, err := executor.RunMiseWithTimeout(execenv.DefaultTimeout, "ls-remote", "--quiet", search)
+	output, err := executor.RunMiseWithTimeout(execenv.DefaultTimeout, "ls-remote", "--quiet", versionString)
 	if err != nil {
-		return false, fmt.Errorf("mise ls-remote %s: %w", search, err)
+		return false, fmt.Errorf("mise ls-remote %s: %w", versionString, err)
 	}
 
 	return strings.TrimSpace(string(output)) != "", nil