[BE-1876] Integrate nixpkgs plugin (#1156)

* [BE-1876] Integrate nixpkgs plugin

* Check for version in index, remove plugin version pinning, fixes

* *

* Fix test version

* Rename tool

* Remove index checking, use listing

* *

* Timeout on test

* 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

* Get rid of MiseExecutor, make ExecEnv mockable instead

MiseExecutor as an interface was created for testing, but I relized this is redundant and ExecEnv should be mockable instead.

* Change plugin ID to final value

This is what we must use a prefix in tool install commands, so let's use the final value (which can be different than what is the git repo's name)

* Unit tests

* Add force flag for integration testing

Also don't return unexpected errors from the function. It's not that the caller would do anything with unexpected errors, it's just going to fallback to the default behavior

* Integration tests

* Add check before executing nix commands

* Make feature flag value true instead of 1

* AI reviewer fixes

* chore: trigger CI checks

* Raise timeout, install backend even with force install

* Lint

* Fix tests, update plugin

* Decrease validate timeout

* Fix tests

* *

* Tests working on stable stacks too, consistent commenting

* Remove nix availability check

* Fake nix checking in tests instead of env var override

* Fixes

* Comments

* *

---------

Co-authored-by: Olivér Falvai <[email protected]>
Co-authored-by: Olivér Falvai <[email protected]>

Author: marcell-vida

bitrise.yml

@@ -75,7 +75,8 @@ workflows:
     - bundle::run_integration_tests: { }
     meta:
       bitrise.io:
-        stack: osx-xcode-16.4.x
+        # TODO: switch to stable stack when Nix is rolled out there
+        stack: osx-xcode-edge
         machine_type_id: g2.mac.large
 
   run_integration_tests_linux:
@@ -86,6 +87,11 @@ workflows:
         - workflow_id: unpin-go-version
     - bundle::setup_go_junit_report: { }
     - bundle::run_integration_tests: { }
+    meta:
+      bitrise.io:
+        # TODO: switch to stable stack when Nix is rolled out there
+        stack: ubuntu-noble-24.04-bitrise-2025-android
+        machine_type_id: g2.linux.x-large
 
   run_docker_integration_tests_linux:
     steps:

integrationtests/toolprovider/mise/install_nixpkgs_ruby_test.go

@@ -0,0 +1,95 @@
+//go:build linux_and_mac
+// +build linux_and_mac
+
+package mise
+
+import (
+	"testing"
+
+	"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
+		tool               string
+		version            string
+		resolutionStrategy provider.ResolutionStrategy
+		want               string
+		wantErr            bool
+	}{
+		{
+			name:               "Install specific version",
+			tool:               "ruby",
+			version:            "3.3.9",
+			resolutionStrategy: provider.ResolutionStrategyStrict,
+			want:               "3.3.9",
+		},
+		{
+			name:               "Install fuzzy version and released strategy",
+			tool:               "ruby",
+			version:            "3.1", // EOL version, won't receive new patch versions suddenly
+			resolutionStrategy: provider.ResolutionStrategyLatestReleased,
+			want:               "3.1.7",
+		},
+		{
+			name:               "Install fuzzy version and installed strategy",
+			tool:               "ruby",
+			version:            "3.1", // EOL version, won't receive new patch versions
+			resolutionStrategy: provider.ResolutionStrategyLatestInstalled,
+			want:               "3.1.7",
+		},
+		{
+			name:               "Nonexistent version in nixpkgs index",
+			tool:               "ruby",
+			version:            "0.1.999",
+			resolutionStrategy: provider.ResolutionStrategyStrict,
+			wantErr:            true,
+		},
+		{
+			name:               "Install some other tool with forced nixpkgs backend",
+			tool:               "node",
+			version:            "22.22.1",
+			resolutionStrategy: provider.ResolutionStrategyStrict,
+			wantErr:            true,
+		},
+	}
+
+	t.Setenv("BITRISE_TOOLSETUP_FAST_INSTALL", "true")
+	t.Setenv("BITRISE_TOOLSETUP_FAST_INSTALL_FORCE", "true")
+
+	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) {
+			request := provider.ToolRequest{
+				ToolName:           provider.ToolID(tt.tool),
+				UnparsedVersion:    tt.version,
+				ResolutionStrategy: tt.resolutionStrategy,
+			}
+			result, installErr := miseProvider.InstallTool(request)
+
+			if tt.wantErr {
+				require.Error(t, installErr)
+				return
+			}
+			require.NoError(t, installErr)
+			if tt.tool == "ruby" {
+				// We purposely return ruby with the nixpkgs: prefix for environment activation later
+				require.Equal(t, provider.ToolID("nixpkgs:ruby"), result.ToolName)
+			} else {
+				require.Equal(t, provider.ToolID(tt.tool), result.ToolName)
+			}
+			require.Equal(t, tt.want, result.ConcreteVersion)
+			require.False(t, result.IsAlreadyInstalled)
+		})
+	}
+}

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/bootstrap.go

@@ -23,18 +23,18 @@ const fallbackDownloadURLBase = "https://storage.googleapis.com/mise-release-mir
 func isMiseInstalled(targetDir string) bool {
 	misePath := filepath.Join(targetDir, "bin", "mise")
 
-	// Check if the file exists and is executable
+	// Check if the file exists and is executable.
 	info, err := os.Stat(misePath)
 	if err != nil {
 		return false
 	}
 
-	// Check if it's a regular file and has execute permissions
+	// Check if it's a regular file and has execute permissions.
 	if !info.Mode().IsRegular() || info.Mode().Perm()&0111 == 0 {
 		return false
 	}
 
-	// Try to run mise --version to verify it's actually runnable
+	// Try to run mise --version to verify it's actually runnable.
 	cmd := exec.Command(misePath, "--version")
 	err = cmd.Run()
 	return err == nil
@@ -106,7 +106,7 @@ func downloadAndVerify(url, expectedChecksum string) (string, error) {
 		_ = tempFile.Close()
 	}()
 
-	// Compute SHA256 hash of the downloaded file and store contents in the temp file
+	// Compute SHA256 hash of the downloaded file and store contents in the temp file.
 	hash := sha256.New()
 	multiWriter := io.MultiWriter(tempFile, hash)
 	if _, err := io.Copy(multiWriter, resp.Body); err != nil {
@@ -211,18 +211,18 @@ func FallbackDownloadURL(version, platformName string) string {
 
 // processHeader processes a tar header and determines the target extraction path.
 func processHeader(header *tar.Header, targetDir string) (string, bool) {
-	// Skip the top-level "mise" directory and extract its contents directly
+	// Skip the top-level "mise" directory and extract its contents directly.
 	pathParts := strings.Split(header.Name, "/")
 	if len(pathParts) > 0 && pathParts[0] == "mise" {
 		if len(pathParts) == 1 {
-			// This is the top-level "mise" directory itself, skip it
+			// This is the top-level "mise" directory itself, skip it.
 			return "", false
 		}
-		// Remove the top-level "mise" directory from the path
+		// Remove the top-level "mise" directory from the path.
 		header.Name = strings.Join(pathParts[1:], "/")
 	}
 
-	// Clean the path to prevent directory traversal attacks
+	// Clean the path to prevent directory traversal attacks.
 	targetPath := filepath.Join(targetDir, header.Name)
 	if !strings.HasPrefix(targetPath, filepath.Clean(targetDir)) {
 		return "", false
@@ -260,14 +260,14 @@ func extractFile(tarReader *tar.Reader, header *tar.Header, targetPath string) e
 		}
 
 		if filepath.Base(targetPath) == "mise" {
-			// Make mise binary executable
+			// Make mise binary executable.
 			err = os.Chmod(targetPath, 0755)
 			if err != nil {
 				return fmt.Errorf("make mise binary executable %s: %w", targetPath, err)
 			}
 		}
 	default:
-		// Skip other file types (symlinks, etc.)
+		// Skip other file types (symlinks, etc.).
 	}
 	return nil
 }

toolprovider/mise/execenv/execenv.go

@@ -16,28 +16,42 @@ const (
 
 // ExecEnv contains everything needed to run mise commands in a specific environment
 // that is installed and pre-configured.
-type ExecEnv struct {
+type ExecEnv interface {
 	// InstallDir is the directory where mise is installed. This is not necessarily the same as the data directory.
-	InstallDir string
+	InstallDir() string
+	RunMise(args ...string) (string, error)
+	RunMiseWithTimeout(timeout time.Duration, args ...string) (string, error)
+	RunMisePlugin(args ...string) (string, error)
+}
+
+type MiseExecEnv struct {
+	installDir string
 
-	// Additional env vars that configure mise and are required for its operation.
-	ExtraEnvs map[string]string
+	extraEnvs map[string]string
 }
 
-func (e *ExecEnv) RunMise(args ...string) (string, error) {
+// extraEnvs: additional env vars that configure mise and are required for its operation.
+func NewMiseExecEnv(installDir string, extraEnvs map[string]string) MiseExecEnv {
+	return MiseExecEnv{
+		installDir: installDir,
+		extraEnvs:  extraEnvs,
+	}
+}
+
+func (e MiseExecEnv) RunMise(args ...string) (string, error) {
 	return e.RunMiseWithTimeout(0, args...)
 }
 
-func (e *ExecEnv) RunMisePlugin(args ...string) (string, error) {
+func (e MiseExecEnv) RunMisePlugin(args ...string) (string, error) {
 	cmdWithArgs := append([]string{"plugin"}, args...)
 
-	// Use timeout for all plugin operations as they involve unknown code execution
+	// Use timeout for all plugin operations as they involve unknown code execution.
 	return e.RunMiseWithTimeout(DefaultTimeout, cmdWithArgs...)
 }
 
 // RunMiseWithTimeout runs mise commands that involve untrusted operations (plugin execution, remote network calls)
-// with a timeout to prevent hanging
-func (e *ExecEnv) RunMiseWithTimeout(timeout time.Duration, args ...string) (string, error) {
+// with a timeout to prevent hanging.
+func (e MiseExecEnv) RunMiseWithTimeout(timeout time.Duration, args ...string) (string, error) {
 	var ctx context.Context
 	if timeout == 0 {
 		ctx = context.Background()
@@ -47,10 +61,10 @@ func (e *ExecEnv) RunMiseWithTimeout(timeout time.Duration, args ...string) (str
 		defer cancel()
 	}
 
-	executable := filepath.Join(e.InstallDir, "bin", "mise")
+	executable := filepath.Join(e.installDir, "bin", "mise")
 	cmd := exec.CommandContext(ctx, executable, args...)
 	cmd.Env = os.Environ()
-	for k, v := range e.ExtraEnvs {
+	for k, v := range e.extraEnvs {
 		cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", k, v))
 	}
 	output, err := cmd.CombinedOutput()
@@ -63,3 +77,7 @@ func (e *ExecEnv) RunMiseWithTimeout(timeout time.Duration, args ...string) (str
 
 	return string(output), nil
 }
+
+func (e MiseExecEnv) InstallDir() string {
+	return e.installDir
+}

toolprovider/mise/helpers_test.go

@@ -0,0 +1,59 @@
+package mise
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+type fakeExecEnv struct {
+	// responses maps command strings to their outputs.
+	responses map[string]string
+	// errors maps command strings to errors.
+	errors map[string]error
+}
+
+func newFakeExecEnv() *fakeExecEnv {
+	return &fakeExecEnv{
+		responses: make(map[string]string),
+		errors:    make(map[string]error),
+	}
+}
+
+func (m *fakeExecEnv) setResponse(cmdKey string, output string) {
+	m.responses[cmdKey] = output
+}
+
+func (m *fakeExecEnv) setError(cmdKey string, err error) {
+	m.errors[cmdKey] = err
+}
+
+func (m *fakeExecEnv) InstallDir() string {
+	return "/fake/mise/install/dir"
+}
+
+func (m *fakeExecEnv) RunMise(args ...string) (string, error) {
+	return m.runCommand(args...)
+}
+
+func (m *fakeExecEnv) RunMisePlugin(args ...string) (string, error) {
+	return m.runCommand(append([]string{"plugin"}, args...)...)
+}
+
+func (m *fakeExecEnv) RunMiseWithTimeout(timeout time.Duration, args ...string) (string, error) {
+	return m.runCommand(args...)
+}
+
+func (m *fakeExecEnv) runCommand(args ...string) (string, error) {
+	cmdKey := strings.Join(args, " ")
+
+	if err, ok := m.errors[cmdKey]; ok {
+		return "", err
+	}
+
+	if output, ok := m.responses[cmdKey]; ok {
+		return output, nil
+	}
+
+	return "", fmt.Errorf("no mock response configured for command: %s", cmdKey)
+}