fix(ruby): set LD_LIBRARY_PATH for Unix Ruby binaries

The Ruby binaries from ruby-builder on Unix require libruby.so which is
located in the installation's lib directory. Added GetEnvironment method
to Provider interface so providers can specify environment variables
needed when executing their binaries.

Ruby provider now sets:
- LD_LIBRARY_PATH on Linux
- DYLD_LIBRARY_PATH on macOS

This fixes the "error while loading shared libraries: libruby.so.3.3:
cannot open shared object file" error on Unix systems.

Author: CalvinAllen

src/cmd/install_test.go

@@ -46,6 +46,10 @@ func (m *mockProvider) ManualPackageInstallCommand(packages []string) string {
 	return ""
 }
 
+func (m *mockProvider) GetEnvironment(_ string) (map[string]string, error) {
+	return map[string]string{}, nil
+}
+
 func (m *mockProvider) GlobalVersion() (string, error) {
 	return m.globalVersion, nil
 }

src/cmd/shim/main.go

@@ -85,13 +85,23 @@ func runShim() error {
 	execPath = adjustExecutablePath(execPath, shimName, runtimeName)
 	ui.Debug("Final executable path: %s", execPath)
 
+	// Get provider-specific environment variables (e.g., LD_LIBRARY_PATH for Ruby)
+	providerEnv, err := provider.GetEnvironment(version)
+	if err != nil {
+		ui.Debug("Failed to get provider environment: %v", err)
+		providerEnv = map[string]string{}
+	}
+	for k, v := range providerEnv {
+		ui.Debug("Provider env: %s=%s", k, v)
+	}
+
 	// Check if this command should trigger a reshim after execution
 	needsReshim := provider.ShouldReshimAfter(shimName, os.Args[1:])
 
 	// Execute the actual binary
 	if needsReshim {
 		// Need to run code after execution, so use exec.Command
-		exitCode := executeCommandWithWait(execPath, os.Args[1:])
+		exitCode := executeCommandWithWait(execPath, os.Args[1:], providerEnv)
 
 		// If command succeeded, prompt for reshim
 		if exitCode == 0 {
@@ -101,7 +111,7 @@ func runShim() error {
 		os.Exit(exitCode)
 	} else {
 		// Normal execution - use syscall.Exec on Unix for efficiency
-		if err := executeCommand(execPath, os.Args[1:]); err != nil {
+		if err := executeCommand(execPath, os.Args[1:], providerEnv); err != nil {
 			return fmt.Errorf("failed to execute %s: %w", execPath, err)
 		}
 	}
@@ -123,8 +133,8 @@ func handleNoConfiguredVersion(shimName, runtimeName string, provider runtime.Sh
 		ui.Info("Or see available versions: dtvem list-all %s", runtimeName)
 		fmt.Fprintln(os.Stderr) // Empty line for spacing
 
-		// Execute the system version
-		if err := executeCommand(systemPath, os.Args[1:]); err != nil {
+		// Execute the system version (no provider env needed for system installations)
+		if err := executeCommand(systemPath, os.Args[1:], nil); err != nil {
 			return fmt.Errorf("failed to execute system %s: %w", shimName, err)
 		}
 		return nil
@@ -243,13 +253,13 @@ func adjustExecutablePath(execPath, shimName, runtimeName string) string {
 	return execPath
 }
 
-// executeCommand executes a command with the given arguments
-func executeCommand(execPath string, args []string) error {
+// executeCommand executes a command with the given arguments and provider environment
+func executeCommand(execPath string, args []string, providerEnv map[string]string) error {
 	// Build full args (executable name + arguments)
 	fullArgs := append([]string{execPath}, args...)
 
-	// Get current environment
-	env := os.Environ()
+	// Get current environment and apply provider overrides
+	env := mergeEnvironment(os.Environ(), providerEnv)
 
 	// On Unix systems, use Exec to replace the current process
 	// On Windows, Exec is not available, so we use StartProcess
@@ -280,12 +290,12 @@ func executeCommand(execPath string, args []string) error {
 }
 
 // executeCommandWithWait executes a command and waits for it to complete, returning the exit code
-func executeCommandWithWait(execPath string, args []string) int {
+func executeCommandWithWait(execPath string, args []string, providerEnv map[string]string) int {
 	// Build full args (executable name + arguments)
 	fullArgs := append([]string{execPath}, args...)
 
-	// Get current environment
-	env := os.Environ()
+	// Get current environment and apply provider overrides
+	env := mergeEnvironment(os.Environ(), providerEnv)
 
 	// Use exec.Command to run the command and wait for completion
 	cmd := &exec.Cmd{
@@ -310,6 +320,43 @@ func executeCommandWithWait(execPath string, args []string) int {
 	return 0
 }
 
+// mergeEnvironment merges provider environment variables into the base environment.
+// Provider variables are prepended to existing values (for PATH-like variables) or set directly.
+func mergeEnvironment(baseEnv []string, providerEnv map[string]string) []string {
+	if len(providerEnv) == 0 {
+		return baseEnv
+	}
+
+	// Build a map of existing environment variables for easy lookup
+	envMap := make(map[string]string)
+	for _, e := range baseEnv {
+		if idx := strings.Index(e, "="); idx != -1 {
+			key := e[:idx]
+			value := e[idx+1:]
+			envMap[key] = value
+		}
+	}
+
+	// Apply provider environment variables
+	// For PATH-like variables (LD_LIBRARY_PATH, DYLD_LIBRARY_PATH), prepend the new value
+	for key, value := range providerEnv {
+		if existing, ok := envMap[key]; ok && existing != "" {
+			// Prepend new value to existing (for PATH-like variables)
+			envMap[key] = value + string(filepath.ListSeparator) + existing
+		} else {
+			envMap[key] = value
+		}
+	}
+
+	// Convert back to slice format
+	result := make([]string, 0, len(envMap))
+	for key, value := range envMap {
+		result = append(result, key+"="+value)
+	}
+
+	return result
+}
+
 // promptReshim prompts the user to run reshim after installing global packages
 func promptReshim() {
 	fmt.Fprintln(os.Stderr) // Empty line for spacing

src/internal/runtime/provider.go

@@ -28,6 +28,11 @@ type ShimProvider interface {
 	// The shimName parameter indicates which shim was invoked (e.g., "npm", "pip")
 	// The args parameter contains the command arguments (e.g., ["install", "-g", "typescript"])
 	ShouldReshimAfter(shimName string, args []string) bool
+
+	// GetEnvironment returns environment variables that should be set when executing
+	// this runtime's binaries. For example, Ruby needs LD_LIBRARY_PATH set to find libruby.so.
+	// Returns an empty map if no special environment is needed.
+	GetEnvironment(version string) (map[string]string, error)
 }
 
 // Provider defines the full interface that all runtime providers must implement.

src/internal/runtime/registry_test.go

@@ -30,6 +30,9 @@ func (m *mockProvider) GlobalPackages(installPath string) ([]string, error)
 func (m *mockProvider) InstallGlobalPackages(version string, packages []string) error { return nil }
 func (m *mockProvider) ManualPackageInstallCommand(packages []string) string          { return "" }
 func (m *mockProvider) ShouldReshimAfter(shimName string, args []string) bool         { return false }
+func (m *mockProvider) GetEnvironment(_ string) (map[string]string, error) {
+	return map[string]string{}, nil
+}
 
 func TestNewRegistry(t *testing.T) {
 	r := NewRegistry()

src/internal/shim/manager_test.go

@@ -37,6 +37,9 @@ func (m *mockProvider) GlobalPackages(installPath string) ([]string, error)
 func (m *mockProvider) InstallGlobalPackages(version string, packages []string) error { return nil }
 func (m *mockProvider) ManualPackageInstallCommand(packages []string) string          { return "" }
 func (m *mockProvider) ShouldReshimAfter(shimName string, args []string) bool         { return false }
+func (m *mockProvider) GetEnvironment(_ string) (map[string]string, error) {
+	return map[string]string{}, nil
+}
 
 func TestRuntimeShims(t *testing.T) {
 	// Register test providers

src/runtimes/node/provider.go

@@ -490,6 +490,12 @@ func (p *Provider) ShouldReshimAfter(shimName string, args []string) bool {
 	return false
 }
 
+// GetEnvironment returns environment variables needed to run Node.js binaries.
+// Node.js binaries are self-contained and don't require special environment setup.
+func (p *Provider) GetEnvironment(_ string) (map[string]string, error) {
+	return map[string]string{}, nil
+}
+
 // init registers the Node.js provider on package load
 func init() {
 	if err := runtime.Register(NewProvider()); err != nil {

src/runtimes/python/provider.go

@@ -687,6 +687,13 @@ func (p *Provider) ShouldReshimAfter(shimName string, args []string) bool {
 	return cmd == "install" || cmd == "uninstall"
 }
 
+// GetEnvironment returns environment variables needed to run Python binaries.
+// Python binaries from python-build-standalone are relocatable and don't require
+// special environment setup.
+func (p *Provider) GetEnvironment(_ string) (map[string]string, error) {
+	return map[string]string{}, nil
+}
+
 // init registers the Python provider on package load
 func init() {
 	if err := runtime.Register(NewProvider()); err != nil {

src/runtimes/ruby/provider.go

@@ -792,6 +792,38 @@ func (p *Provider) ShouldReshimAfter(shimName string, args []string) bool {
 	return false
 }
 
+// GetEnvironment returns environment variables needed to run Ruby binaries.
+// On Unix systems, Ruby from ruby-builder needs LD_LIBRARY_PATH (Linux) or
+// DYLD_LIBRARY_PATH (macOS) set to find libruby.so.
+func (p *Provider) GetEnvironment(version string) (map[string]string, error) {
+	// Windows RubyInstaller binaries are self-contained, no special environment needed
+	if goruntime.GOOS == constants.OSWindows {
+		return map[string]string{}, nil
+	}
+
+	// Get the install path for this version
+	installPath, err := p.InstallPath(version)
+	if err != nil {
+		return nil, err
+	}
+
+	// The lib directory contains libruby.so
+	libPath := filepath.Join(installPath, "lib")
+
+	env := make(map[string]string)
+
+	// Set the appropriate library path based on platform
+	if goruntime.GOOS == constants.OSDarwin {
+		// macOS uses DYLD_LIBRARY_PATH
+		env["DYLD_LIBRARY_PATH"] = libPath
+	} else {
+		// Linux uses LD_LIBRARY_PATH
+		env["LD_LIBRARY_PATH"] = libPath
+	}
+
+	return env, nil
+}
+
 // init registers the Ruby provider on package load
 func init() {
 	if err := runtime.Register(NewProvider()); err != nil {