Fix: allow vfox use --global without shell hook support (Docker compatibility)

When running in Docker RUN commands, `.bashrc` is not sourced by non-interactive
bash, so __VFOX_SHELL is never set and vfox use --global fails with the hook
error. Global scope only writes a config file and creates symlinks, so it does
not need shell hook support.

- In UseWithConfig: on non-Windows, only return the hook error when scope is
  NOT global (mirrors the Windows behaviour)
- In useInHook: when hook env is absent and scope is global, skip spawning a
  new shell and print a helpful hint instead
- Add TestUseWithConfig_NoHookEnv to verify session/project scopes still require
  hook support while global scope does not

Co-authored-by: aooohan <40265686+aooohan@users.noreply.github.com>

Author: Copilot

internal/sdk/sdk.go

@@ -543,7 +543,11 @@ func (b *impl) UseWithConfig(version Version, scope env.UseScope, unlink bool) e
 				pterm.Printf("Warning: The current shell lacks hook support. Switching to global scope automatically.\n")
 				scope = env.Global
 			}
-		} else {
+		} else if scope != env.Global {
+			// On non-Windows, only global scope is allowed without hook support.
+			// Session and project scopes require shell hooks to propagate environment variables.
+			// Global scope only writes a config file and creates symlinks, so it works fine
+			// in non-interactive environments such as Docker RUN commands.
 			logger.Debugf("Hook environment not available\n")
 			return fmt.Errorf("vfox requires hook support. Please ensure vfox is properly initialized with 'vfox activate'")
 		}
@@ -668,8 +672,14 @@ func (b *impl) useInHook(version Version, scope env.UseScope, unlink bool, hookE
 	pterm.Printf("Now using %s.\n", pterm.LightGreen(b.Label(version)))
 	logger.Debugf("Successfully using SDK: %s\n", b.Label(version))
 
-	// In non-hook environment, spawn a new shell so the user can use the new version immediately
+	// In non-hook environment, spawn a new shell so the user can use the new version immediately.
+	// For global scope, spawning a shell is unnecessary because the version is persisted via
+	// config file and symlinks — no shell-session state needs to be updated.
 	if !hookEnv {
+		if scope == env.Global {
+			pterm.Printf("Please start a new shell session or run 'eval \"$(vfox activate <shell>)\"' to use the new version.\n")
+			return nil
+		}
 		return shell.Open(os.Getppid())
 	}
 

internal/sdk/sdk_test.go

@@ -510,6 +510,76 @@ func TestEnsureVfoxInGitignore(t *testing.T) {
 	}
 }
 
+// TestUseWithConfig_NoHookEnv verifies that UseWithConfig behaves correctly
+// when the shell hook environment is not active (e.g., in Docker RUN commands).
+// Global scope should be allowed; session and project scopes should return an error.
+func TestUseWithConfig_NoHookEnv(t *testing.T) {
+	// Ensure __VFOX_SHELL is unset for this test
+	orig := os.Getenv(env.HookFlag)
+	os.Unsetenv(env.HookFlag)
+	defer func() {
+		if orig != "" {
+			os.Setenv(env.HookFlag, orig)
+		}
+	}()
+
+	tempDir := t.TempDir()
+	pathMeta := &pathmeta.PathMeta{
+		User: pathmeta.UserPaths{
+			Home: filepath.Join(tempDir, "user"),
+		},
+		Shared: pathmeta.SharedPaths{
+			Installs: filepath.Join(tempDir, "shared", "installs"),
+		},
+		Working: pathmeta.WorkingPaths{
+			Directory:     filepath.Join(tempDir, "project"),
+			ProjectSdkDir: filepath.Join(tempDir, "project", ".vfox", "sdk"),
+			SessionSdkDir: filepath.Join(tempDir, "session", "sdk"),
+			GlobalSdkDir:  filepath.Join(tempDir, "user", "sdk"),
+		},
+	}
+
+	runtimeEnvContext := &env.RuntimeEnvContext{
+		PathMeta: pathMeta,
+	}
+
+	sdkImpl := &impl{
+		Name:        "test-sdk",
+		envContext:  runtimeEnvContext,
+		InstallPath: filepath.Join(pathMeta.Shared.Installs, "test-sdk"),
+	}
+
+	// Session and project scopes must return a hook error when __VFOX_SHELL is not set.
+	for _, scope := range []env.UseScope{env.Session, env.Project} {
+		scope := scope
+		t.Run(scope.String()+" scope returns hook error without hook env", func(t *testing.T) {
+			err := sdkImpl.UseWithConfig("1.0.0", scope, false)
+			if err == nil || !strings.Contains(err.Error(), "vfox requires hook support") {
+				t.Errorf("scope=%v: expected 'vfox requires hook support' error, got: %v", scope, err)
+			}
+		})
+	}
+
+	// Global scope must NOT return a hook error when __VFOX_SHELL is not set.
+	// It should proceed past the hook check (it will fail later with a missing plugin/version
+	// error since this is a minimal test fixture, but NOT with the hook-support error).
+	t.Run("global scope does not return hook error without hook env", func(t *testing.T) {
+		var gotHookErr bool
+		func() {
+			// The call will panic or return an error due to the missing plugin in the test
+			// fixture — that is acceptable. We only care that it is NOT a hook-support error.
+			defer func() { recover() }() //nolint:errcheck
+			err := sdkImpl.UseWithConfig("1.0.0", env.Global, false)
+			if err != nil && strings.Contains(err.Error(), "vfox requires hook support") {
+				gotHookErr = true
+			}
+		}()
+		if gotHookErr {
+			t.Error("global scope must not return 'vfox requires hook support' error when hook env is not set")
+		}
+	})
+}
+
 // Helper function to check if a line exists in content
 func containsLine(content, line string) bool {
 	lines := splitLines(content)