48 | ```
49 | :::
50 |
51 |
52 |
53 |
54 |
55 |
56 |
59 |
![]()
60 |
61 |
{{item.desc}}
62 |
63 |
64 |
Loading, please be patient...
66 |
67 |
--------------------------------------------------------------------------------
/internal/config/cache.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package config
18 |
19 | import (
20 | "fmt"
21 | "time"
22 |
23 | "gopkg.in/yaml.v3"
24 | )
25 |
26 | var (
27 | EmptyCache = &Cache{
28 | AvailableHookDuration: CacheDuration(12 * time.Hour),
29 | }
30 | )
31 |
32 | // Cache is the cache configuration
33 | type Cache struct {
34 | AvailableHookDuration CacheDuration `yaml:"availableHookDuration"` // Available hook result cache time
35 | }
36 |
37 | // CacheDuration is a duration that represents the cache duration and some special values
38 | // -1: never expire
39 | // 0: never cache
40 | type CacheDuration time.Duration
41 |
42 | func (d CacheDuration) MarshalYAML() (interface{}, error) {
43 | switch d {
44 | case -1:
45 | return -1, nil
46 | case 0:
47 | return 0, nil
48 | default:
49 | return d.String(), nil
50 | }
51 | }
52 |
53 | func (d *CacheDuration) UnmarshalYAML(node *yaml.Node) error {
54 | var data any
55 | err := node.Decode(&data)
56 | if err != nil {
57 | return err
58 | }
59 | switch va := data.(type) {
60 | case int:
61 | *d = CacheDuration(va)
62 | case string:
63 | pd, err := time.ParseDuration(va)
64 | if err != nil {
65 | return err
66 | }
67 | *d = CacheDuration(pd)
68 | }
69 | return nil
70 | }
71 |
72 | func (d CacheDuration) String() string {
73 | switch d {
74 | case -1:
75 | return "-1"
76 | case 0:
77 | return "0"
78 | }
79 |
80 | var str string
81 | duration := time.Duration(d)
82 | if h := int(duration.Hours()); h > 0 {
83 | str = fmt.Sprintf("%dh", h)
84 | }
85 | if m := int(duration.Minutes()) % 60; m > 0 {
86 | str = fmt.Sprintf("%s%dm", str, m)
87 | }
88 | if s := int(duration.Seconds()) % 60; s > 0 {
89 | str = fmt.Sprintf("%s%ds", str, s)
90 | }
91 |
92 | return str
93 | }
94 |
--------------------------------------------------------------------------------
/internal/toolset/tool_version.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package toolset
18 |
19 | import (
20 | "fmt"
21 | "path/filepath"
22 | )
23 |
24 | const filename = ".tool-versions"
25 |
26 | type MultiToolVersions []*ToolVersion
27 |
28 | // FilterTools filters tools by the given filter function
29 | // and return the first one you find.
30 | func (m MultiToolVersions) FilterTools(filter func(name, version string) bool) map[string]string {
31 | tools := make(map[string]string)
32 | for _, t := range m {
33 | for name, version := range t.Record {
34 | _, ok := tools[name]
35 | if !ok && filter(name, version) {
36 | tools[name] = version
37 | }
38 | }
39 | }
40 | return tools
41 | }
42 |
43 | func (m MultiToolVersions) Add(name, version string) {
44 | for _, t := range m {
45 | t.Record[name] = version
46 | }
47 | }
48 |
49 | func (m MultiToolVersions) Save() error {
50 | for _, t := range m {
51 | if err := t.Save(); err != nil {
52 | return err
53 | }
54 | }
55 | return nil
56 | }
57 |
58 | // ToolVersion represents a .tool-versions file
59 | type ToolVersion struct {
60 | *FileRecord
61 | }
62 |
63 | func NewToolVersion(dirPath string) (*ToolVersion, error) {
64 | file := filepath.Join(dirPath, filename)
65 | mapFile, err := NewFileRecord(file)
66 | if err != nil {
67 | return nil, fmt.Errorf("failed to read tool versions file %s: %w", file, err)
68 | }
69 | return &ToolVersion{
70 | FileRecord: mapFile,
71 | }, nil
72 | }
73 |
74 | func NewMultiToolVersions(paths []string) (MultiToolVersions, error) {
75 | var tools MultiToolVersions
76 | for _, p := range paths {
77 | tool, err := NewToolVersion(p)
78 | if err != nil {
79 | return nil, err
80 | }
81 | tools = append(tools, tool)
82 | }
83 | return tools, nil
84 | }
85 |
--------------------------------------------------------------------------------
/docs/zh-hans/guides/intro.md:
--------------------------------------------------------------------------------
1 | # 项目简介
2 |
3 | 如果你经常需要在各种开发项目之间切换，而这些项目又各自需要不同的运行环境，尤其是不同的运行时版本或环境库, 或者
4 | 厌倦了各种环境繁琐的配置，那么 `vfox` 就是你的不二选择。
5 |
6 | `vfox` 是一款跨平台、可拓展的通用版本管理器。支持**原生Windows**以及**Unix-like**! 通过它，您可以**快速安装和切换**开发环境。
7 |
8 | 它将所有的工具版本信息保存在一个名为 `.tool-versions` 的文件中，这样您就可以在项目中共享这些信息，确保团队中的每个人都使用相同的工具版本。
9 |
10 | 传统工作方式需要多个命令行版本管理器(如`nvm`、`fvm`、`sdkman`、`asdf-vm`等)，而且每个管理器都有其不同的
11 | API、配置文件和实现方式（比如，`$PATH`
12 | 操作、垫片、环境变量等等）。`vfox` 提供单个交互方式和配置文件来简化开发工作流程，并可通过简单的插件接口扩展到所有工具和运行环境。
13 |
14 | ## 为什么选择 vfox？
15 |
16 |
17 | - 支持**Windows(非WSL)**、Linux、macOS!
18 | - 支持**不同项目不同版本**、**不同Shell不同版本**以及**全局版本**
19 | - 简单的 **插件系统** 来添加对你选择的语言的支持
20 | - 在您切换项目时, 帮您**自动切换**运行时版本
21 | - 支持现有配置文件 `.node-version`、`.nvmrc`、`.sdkmanrc`，以方便迁移
22 | - 支持常用Shell(Powershell、Bash、ZSH),并提供补全功能
23 | - **比 `asdf-vm` 更快**，并提供更简单的命令和真正的跨平台统一。参见 [与asdf-vm对比](../misc/vs-asdf.md)。
24 |
25 | ## 已支持 Shell
26 |
27 | | Shell | Support | Note |
28 | |------------|---------|---------------------------------------------------------------------------------|
29 | | Powershell | ✅ | |
30 | | GitBash | ✅ | [相关问题](./faq.md#why-can-t-i-select-when-use-use-and-search-commands-in-gitbash) |
31 | | Bash | ✅ | |
32 | | ZSH | ✅ | |
33 | | Fish | ✅ | |
34 | | CMD | ✅ | 仅支持`Global`作用域,不推荐使用!!! |
35 | | Clink | ✅ | |
36 | | Cmder | ✅ | |
37 | | Nushell | ✅ | |
38 |
39 |
40 |
41 | ## 贡献者
42 |
43 | > [!TIP]
44 | > 感谢以下贡献者对本项目的贡献。🎉🎉🙏🙏
45 |
46 | #### [核心仓库](https://github.com/version-fox/vfox)
47 |
48 | 
49 |
50 | #### [插件仓库](https://github.com/version-fox/vfox-plugins)
51 |
52 | )
53 |
--------------------------------------------------------------------------------
/internal/config/cache_test.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package config
18 |
19 | import (
20 | "gopkg.in/yaml.v3"
21 | "testing"
22 | "time"
23 | )
24 |
25 | func TestCacheDuration_MarshalYAML(t *testing.T) {
26 | tests := []struct {
27 | name string
28 | cd CacheDuration
29 | want interface{}
30 | wantErr bool
31 | }{
32 | {"Negative", CacheDuration(-1), -1, false},
33 | {"Zero", CacheDuration(0), 0, false},
34 | {"Positive", CacheDuration(time.Hour), "1h", false},
35 | }
36 |
37 | for _, tt := range tests {
38 | t.Run(tt.name, func(t *testing.T) {
39 | got, err := tt.cd.MarshalYAML()
40 | if (err != nil) != tt.wantErr {
41 | t.Errorf("MarshalYAML() error = %v, wantErr %v", err, tt.wantErr)
42 | return
43 | }
44 | if got != tt.want {
45 | t.Errorf("MarshalYAML() got = %v, want %v", got, tt.want)
46 | }
47 | })
48 | }
49 | }
50 |
51 | func TestCacheDuration_UnmarshalYAML(t *testing.T) {
52 | tests := []struct {
53 | name string
54 | node *yaml.Node
55 | want CacheDuration
56 | wantErr bool
57 | }{
58 | {"Negative", &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!int", Value: "-1"}, CacheDuration(-1), false},
59 | {"Zero", &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!int", Value: "0"}, CacheDuration(0), false},
60 | {"Positive", &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: "1h"}, CacheDuration(time.Hour), false},
61 | }
62 |
63 | for _, tt := range tests {
64 | t.Run(tt.name, func(t *testing.T) {
65 | cd := CacheDuration(0)
66 | if err := cd.UnmarshalYAML(tt.node); (err != nil) != tt.wantErr {
67 | t.Errorf("UnmarshalYAML() error = %v, wantErr %v", err, tt.wantErr)
68 | }
69 | if cd != tt.want {
70 | t.Errorf("UnmarshalYAML() got = %v, want %v", cd, tt.want)
71 | }
72 | })
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/internal/env/path.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package env
18 |
19 | import (
20 | "fmt"
21 | "os"
22 | "path/filepath"
23 | "strings"
24 |
25 | "github.com/version-fox/vfox/internal/logger"
26 | "github.com/version-fox/vfox/internal/util"
27 | )
28 |
29 | type PathFrom int
30 |
31 | const (
32 | EmptyPaths PathFrom = iota
33 | OsPaths
34 | )
35 |
36 | // Paths is a slice of PATH.
37 | type Paths struct {
38 | *util.SortedSet[string]
39 | }
40 |
41 | func (p *Paths) Merge(other *Paths) *Paths {
42 | if other == nil {
43 | return p
44 | }
45 | for _, path := range other.Slice() {
46 | p.Add(path)
47 | }
48 | return p
49 | }
50 |
51 | // ToBinPaths returns a BinPaths from Paths which contains only executable files.
52 | func (p *Paths) ToBinPaths() (*Paths, error) {
53 | bins := NewPaths(EmptyPaths)
54 | for _, path := range p.Slice() {
55 | dir, err := os.ReadDir(path)
56 | if err != nil {
57 | logger.Debugf("Failed to read bin paths:%s: %v", path, err)
58 | return nil, fmt.Errorf("failed to read bin paths:%s: %w", path, err)
59 | }
60 | for _, d := range dir {
61 | if d.IsDir() {
62 | continue
63 | }
64 | file := filepath.Join(path, d.Name())
65 | if util.IsExecutable(file) {
66 | bins.Add(file)
67 | }
68 | }
69 | }
70 | return bins, nil
71 | }
72 |
73 | // NewPaths returns a new Paths.
74 | // from is the source of the paths.
75 | // If from is OsPaths, it returns the paths from the environment variable PATH.
76 | func NewPaths(from PathFrom) *Paths {
77 | var paths []string
78 | switch from {
79 | case OsPaths:
80 | paths = strings.Split(os.Getenv("PATH"), string(os.PathListSeparator))
81 | default:
82 |
83 | }
84 | p := &Paths{
85 | util.NewSortedSet[string](),
86 | }
87 | for _, v := range paths {
88 | p.Add(v)
89 | }
90 | return p
91 | }
92 |
--------------------------------------------------------------------------------
/docs/zh-hans/plugins/create/howto_registry.md:
--------------------------------------------------------------------------------
1 | # 如何将插件提交到索引仓库?
2 |
3 | :::tip 提醒
4 | 请注意，这个文档是关于如何将插件提交到[索引仓库](https://github.com/version-fox/vfox-plugins)的。
5 |
6 | 如果你想要了解如何创建一个插件，请查看[这里](./howto.md)。
7 | :::
8 |
9 |
10 | ## 索引仓库(Registry)
11 |
12 | `vfox` 插件索引仓库是一个用于**收集和分发**各种**vfox插件**的仓库。 方便用户通过`vfox add `命令来快速安装对应插件。
13 |
14 | 索引仓库是一个公共仓库, 任何人都可以提交**vfox插件**到这个仓库中。
15 |
16 | 索引仓库主要分为两个部分:
17 | - `plugins`: 用于存放插件的`manifest.json`文件, 以插件短名为文件名。例如`nodejs.json`
18 | - `sources`: 用于存放插件的数据源信息, 以插件短名为文件名。例如`nodejs.json`
19 |
20 | 仓库将会自动定时(间隔一小时)通过`sources`中的信息检索插件的最新版本信息以及校验插件可用性, 并将获取的`manifest`信息存放在`plugins`目录下。
21 |
22 |
23 | ::: tip 仓库地址
24 | `vfox`默认将会从[插件仓库](https://version-fox.github.io/vfox-plugins)检索插件。
25 |
26 | 如果你想使用**自己的索引仓库或第三方镜像仓库**, 请按照[插件注册表地址](../../guides/configuration.md#插件注册表地址)进行配置。
27 | :::
28 |
29 | ## 提交插件
30 |
31 | 1. 首先，你需要按照[插件创建指南](./howto.md)创建一个插件。
32 | 2. 维护一个`manifest.json`文件，用于描述插件最新版本信息。(如果基于[vfox-plugin-template](https://github.com/version-fox/vfox-plugin-template)开发, 在发版时会自动生成)
33 | ```json
34 | {
35 | "downloadUrl": "https://github.com/version-fox/vfox-nodejs/releases/download/v0.0.5/vfox-nodejs_0.0.5.zip",
36 | "notes": [],
37 | "version": "0.0.5",
38 | "homepage": "https://github.com/version-fox/vfox-nodejs",
39 | "minRuntimeVersion": "0.2.6",
40 | "license": "Apache 2.0",
41 | "description": "Node.js runtime environment.",
42 | "name": "nodejs"
43 | }
44 | ```
45 | - `downloadUrl`: 插件的下载地址
46 | - `notes`: 插件的更新日志
47 | - `version`: 插件的版本
48 | - `homepage`: 插件的主页
49 | - `minRuntimeVersion`: 插件所需的最低`vfox`版本
50 | - `license`: 插件的许可证
51 | - `description`: 插件的描述
52 | - `name`: 插件的短名
53 | 3. 在`sources/.json`中创建一个带有您希望`vfox`使用的短名的文件, 例如`sources/nodejs.json`
54 | 4. 在`sources/.json`中添加插件的manifest地址信息，例如:
55 | ```json
56 | {
57 | "name": "nodejs",
58 | "manifestUrl": "https://github.com/version-fox/vfox-nodejs/releases/download/manifest/manifest.json",
59 | "test": {
60 | "version": "21.7.1",
61 | "check": "node -v",
62 | "resultRegx": "v21.7.1"
63 | }
64 | }
65 | ```
66 | - `name`: 插件的短名
67 | - `manifestUrl`: 插件的manifest地址
68 | - `test`: 插件的测试信息
69 | - `version`: 插件的版本
70 | - `check`: 测试命令
71 | - `resultRegx`: 测试结果正则表达式
72 | 5. 最后, 提交一个PR到[索引仓库](https://github.com/version-fox/vfox-plugins/).
73 | 6. PR被合并后，插件将会被自动添加到索引仓库中, 并每隔一小时检查一次插件的更新情况。
74 |
75 |
76 |
77 |
--------------------------------------------------------------------------------
/cmd/commands/list.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package commands
18 |
19 | import (
20 | "context"
21 | "fmt"
22 |
23 | "github.com/pterm/pterm"
24 | "github.com/pterm/pterm/putils"
25 | "github.com/urfave/cli/v3"
26 | "github.com/version-fox/vfox/internal"
27 | )
28 |
29 | var List = &cli.Command{
30 | Name: "list",
31 | Aliases: []string{"ls"},
32 | Usage: "List all versions of the target SDK",
33 | Action: listCmd,
34 | Category: CategorySDK,
35 | }
36 |
37 | func listCmd(ctx context.Context, cmd *cli.Command) error {
38 | manager := internal.NewSdkManager()
39 | defer manager.Close()
40 | sdkName := cmd.Args().First()
41 | if sdkName == "" {
42 | allSdk, err := manager.LoadAllSdk()
43 | if err != nil {
44 | return err
45 | }
46 | if len(allSdk) == 0 {
47 | return fmt.Errorf("you don't have any sdk installed yet")
48 | }
49 | tree := pterm.LeveledList{}
50 |
51 | for _, s := range allSdk {
52 | name := s.Name
53 | tree = append(tree, pterm.LeveledListItem{Level: 0, Text: name})
54 | for _, version := range s.List() {
55 | tree = append(tree, pterm.LeveledListItem{Level: 1, Text: "v" + string(version)})
56 | }
57 | }
58 | // Generate tree from LeveledList.
59 | root := putils.TreeFromLeveledList(tree)
60 | root.Text = "All installed sdk versions"
61 | // Render TreePrinter
62 | _ = pterm.DefaultTree.WithRoot(root).Render()
63 | return nil
64 | }
65 | source, err := manager.LookupSdk(sdkName)
66 | if err != nil {
67 | return fmt.Errorf("%s not supported, error: %w", sdkName, err)
68 | }
69 | curVersion := source.Current()
70 | list := source.List()
71 | if len(list) == 0 {
72 | return fmt.Errorf("no available version")
73 | }
74 | for _, version := range list {
75 | if version == curVersion {
76 | pterm.Println("->", fmt.Sprintf("v%s", version), pterm.LightGreen("<— current"))
77 | } else {
78 | pterm.Println("->", fmt.Sprintf("v%s", version))
79 | }
80 | }
81 | return nil
82 | }
83 |
--------------------------------------------------------------------------------
/internal/env/flag.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package env
18 |
19 | import (
20 | "os"
21 | "strconv"
22 | )
23 |
24 | const (
25 | HomeFromEnv = "VFOX_HOME"
26 | PluginFromEnv = "VFOX_PLUGIN"
27 | CacheFromEnv = "VFOX_CACHE"
28 | TempFromEnv = "VFOX_TEMP"
29 |
30 | HookFlag = "__VFOX_SHELL"
31 | PidFlag = "__VFOX_PID"
32 | )
33 |
34 | func IsHookEnv() bool {
35 | return os.Getenv(HookFlag) != ""
36 | }
37 |
38 | // IsIDEEnvironmentResolution detects if the current shell session was launched by an IDE
39 | // for the purpose of environment variable resolution. This is useful to avoid certain
40 | // shell initialization behaviors that might interfere with IDE environment detection.
41 | //
42 | // Supported IDEs:
43 | // - Visual Studio Code: Detects via VSCODE_RESOLVING_ENVIRONMENT environment variable
44 | // Reference: https://code.visualstudio.com/docs/configure/command-line#_how-do-i-detect-when-a-shell-was-launched-by-vs-code
45 | // - JetBrains IDEs (IntelliJ IDEA, PyCharm, etc.): Detects via INTELLIJ_ENVIRONMENT_READER environment variable
46 | // Reference: https://youtrack.jetbrains.com/articles/SUPPORT-A-1727/Shell-Environment-Loading
47 | //
48 | // Returns true if any of the supported IDE environment resolution indicators are present.
49 | func IsIDEEnvironmentResolution() bool {
50 | return os.Getenv("VSCODE_RESOLVING_ENVIRONMENT") != "" ||
51 | os.Getenv("INTELLIJ_ENVIRONMENT_READER") != ""
52 | }
53 |
54 | func GetPid() int {
55 | if IsHookEnv() {
56 | if pid := os.Getenv(PidFlag); pid != "" {
57 | p, _ := strconv.Atoi(pid) // Convert pid from string to int
58 | return p
59 | }
60 | }
61 |
62 | return os.Getppid()
63 | }
64 |
65 | func GetVfoxHome() string {
66 | return os.Getenv(HomeFromEnv)
67 | }
68 |
69 | func GetVfoxPlugin() string {
70 | return os.Getenv(PluginFromEnv)
71 | }
72 |
73 | func GetVfoxCache() string {
74 | return os.Getenv(CacheFromEnv)
75 | }
76 |
77 | func GetVfoxTemp() string {
78 | return os.Getenv(TempFromEnv)
79 | }
80 |
--------------------------------------------------------------------------------
/internal/manager_test.go:
--------------------------------------------------------------------------------
1 | package internal
2 |
3 | import (
4 | "os"
5 | "path/filepath"
6 | "strconv"
7 | "testing"
8 | "time"
9 |
10 | "github.com/shirou/gopsutil/v4/process"
11 | )
12 |
13 | func detectPidNotExists(t *testing.T, pid int32, num int32) int32 {
14 | if num < 1 {
15 | t.Fatalf("num must be greater than 1")
16 | }
17 |
18 | for i := pid + 1; i < pid+num; i++ {
19 | exists, err := process.PidExists(i)
20 | if err != nil {
21 | t.Fatalf("failed to check pid %d existence: %v", i, err)
22 | }
23 |
24 | if !exists {
25 | return i
26 | }
27 | }
28 |
29 | return pid + num
30 | }
31 |
32 | func TestCleanTmp(t *testing.T) {
33 | tmpRoot := filepath.Join(os.TempDir(), "vfox-cleantmp-test")
34 | _ = os.RemoveAll(tmpRoot)
35 | defer os.RemoveAll(tmpRoot)
36 | now := time.Now()
37 | today := strconv.FormatInt(time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location()).Unix(), 10)
38 | // Create a simulated temporary directory structure
39 | yesterday := strconv.FormatInt(now.Add(-250*time.Hour).Unix(), 10)
40 | pid := os.Getpid()
41 | otherPid := int(detectPidNotExists(t, int32(pid+100), 10000))
42 | dirs := []string{
43 | filepath.Join(tmpRoot, today+"-"+strconv.Itoa(pid)),
44 | // filepath.Join(tmpRoot, yesterday+"-"+strconv.Itoa(pid)),
45 | filepath.Join(tmpRoot, yesterday+"-"+strconv.Itoa(otherPid)),
46 | filepath.Join(tmpRoot, yesterday+"-"+strconv.Itoa(pid)),
47 | }
48 | for _, dir := range dirs {
49 | if err := os.MkdirAll(dir, 0o755); err != nil {
50 | t.Fatalf("failed to create dir: %v", err)
51 | }
52 | }
53 | cleanFlagPath := filepath.Join(tmpRoot, cleanupFlagFilename)
54 | // Write yesterday to cleanFlagPath
55 | if err := os.WriteFile(cleanFlagPath, []byte(yesterday), 0o644); err != nil {
56 | t.Fatalf("failed to write cleanFlagPath: %v", err)
57 | }
58 |
59 | // Construct Manager
60 | m := &Manager{PathMeta: &PathMeta{CurTmpPath: tmpRoot, TempPath: tmpRoot}}
61 |
62 | // Execute cleanup
63 | m.CleanTmp()
64 |
65 | // today-pid should be retained
66 | if _, err := os.Stat(filepath.Join(tmpRoot, today+"-"+strconv.Itoa(pid))); os.IsNotExist(err) {
67 | t.Errorf("today-pid dir should exist, but got removed")
68 | }
69 |
70 | // yesterday-otherPid should be deleted
71 | if _, err := os.Stat(filepath.Join(tmpRoot, yesterday+"-"+strconv.Itoa(otherPid))); err == nil {
72 | t.Errorf("yesterday-otherPid dir should be removed, but still exists")
73 | }
74 |
75 | // yesterday-pid should be retained
76 | if _, err := os.Stat(filepath.Join(tmpRoot, yesterday+"-"+strconv.Itoa(pid))); os.IsNotExist(err) {
77 | t.Errorf("yesterday-pid dir should exist, but got removed")
78 | }
79 | }
80 |
--------------------------------------------------------------------------------
/internal/shell/shell_test.go:
--------------------------------------------------------------------------------
1 | package shell
2 |
3 | import (
4 | "testing"
5 | )
6 |
7 | func TestStripLoginShellDash(t *testing.T) {
8 | tests := []struct {
9 | name string
10 | input string
11 | expected string
12 | }{
13 | {
14 | name: "zsh with dash",
15 | input: "-zsh",
16 | expected: "zsh",
17 | },
18 | {
19 | name: "bash with dash",
20 | input: "-bash",
21 | expected: "bash",
22 | },
23 | {
24 | name: "fish with dash",
25 | input: "-fish",
26 | expected: "fish",
27 | },
28 | {
29 | name: "shell without dash",
30 | input: "zsh",
31 | expected: "zsh",
32 | },
33 | {
34 | name: "shell with path and dash",
35 | input: "-/bin/zsh",
36 | expected: "/bin/zsh",
37 | },
38 | }
39 |
40 | for _, tt := range tests {
41 | t.Run(tt.name, func(t *testing.T) {
42 | shellName := tt.input
43 | if len(shellName) > 0 && shellName[0] == '-' {
44 | shellName = shellName[1:]
45 | }
46 | if shellName != tt.expected {
47 | t.Errorf("stripLoginShellDash() = %v, want %v", shellName, tt.expected)
48 | }
49 | })
50 | }
51 | }
52 |
53 | func TestCommonShellPaths(t *testing.T) {
54 | tests := []struct {
55 | name string
56 | shell string
57 | expected []string
58 | }{
59 | {
60 | name: "zsh paths",
61 | shell: "zsh",
62 | expected: []string{
63 | "/bin/zsh",
64 | "/usr/bin/zsh",
65 | "/usr/local/bin/zsh",
66 | "/opt/homebrew/bin/zsh",
67 | "/usr/local/Cellar/zsh",
68 | },
69 | },
70 | {
71 | name: "bash paths",
72 | shell: "bash",
73 | expected: []string{
74 | "/bin/bash",
75 | "/usr/bin/bash",
76 | "/usr/local/bin/bash",
77 | "/opt/homebrew/bin/bash",
78 | "/usr/local/Cellar/bash",
79 | },
80 | },
81 | }
82 |
83 | for _, tt := range tests {
84 | t.Run(tt.name, func(t *testing.T) {
85 | // This test verifies the expected paths are generated correctly
86 | // Actual file existence may vary on different systems
87 | commonPaths := []string{
88 | "/bin/" + tt.shell,
89 | "/usr/bin/" + tt.shell,
90 | "/usr/local/bin/" + tt.shell,
91 | "/opt/homebrew/bin/" + tt.shell,
92 | "/usr/local/Cellar/" + tt.shell,
93 | }
94 |
95 | if len(commonPaths) != len(tt.expected) {
96 | t.Errorf("Expected %d paths, got %d", len(tt.expected), len(commonPaths))
97 | }
98 |
99 | for i, path := range commonPaths {
100 | if path != tt.expected[i] {
101 | t.Errorf("Expected path %s, got %s", tt.expected[i], path)
102 | }
103 | }
104 | })
105 | }
106 | }
--------------------------------------------------------------------------------
/internal/plugin/luai/vm.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package luai
18 |
19 | import (
20 | _ "embed"
21 | "strings"
22 |
23 | "github.com/version-fox/vfox/internal/plugin/luai/module"
24 | lua "github.com/yuin/gopher-lua"
25 | )
26 |
27 | //go:embed fixtures/preload.lua
28 | var preloadScript string
29 |
30 | type LuaVM struct {
31 | Instance *lua.LState
32 | }
33 |
34 | func NewLuaVM() *LuaVM {
35 | instance := lua.NewState()
36 |
37 | return &LuaVM{
38 | Instance: instance,
39 | }
40 | }
41 |
42 | func (vm *LuaVM) Prepare(options *module.PreloadOptions) error {
43 | if err := vm.Instance.DoString(preloadScript); err != nil {
44 | return err
45 | }
46 |
47 | if options != nil {
48 | module.Preload(vm.Instance, options)
49 | }
50 |
51 | return nil
52 | }
53 |
54 | // LimitPackagePath limits the package path of the Lua VM.
55 | func (vm *LuaVM) LimitPackagePath(packagePaths ...string) {
56 | packageModule := vm.Instance.GetGlobal("package").(*lua.LTable)
57 | packageModule.RawSetString("path", lua.LString(strings.Join(packagePaths, ";")))
58 | }
59 |
60 | func (vm *LuaVM) ReturnedValue() *lua.LTable {
61 | table := vm.Instance.ToTable(-1) // returned value
62 | vm.Instance.Pop(1) // remove received value
63 | return table
64 | }
65 |
66 | func (vm *LuaVM) CallFunction(pluginObj *lua.LTable, funcName string, _args ...lua.LValue) (*lua.LTable, error) {
67 | function := pluginObj.RawGetString(funcName)
68 |
69 | // In Lua, when a function is called with colon syntax (object:method()),
70 | // the object itself is implicitly passed as the first argument.
71 | // Here, pluginObj represents the Lua table instance of the plugin,
72 | // and it's being passed as the first argument to the Lua function to simulate this behavior.
73 | args := append([]lua.LValue{pluginObj}, _args...)
74 |
75 | if err := vm.Instance.CallByParam(lua.P{
76 | Fn: function.(*lua.LFunction),
77 | NRet: 1,
78 | Protect: true,
79 | }, args...); err != nil {
80 | return nil, err
81 | }
82 |
83 | return vm.ReturnedValue(), nil
84 | }
85 |
86 | func (vm *LuaVM) Close() {
87 | vm.Instance.Close()
88 | }
89 |
--------------------------------------------------------------------------------
/internal/config/config.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package config
18 |
19 | import (
20 | "github.com/version-fox/vfox/internal/util"
21 | "gopkg.in/yaml.v3"
22 | "os"
23 | "path/filepath"
24 | )
25 |
26 | type Config struct {
27 | Proxy *Proxy `yaml:"proxy"`
28 | Storage *Storage `yaml:"storage"`
29 | Registry *Registry `yaml:"registry"`
30 | LegacyVersionFile *LegacyVersionFile `yaml:"legacyVersionFile"`
31 | Cache *Cache `yaml:"cache"`
32 | }
33 |
34 | const filename = "config.yaml"
35 |
36 | var (
37 | DefaultConfig = &Config{
38 | Proxy: EmptyProxy,
39 | Storage: EmptyStorage,
40 | Registry: EmptyRegistry,
41 | LegacyVersionFile: EmptyLegacyVersionFile,
42 | Cache: EmptyCache,
43 | }
44 | )
45 |
46 | func NewConfigWithPath(p string) (*Config, error) {
47 | if !util.FileExists(p) {
48 | content, err := yaml.Marshal(DefaultConfig)
49 | if err == nil {
50 | _ = os.WriteFile(p, content, 0666)
51 | return DefaultConfig, nil
52 | }
53 | }
54 | _ = util.ChangeModeIfNot(p, 0666)
55 | content, err := os.ReadFile(p)
56 | if err != nil {
57 | return nil, err
58 | }
59 | config := &Config{}
60 | err = yaml.Unmarshal(content, config)
61 | if err != nil {
62 | return nil, err
63 | }
64 | if config.Proxy == nil {
65 | config.Proxy = EmptyProxy
66 | }
67 | if config.Storage == nil {
68 | config.Storage = EmptyStorage
69 | }
70 | if config.Registry == nil {
71 | config.Registry = EmptyRegistry
72 | }
73 | if config.LegacyVersionFile == nil {
74 | config.LegacyVersionFile = EmptyLegacyVersionFile
75 | }
76 | if config.Cache == nil {
77 | config.Cache = EmptyCache
78 | }
79 | return config, nil
80 |
81 | }
82 |
83 | func NewConfig(path string) (*Config, error) {
84 | p := filepath.Join(path, filename)
85 | return NewConfigWithPath(p)
86 | }
87 |
88 | func (c *Config) SaveConfig(path string) error {
89 | p := filepath.Join(path, filename)
90 | content, err := yaml.Marshal(c)
91 | if err != nil {
92 | return err
93 | }
94 | return os.WriteFile(p, content, os.ModePerm)
95 | }
96 |
--------------------------------------------------------------------------------
/docs/zh-hans/guides/configuration.md:
--------------------------------------------------------------------------------
1 | # 配置
2 |
3 | `vfox` 允许你修改一些配置, 所有配置信息都存放在`$HOME/.version-fox/config.yaml`文件中。
4 |
5 | ::: tip 注意
6 | 如果你是首次运行`vfox`, 则会自动创建一个空的 config.yaml 文件。
7 | :::
8 |
9 | ## 兼容版本文件
10 |
11 | 插件 **支持** 读取其他版本管理器的配置文件, 例如: Nodejs 的`nvm`的`.nvmrc`文件, Java 的`SDKMAN`的`.sdkmanrc`文件等。
12 |
13 | 此能力**默认是开启的**。相关配置选项如下:
14 |
15 | ```yaml
16 | legacyVersionFile:
17 | enable: true
18 | strategy: "specified" # 解析策略
19 | ```
20 |
21 | - `enable`: 是否启用 legacy version file 解析功能
22 | - `strategy`: 解析策略，详见下方策略选项说明
23 |
24 | ### 策略选项
25 |
26 | `vfox` 支持以下三种解析策略：
27 |
28 | - `latest_installed`: 使用最新安装的版本
29 | - `latest_available`: 使用最新可用的版本
30 | - `specified`: 使用 legacy file 中指定的版本（默认）
31 |
32 | ::: warning
33 |
34 | 1. 如果目录里同时存在`.tool-versions`和其他版本管理器的配置文件(`.nvmrc`, `.sdkmanrc`等),
35 | `vfox` **优先加载**`.tool-versions`文件.
36 | 2. 开启此功能可能会导致`vfox`刷新环境变量时略微变慢, **请根据自己的需求开启**。
37 |
38 | :::
39 |
40 | 如果你想禁用此功能，可以使用命令：`vfox config legacyVersionFile.enable false`
41 |
42 | ## 代理设置
43 |
44 | ::: tip 注意
45 | 当前仅支持 http(s)代理协议
46 | :::
47 |
48 | **格式**: `http[s]://[username:password@]host:port`
49 |
50 | ```yaml
51 | proxy:
52 | enable: false
53 | url: http://localhost:7890
54 | ```
55 |
56 | ## 存储路径
57 |
58 | `vfox`默认将 SDK 缓存文件存储在`$HOME/.version-fox/cache`目录下。
59 |
60 | ::: danger !!!
61 | 在配置之前， 请确保`vfox`有文件夹的写权限。⚠⚠⚠
62 | :::
63 |
64 | ```yaml
65 | storage:
66 | sdkPath: /tmp
67 | ```
68 |
69 | ## 插件注册表地址
70 |
71 | `vfox`默认从[插件仓库](https://version-fox.github.io/vfox-plugins)检索插件。
72 |
73 | 如果你想要使用自己的索引仓库或第三方镜像仓库,可以按照以下方式配置:
74 |
75 | ```yaml
76 | registry:
77 | address: "https://version-fox.github.io/vfox-plugins"
78 | ```
79 |
80 | ::: tip 可用镜像
81 |
82 | - https://gitee.com/version-fox/vfox-plugins/raw/main/plugins
83 | - https://cdn.jsdelivr.net/gh/version-fox/vfox-plugins/plugins
84 | - https://rawcdn.githack.com/version-fox/vfox-plugins/plugins
85 | :::
86 |
87 | ## 缓存
88 |
89 | `vfox` 默认会缓存`search`命令的结果, 以减少网络请求次数。默认缓存时间为`12h`。
90 |
91 | ::: warning 特殊值
92 |
93 | - `-1`: 永不过期
94 | - `0`: 不进行缓存
95 | :::
96 |
97 | ```yaml
98 | cache:
99 | availableHookDuration: 12h # s 秒, m 分钟, h 小时
100 | ```
101 |
102 | ::: tip 缓存文件路径
103 | `$HOME/.version-fox/plugins//available.cache`
104 | :::
105 |
106 | ## Config 命令
107 |
108 | 设置，查看配置
109 |
110 | **用法**
111 |
112 | ```shell
113 | vfox config [] []
114 |
115 | vfox config proxy.enable true
116 | vfox config proxy.url http://localhost:7890
117 | vfox config storage.sdkPath /tmp
118 | ```
119 |
120 | `key`：配置项，以`.`分割。
121 | `value`：不传为查看配置项的值。
122 |
123 | **选项**
124 |
125 | - `-l, --list`：列出所有配置。
126 | - `-un, --unset`：删除一个配置。
127 |
--------------------------------------------------------------------------------
/docs/usage/plugins-commands.md:
--------------------------------------------------------------------------------
1 | # Plugins
2 |
3 | Plugins are how `vfox` knows to handle different tools like `Node.js`, `Java`, `Elixir` etc.
4 |
5 | See [Creating Plugins](../plugins/create/howto.md) for the plugin API used to support more tools.
6 |
7 | ## Available
8 |
9 | View all available plugins.
10 |
11 | **Usage**
12 |
13 | ```shell
14 | vfox available
15 | ```
16 |
17 | ## Add
18 | Add a plugin from the official repository or a custom source.
19 |
20 | **Usage**
21 |
22 | ```shell
23 | vfox add [options] [...]
24 | ```
25 |
26 | `plugin-name`: Plugin name, such as `nodejs`. You can install multiple plugins at once, separated by spaces.
27 |
28 | **Options**
29 |
30 | - `-a, --alias`: Set the plugin alias.
31 | - `-s, --source`: Install the plugin from the specified path (can be a remote file or a local file).
32 |
33 |
34 | ::: warning
35 | `--alias` and `--source` are not supported when adding multiple plugins.
36 | :::
37 |
38 | **Examples**
39 |
40 | **Install plugin from the official repository**
41 |
42 | ```shell
43 | $ vfox add --alias node nodejs
44 |
45 | $ vfox add golang java nodejs
46 | ```
47 |
48 | **Install custom plugin**
49 |
50 | ```shell
51 | $ vfox add --source https://github.com/version-fox/vfox-nodejs/releases/download/v0.0.5/vfox-nodejs_0.0.5.zip custom-node
52 | ```
53 |
54 | ## Info
55 |
56 | View the SDK information installed locally.
57 |
58 | **Usage**
59 |
60 | ```shell
61 | vfox info
62 | vfox info @
63 | vfox info [options]
64 | ```
65 |
66 | `plugin-name`: Plugin name, such as `nodejs`.
67 | `version`: Specific version of the plugin.
68 |
69 | **Options**
70 |
71 | - `-f, --format`: Format the output using the given Go template. Available fields:
72 | - For plugin info: `Name`, `Version`, `Homepage`, `InstallPath`, `Description`
73 | - For version info: `Name`, `Version`, `Path`
74 |
75 | **Examples**
76 |
77 | **View plugin information**
78 | ```shell
79 | vfox info nodejs
80 | ```
81 |
82 | **View specific version path**
83 | ```shell
84 | vfox info nodejs@20.0.0
85 | ```
86 |
87 | **Format output with template**
88 | ```shell
89 | vfox info --format "{{.Homepage}}" nodejs
90 | vfox info --format "{{.InstallPath}}" nodejs
91 | vfox info --format "{{.Path}}" nodejs@20.0.0
92 | ```
93 |
94 | ## Remove
95 |
96 | Remove the installed plugin.
97 |
98 | **Usage**
99 |
100 | ```shell
101 | vfox remove
102 | ```
103 |
104 | ::: danger
105 | `vfox` will remove all versions of the runtime installed by the current plugin.
106 | :::
107 |
108 |
109 |
110 | ## Update
111 |
112 | Update a specified or all plugin(s)
113 |
114 | **Usage**
115 |
116 | ```shell
117 | vfox update
118 | vfox update --all # update all installed plugins
119 | ```
120 |
121 |
--------------------------------------------------------------------------------
/internal/util/set_test.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package util
18 |
19 | import (
20 | "reflect"
21 | "testing"
22 | )
23 |
24 | func TestMapSet(t *testing.T) {
25 | s := NewSet[int]()
26 |
27 | s.Add(1)
28 | if !s.Contains(1) {
29 | t.Errorf("Expected set to contain 1")
30 | }
31 |
32 | s.Remove(1)
33 | if s.Contains(1) {
34 | t.Errorf("Expected set to not contain 1")
35 | }
36 |
37 | if s.Len() != 0 {
38 | t.Errorf("Expected set length to be 0, got %d", s.Len())
39 | }
40 | }
41 |
42 | func TestOrderedSet(t *testing.T) {
43 | s := NewSortedSet[int]()
44 |
45 | s.Add(1)
46 | if !s.Contains(1) {
47 | t.Errorf("Expected set to contain 1")
48 | }
49 |
50 | s.Remove(1)
51 | if s.Contains(1) {
52 | t.Errorf("Expected set to not contain 1")
53 | }
54 |
55 | if s.Len() != 0 {
56 | t.Errorf("Expected set length to be 0, got %d", s.Len())
57 | }
58 |
59 | for v := range s.Slice() {
60 | t.Errorf("Expected no iteration over set, but got %v", v)
61 | }
62 | }
63 |
64 | func TestSortedSetSort(t *testing.T) {
65 | s := NewSortedSet[string]()
66 |
67 | elements := []string{"ss23434444444jl2342342424s", "89999809898998bbb", "99234234234234aaa", "1232ssssssssssssssss414141fff"}
68 |
69 | for _, r := range elements {
70 | s.Add(r)
71 | }
72 |
73 | if !reflect.DeepEqual(s.Slice(), elements) {
74 | t.Errorf("Expected set to contain %v, got %v", elements, s.Slice())
75 | }
76 |
77 | e := elements[0]
78 | elements = elements[1:]
79 | s.Remove(e)
80 | if !reflect.DeepEqual(s.Slice(), elements) {
81 | t.Errorf("Expected set to contain %v, got %v", elements, s.Slice())
82 | }
83 | }
84 |
85 | func TestLoopRemoveSortedSet(t *testing.T) {
86 | s1 := NewSortedSet[int]()
87 | s2 := NewSortedSet[int]()
88 | s3 := NewSortedSet[int]()
89 | for i := 0; i < 10; i++ {
90 | s1.Add(i)
91 | if i < 5 {
92 | s2.Add(i)
93 | } else {
94 | s3.Add(i)
95 | }
96 | }
97 | for _, s := range s1.Slice() {
98 | if s2.Contains(s) {
99 | s1.Remove(s)
100 | }
101 | }
102 | for _, s := range s1.Slice() {
103 | if !s3.Contains(s) {
104 | t.Errorf("Expected set to equal %v, got %v", s3.Slice(), s1.Slice())
105 | break
106 | }
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/cmd/commands/activate.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package commands
18 |
19 | import (
20 | "context"
21 | "fmt"
22 | "os"
23 | "strings"
24 | "text/template"
25 |
26 | "github.com/version-fox/vfox/internal"
27 |
28 | "github.com/urfave/cli/v3"
29 | "github.com/version-fox/vfox/internal/env"
30 | "github.com/version-fox/vfox/internal/logger"
31 | "github.com/version-fox/vfox/internal/shell"
32 | )
33 |
34 | var Activate = &cli.Command{
35 | Name: "activate",
36 | Hidden: true,
37 | Action: activateCmd,
38 | Category: CategorySDK,
39 | }
40 |
41 | func activateCmd(ctx context.Context, cmd *cli.Command) error {
42 | name := cmd.Args().First()
43 | if name == "" {
44 | return cli.Exit("shell name is required", 1)
45 | }
46 | manager := internal.NewSdkManager()
47 | defer manager.Close()
48 |
49 | sdkEnvs, err := manager.GlobalEnvKeys()
50 | if err != nil {
51 | return err
52 | }
53 |
54 | // Note: This step must be the first.
55 | // the Paths will handle the path format of GitBash which is different from other shells.
56 | // So we need to set the env.HookFlag first to let the Paths know
57 | // which shell we are using.
58 | _ = os.Setenv(env.HookFlag, name)
59 |
60 | exportEnvs := sdkEnvs.ToExportEnvs()
61 |
62 | // Current shell is not for user use, it will be killed after the activation.
63 | // If we setup hook in this shell, it will cause all terminal launched by IDE could not be hooked properly.
64 | if !env.IsIDEEnvironmentResolution() {
65 | exportEnvs[env.HookFlag] = &name
66 | exportEnvs[internal.HookCurTmpPath] = &manager.PathMeta.CurTmpPath
67 | }
68 |
69 | logger.Debugf("export envs: %+v", exportEnvs)
70 |
71 | path := manager.PathMeta.ExecutablePath
72 | path = strings.Replace(path, "\\", "/", -1)
73 | s := shell.NewShell(name)
74 | if s == nil {
75 | return fmt.Errorf("unknown target shell %s", name)
76 | }
77 |
78 | exportStr := s.Export(exportEnvs)
79 | str, err := s.Activate(
80 | shell.ActivateConfig{
81 | SelfPath: path,
82 | Args: cmd.Args().Tail(),
83 | },
84 | )
85 | if err != nil {
86 | return err
87 | }
88 | hookTemplate, err := template.New("hook").Parse(str)
89 | if err != nil {
90 | return nil
91 | }
92 | tmpCtx := struct {
93 | SelfPath string
94 | EnvContent string
95 | }{
96 | SelfPath: path,
97 | EnvContent: exportStr,
98 | }
99 | return hookTemplate.Execute(cmd.Writer, tmpCtx)
100 | }
101 |
--------------------------------------------------------------------------------
/cmd/cmd.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Han Li and contributors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package cmd
18 |
19 | import (
20 | "context"
21 | "fmt"
22 | "os"
23 |
24 | "github.com/urfave/cli/v3"
25 | "github.com/version-fox/vfox/cmd/commands"
26 | "github.com/version-fox/vfox/internal"
27 | "github.com/version-fox/vfox/internal/logger"
28 | )
29 |
30 | func Execute(args []string) {
31 | newCmd().Execute(args)
32 | }
33 |
34 | type cmd struct {
35 | app *cli.Command
36 | version string
37 | }
38 |
39 | func (c *cmd) Execute(args []string) {
40 | if err := c.app.Run(context.Background(), args); err != nil {
41 | fmt.Println(err)
42 | os.Exit(1)
43 | }
44 | }
45 |
46 | func newCmd() *cmd {
47 | version := internal.RuntimeVersion
48 | cli.VersionFlag = &cli.BoolFlag{
49 | Name: "version",
50 | Aliases: []string{"v", "V"},
51 | Usage: "print version",
52 | Action: func(ctx context.Context, cmd *cli.Command, b bool) error {
53 | println(version)
54 | return nil
55 | },
56 | }
57 |
58 | app := &cli.Command{}
59 | app.EnableShellCompletion = true
60 | app.Name = "vfox"
61 | app.Usage = "vfox is a tool for runtime version management."
62 | app.UsageText = "vfox [command] [command options]"
63 | app.Copyright = "Copyright 2025 Han Li. All rights reserved."
64 | app.Version = version
65 | app.Description = "vfox is a cross-platform version manager, extendable via plugins. It allows you to quickly install and switch between different environment you need via the command line."
66 | app.Suggest = true
67 | app.ShellComplete = func(ctx context.Context, cmd *cli.Command) {
68 | for _, command := range cmd.Commands {
69 | _, _ = fmt.Fprintln(cmd.Writer, command.Name)
70 | }
71 | }
72 |
73 | debugFlags := &cli.BoolFlag{
74 | Name: "debug",
75 | Usage: "show debug information",
76 | Action: func(ctx context.Context, cmd *cli.Command, b bool) error {
77 | logger.SetLevel(logger.DebugLevel)
78 | return nil
79 | },
80 | }
81 |
82 | app.Flags = []cli.Flag{
83 | debugFlags,
84 | }
85 | app.Commands = []*cli.Command{
86 | commands.Info,
87 | commands.Install,
88 | commands.Current,
89 | commands.Use,
90 | commands.Unuse,
91 | commands.List,
92 | commands.Uninstall,
93 | commands.Available,
94 | commands.Search,
95 | commands.Update,
96 | commands.Upgrade,
97 | commands.Remove,
98 | commands.Add,
99 | commands.Activate,
100 | commands.Env,
101 | commands.Config,
102 | commands.Cd,
103 | }
104 |
105 | return &cmd{app: app, version: version}
106 | }
107 |
--------------------------------------------------------------------------------
/internal/shell/nushell_test.go:
--------------------------------------------------------------------------------
1 | package shell
2 |
3 | import (
4 | "encoding/json"
5 | "os"
6 | "reflect"
7 | "runtime"
8 | "slices"
9 | "testing"
10 |
11 | "github.com/version-fox/vfox/internal/env"
12 | )
13 |
14 | func TestExport(t *testing.T) {
15 | sep := string(os.PathListSeparator)
16 |
17 | var pathVarName string
18 | if runtime.GOOS == "windows" {
19 | pathVarName = "Path"
20 | } else {
21 | pathVarName = "PATH"
22 | }
23 |
24 | tests := []struct {
25 | name string
26 | envs env.Vars
27 | want nushellExportData
28 | }{
29 | {
30 | "Empty",
31 | env.Vars{},
32 | nushellExportData{
33 | EnvsToSet: make(map[string]any),
34 | EnvsToUnset: make([]string, 0)},
35 | },
36 | {
37 | "SingleEnv",
38 | env.Vars{"FOO": newString("bar")},
39 | nushellExportData{
40 | EnvsToSet: map[string]any{"FOO": "bar"},
41 | EnvsToUnset: make([]string, 0),
42 | },
43 | },
44 | {
45 | "MultipleEnvs",
46 | env.Vars{"FOO": newString("bar"), "BAZ": newString("qux")},
47 | nushellExportData{
48 | EnvsToSet: map[string]any{"FOO": "bar", "BAZ": "qux"},
49 | EnvsToUnset: make([]string, 0),
50 | },
51 | },
52 | {
53 | "UnsetEnv",
54 | env.Vars{"FOO": nil},
55 | nushellExportData{
56 | EnvsToSet: make(map[string]any),
57 | EnvsToUnset: []string{"FOO"},
58 | },
59 | },
60 | {
61 | "MixedEnvs",
62 | env.Vars{"FOO": newString("bar"), "BAZ": nil},
63 | nushellExportData{
64 | EnvsToSet: map[string]any{"FOO": "bar"},
65 | EnvsToUnset: []string{"BAZ"},
66 | },
67 | },
68 | {
69 | "MultipleUnsetEnvs",
70 | env.Vars{"FOO": nil, "BAZ": nil},
71 | nushellExportData{
72 | EnvsToSet: make(map[string]any),
73 | EnvsToUnset: []string{"FOO", "BAZ"},
74 | },
75 | },
76 | {
77 | "PathEnv",
78 | env.Vars{"PATH": newString("/path1" + sep + "/path2")},
79 | nushellExportData{
80 | EnvsToSet: map[string]any{pathVarName: []any{"/path1", "/path2"}},
81 | EnvsToUnset: make([]string, 0),
82 | },
83 | },
84 | {
85 | "PathAndOtherEnv",
86 | env.Vars{
87 | "PATH": newString("/path1" + sep + "/path2" + sep + "/path3"),
88 | "FOO": newString("bar"),
89 | "BAZ": nil,
90 | },
91 | nushellExportData{
92 | EnvsToSet: map[string]any{pathVarName: []any{"/path1", "/path2", "/path3"}, "FOO": "bar"},
93 | EnvsToUnset: []string{"BAZ"},
94 | },
95 | },
96 | }
97 |
98 | for _, test := range tests {
99 | t.Run(test.name, func(t *testing.T) {
100 | runExportTest(t, test.envs, test.want)
101 | })
102 | }
103 | }
104 |
105 | func runExportTest(t *testing.T, envs env.Vars, want nushellExportData) {
106 | n := nushell{}
107 | got := n.Export(envs)
108 | var gotData nushellExportData
109 | err := json.Unmarshal([]byte(got), &gotData)
110 | if err != nil {
111 | t.Errorf("%s: error unmarshaling export data - %v", t.Name(), err)
112 | return
113 | }
114 |
115 | slices.Sort(want.EnvsToUnset)
116 | slices.Sort(gotData.EnvsToUnset)
117 | if !reflect.DeepEqual(gotData, want) {
118 | t.Errorf("%s: export data mismatch - want %v, got %v", t.Name(), want, gotData)
119 | }
120 | }
121 |
122 | func newString(s string) *string {
123 | return &s
124 | }
125 |
--------------------------------------------------------------------------------
/internal/plugin/luai/module/string/string_test.go:
--------------------------------------------------------------------------------
1 | package string
2 |
3 | import (
4 | lua "github.com/yuin/gopher-lua"
5 | "testing"
6 | )
7 |
8 | func TestSplit(t *testing.T) {
9 | const str = `
10 | local strings = require("vfox.strings")
11 | local str_parts = strings.split("hello world", " ")
12 | assert(type(str_parts) == 'table')
13 | assert(#str_parts == 2, string.format("%d ~= 2", #str_parts))
14 | assert(str_parts[1] == "hello", string.format("%s ~= hello", str_parts[1]))
15 | assert(str_parts[2] == "world", string.format("%s ~= world", str_parts[2]))
16 | `
17 | eval(str, t)
18 | }
19 | func TestHasPrefix(t *testing.T) {
20 | const str = `
21 | local strings = require("vfox.strings")
22 | assert(strings.has_prefix("hello world", "hello"), [[not strings.has_prefix("hello")]])
23 | `
24 | eval(str, t)
25 | }
26 | func TestHasSuffix(t *testing.T) {
27 | const str = `
28 | local strings = require("vfox.strings")
29 | assert(strings.has_suffix("hello world", "world"), [[not strings.has_suffix("world")]])
30 | `
31 | eval(str, t)
32 | }
33 |
34 | func TestTrim(t *testing.T) {
35 | const str = `
36 | local strings = require("vfox.strings")
37 | assert(strings.trim("hello world", "world") == "hello ", "strings.trim()")
38 | assert(strings.trim("hello world", "hello ") == "world", "strings.trim()")
39 | assert(strings.trim_prefix("hello world", "hello ") == "world", "strings.trim()")
40 | assert(strings.trim_suffix("hello world", "hello ") == "hello world", "strings.trim()")
41 | `
42 | eval(str, t)
43 | }
44 |
45 | func TestContains(t *testing.T) {
46 | const str = `
47 | local strings = require("vfox.strings")
48 | assert(strings.contains("hello world", "hello ") == true, "strings.contains()")
49 | `
50 | eval(str, t)
51 | }
52 |
53 | func TestJoin(t *testing.T) {
54 | const str = `
55 | local strings = require("vfox.strings")
56 | local str = strings.join({"1",3,"4"},";")
57 | assert(str == "1;3;4", "strings.join()")
58 | `
59 | eval(str, t)
60 | }
61 |
62 | func TestTrimSpace(t *testing.T) {
63 | const str = `
64 | local strings = require("vfox.strings")
65 | tests = {
66 | {
67 | name = "string with trailing whitespace",
68 | input = "foo bar ",
69 | expected = "foo bar",
70 | },
71 | {
72 | name = "string with leading whitespace",
73 | input = " foo bar",
74 | expected = "foo bar",
75 | },
76 | {
77 | name = "string with leading and trailing whitespace",
78 | input = " foo bar ",
79 | expected = "foo bar",
80 | },
81 | {
82 | name = "string with no leading or trailing whitespace",
83 | input = "foo bar",
84 | expected = "foo bar",
85 | },
86 | }
87 |
88 | for _, tt in ipairs(tests) do
89 | got = strings.trim_space(tt.input)
90 | assert(got == tt.expected, string.format([[expected "%s"; got "%s"]], expected, got))
91 | end
92 | `
93 | eval(str, t)
94 | }
95 |
96 | func eval(str string, t *testing.T) {
97 | s := lua.NewState()
98 | defer s.Close()
99 |
100 | Preload(s)
101 | if err := s.DoString(str); err != nil {
102 | t.Error(err)
103 | }
104 | }
105 |
--------------------------------------------------------------------------------
/internal/shim/shim_windows.go:
--------------------------------------------------------------------------------
1 | //go:build windows
2 |
3 | /*
4 | * Copyright 2025 Han Li and contributors
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | package shim
20 |
21 | import (
22 | _ "embed"
23 | "fmt"
24 | "os"
25 | "path/filepath"
26 |
27 | "github.com/version-fox/vfox/internal/logger"
28 | "github.com/version-fox/vfox/internal/util"
29 | )
30 |
31 | const shimFileContent = `
32 | path = "%s"
33 | `
34 |
35 | const cmdShimContent = `
36 | @echo off
37 | call "%s" %%*
38 | `
39 | const ps1ShimContent = `
40 | param (
41 | [Parameter(Position=0, ValueFromRemainingArguments=$true)]
42 | $params
43 | )
44 |
45 | & '%s' @params
46 | `
47 |
48 | //go:embed binary/shim.exe
49 | var shim []byte
50 |
51 | // Clear removes the generated shim.
52 | func (s *Shim) Clear() (err error) {
53 | filename := filepath.Base(s.BinaryPath)
54 | ext := filepath.Ext(filename)
55 | shimName := filename[:len(filename)-len(ext)] + ".shim"
56 | shimBinary := filepath.Join(s.OutputPath, filename)
57 |
58 | if util.FileExists(shimBinary) {
59 | if err = os.Remove(shimBinary); err != nil {
60 | return
61 | }
62 | }
63 | shimFile := filepath.Join(s.OutputPath, shimName)
64 | if util.FileExists(shimFile) {
65 | if err = os.Remove(shimFile); err != nil {
66 | return
67 | }
68 | }
69 | return nil
70 | }
71 |
72 | // Generate generates the shim.
73 | func (s *Shim) Generate() error {
74 | if err := s.Clear(); err != nil {
75 | logger.Debugf("Clear shim failed: %s", err)
76 | return err
77 | }
78 | filename := filepath.Base(s.BinaryPath)
79 | stat, err := os.Stat(s.BinaryPath)
80 | if err != nil {
81 | return err
82 | }
83 | targetPath := filepath.Join(s.OutputPath, filename)
84 | ext := filepath.Ext(filename)
85 | if ext == ".cmd" {
86 | if err = os.WriteFile(targetPath, []byte(fmt.Sprintf(cmdShimContent, s.BinaryPath)), stat.Mode()); err != nil {
87 | return fmt.Errorf("failed to generate shim: %w", err)
88 | }
89 | return nil
90 | } else if ext == ".ps1" {
91 | if err = os.WriteFile(targetPath, []byte(fmt.Sprintf(ps1ShimContent, s.BinaryPath)), stat.Mode()); err != nil {
92 | return fmt.Errorf("failed to generate shim: %w", err)
93 | }
94 | return nil
95 | }
96 | logger.Debugf("Write shim binary to %s", targetPath)
97 | if err = os.WriteFile(targetPath, shim, stat.Mode()); err != nil {
98 | return fmt.Errorf("failed to generate shim: %w", err)
99 | }
100 | shimName := filename[:len(filename)-len(ext)] + ".shim"
101 | shimFile := filepath.Join(s.OutputPath, shimName)
102 | logger.Debugf("Write shim file to %s", shimFile)
103 | if err = os.WriteFile(shimFile, []byte(fmt.Sprintf(shimFileContent, s.BinaryPath)), stat.Mode()); err != nil {
104 | return fmt.Errorf("failed to generate shim: %w", err)
105 | }
106 | return nil
107 | }
108 |
--------------------------------------------------------------------------------
/docs/guides/intro.md:
--------------------------------------------------------------------------------
1 | # Introduction
2 |
3 | If you switch between development projects which expect different environments, specifically different runtime versions or ambient libraries,
4 | or you are tired of all kinds of cumbersome environment configurations, `vfox` is the ideal choice for you.
5 |
6 | `vfox` is a cross-platform, extensible version manager. It supports **native Windows**, and of course **Unix-like**!
7 | With it, you can **quickly install and switch** different environment.
8 |
9 | It saves all tool version information in a file named `.tool-versions`, so you can share this information in your
10 | project to ensure that everyone on your team is using the same tool versions.
11 |
12 | Traditional work requires multiple cli version managers, each with its own API, configuration files, and
13 | implementation (e.g., `$PATH` operations, shims, environment variables, etc.). `vfox` provides a single interactive way
14 | and configuration file to simplify the development workflow and can be extended to all tools and runtime environments
15 | through a simple plugin interface.
16 |
17 | ## Why use vfox?
18 |
19 | - **cross-platform support** (**Windows**, Linux, macOS)
20 | - **consistent commands** to manage all your languages
21 | - supports **different versions for different projects, different shells, and globally**.
22 | - simple **plugin system** to add support for your runtime of choice
23 | - **automatically switches** runtime versions as you traverse your project
24 | - support for existing config files `.node-version`, `.nvmrc`, `.sdkmanrc` for easy migration
25 | - shell completion available for common shells (Bash, ZSH, Powershell, Clink)
26 | - **Faster than `asdf-vm`**, and provides simpler commands and true cross-platform unification.
27 | See [Comparison to asdf](../misc/vs-asdf.md)。
28 |
29 | ## Supported Shell
30 |
31 | | Shell | Support | Note |
32 | |------------|---------|----------------------------------------------------------------------------------|
33 | | Powershell | ✅ | |
34 | | GitBash | ✅ | [Issue](./faq.md#why-can-t-i-select-when-use-use-and-search-commands-in-gitbash) |
35 | | Bash | ✅ | |
36 | | ZSH | ✅ | |
37 | | Fish | ✅ | |
38 | | CMD | ✅ | Only Support `Global` Scope. Not Recommend!!! |
39 | | Clink | ✅ | |
40 | | Cmder | ✅ | |
41 | | Nushell | ✅ | |
42 |
43 |
44 |
45 | ## Contributors
46 |
47 |
48 | > [!TIP]
49 | > Thanks to the following contributors for their contributions.🎉🎉🙏🙏
50 |
51 | #### [vfox](https://github.com/version-fox/vfox)
52 |
53 | 
54 |
55 | #### [Public Registry](https://github.com/version-fox/vfox-plugins)
56 |
57 | )
58 |
--------------------------------------------------------------------------------
/install.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | main() {
4 | # Detect if running in Termux
5 | IS_TERMUX=false
6 | case "${HOME:-}" in
7 | *com.termux*)
8 | IS_TERMUX=true
9 | echo "Detected Termux environment"
10 | ;;
11 | esac
12 |
13 | # Set installation directory and sudo command based on environment
14 | if [ "$IS_TERMUX" = true ]; then
15 | INSTALL_DIR="${PREFIX}/bin"
16 | SUDO_CMD=""
17 | else
18 | INSTALL_DIR="/usr/local/bin"
19 | # Check if sudo is available
20 | if command -v sudo &> /dev/null; then
21 | SUDO_CMD="sudo"
22 | else
23 | SUDO_CMD=""
24 | fi
25 | fi
26 |
27 | # Check if curl or wget is installed
28 | if command -v curl &> /dev/null
29 | then
30 | DOWNLOAD_CMD="curl -LO"
31 | elif command -v wget &> /dev/null
32 | then
33 | DOWNLOAD_CMD="wget"
34 | else
35 | echo "Neither curl nor wget was found. Please install one of them and try again."
36 | exit 1
37 | fi
38 |
39 | # Get the latest version
40 | if [ -n "${GITHUB_TOKEN}" ]; then
41 | API_RESPONSE=$(curl --silent --header "Authorization: Bearer ${GITHUB_TOKEN}" "https://api.github.com/repos/version-fox/vfox/releases/latest")
42 | else
43 | API_RESPONSE=$(curl --silent "https://api.github.com/repos/version-fox/vfox/releases/latest")
44 | fi
45 |
46 | # Check if the response contains an error message
47 | if echo "$API_RESPONSE" | grep -q '"message":'; then
48 | echo "GitHub API Error:"
49 | echo "$API_RESPONSE"
50 | exit 1
51 | fi
52 |
53 | VERSION=$(echo "$API_RESPONSE" | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/' | cut -c 2-)
54 | if [ -z "$VERSION" ]; then
55 | echo "Failed to get the latest version. Please check your network connection and try again."
56 | exit 1
57 | fi
58 | echo "Installing vfox v$VERSION ..."
59 |
60 | # Check if the OS is supported
61 | OS_TYPE=$(uname -s | tr '[:upper:]' '[:lower:]')
62 | if [ "$OS_TYPE" = "darwin" ]; then
63 | OS_TYPE="macos"
64 | fi
65 |
66 | ARCH_TYPE=$(uname -m)
67 |
68 | if [ "$ARCH_TYPE" = "arm64" ]; then
69 | ARCH_TYPE="aarch64"
70 | elif [ "$ARCH_TYPE" = "loongarch64" ]; then
71 | ARCH_TYPE="loong64"
72 | fi
73 |
74 | FILENAME="vfox_${VERSION}_${OS_TYPE}_${ARCH_TYPE}"
75 | TAR_FILE="${FILENAME}.tar.gz"
76 |
77 | echo https://github.com/version-fox/vfox/releases/download/v$VERSION/$TAR_FILE
78 | $DOWNLOAD_CMD https://github.com/version-fox/vfox/releases/download/v$VERSION/$TAR_FILE
79 |
80 |
81 | tar -zxvf $TAR_FILE
82 | if [ $? -ne 0 ]; then
83 | echo "Failed to extract vfox binary. Please check if the downloaded file is a valid tar.gz file."
84 | exit 1
85 | fi
86 |
87 | # Create installation directory
88 | $SUDO_CMD mkdir -p "$INSTALL_DIR"
89 | if [ $? -ne 0 ]; then
90 | echo "Failed to create $INSTALL_DIR directory. Please check your permissions and try again."
91 | exit 1
92 | fi
93 |
94 | if [ -d "$INSTALL_DIR" ]; then
95 | $SUDO_CMD mv "${FILENAME}/vfox" "$INSTALL_DIR"
96 | else
97 | echo "$INSTALL_DIR is not a directory. Please make sure it is a valid directory path."
98 | exit 1
99 | fi
100 |
101 | if [ $? -ne 0 ]; then
102 | echo "Failed to move vfox to $INSTALL_DIR. Please check your permissions and try again."
103 | exit 1
104 | fi
105 | rm $TAR_FILE
106 | rm -rf $FILENAME
107 | echo "vfox installed successfully!"
108 | }
109 |
110 | main "$@"
111 |
--------------------------------------------------------------------------------
/docs/zh-hans/usage/core-commands.md:
--------------------------------------------------------------------------------
1 | # 核心命令
2 |
3 | ## Search
4 |
5 | 获取指定 SDK 所有可用的运行时版本。
6 |
7 | **用法**
8 |
9 | ```shell
10 | vfox search [...optionArgs]
11 | ```
12 |
13 | `sdk-name`: 运行时名称， 如`nodejs`、`custom-node`。
14 | `optionArgs`: 搜索命令的附加参数。注意：是否支持取决于插件。
15 |
16 | ::: warning 缓存
17 |
18 | `vfox`会缓存`search`的结果, 默认缓存时间为`12h`。
19 |
20 | 如果你想禁用，可以通过`vfox config`命令进行配置。
21 | ```shell
22 | vfox config cache.availableHookDuration 0
23 | ```
24 |
25 | 其余操作, 请查看[配置#缓存](../guides/configuration.md#%E7%BC%93%E5%AD%98)。
26 |
27 | :::
28 |
29 | ::: tip 快捷安装
30 | 选择目标版本， 回车即可快速安装。
31 | :::
32 |
33 | ::: tip 自动安装
34 | 如果本地没有安装 SDK，`search`命令会从远端仓库检索插件并安装到本地。
35 | :::
36 |
37 | ## Install
38 |
39 | 将指定的 SDK 版本安装到您的计算机并缓存以供将来使用。
40 |
41 | **用法**
42 |
43 | ```shell
44 | vfox install @
45 |
46 | vfox i @
47 | ```
48 |
49 | `sdk-name`: SDK 名称
50 |
51 | `version`: 需要安装的版本号
52 |
53 | **选项**
54 |
55 | - `-a, --all`: 安装 .tool-versions 中记录的所有 SDK 版本
56 | - `-y, --yes`: 直接安装，跳过确认提示
57 |
58 | ::: tip 自动安装
59 | 你可以一次性安装多个 SDK，通过空格分隔。
60 |
61 | ```shell
62 | vfox install nodejs@20 golang ...
63 | ```
64 |
65 | :::
66 |
67 | ::: tip
68 | 直接安装，跳过确认提示
69 |
70 | ```shell
71 | vfox install --yes nodejs@20
72 | vfox install --yes --all
73 | ```
74 |
75 | :::
76 |
77 | ## Use
78 |
79 | 设置运行时版本
80 |
81 | **用法**
82 |
83 | ```shell
84 | vfox use [options] [@]
85 |
86 | vfox u [options] [@]
87 | ```
88 |
89 | `sdk-name`: SDK 名称
90 |
91 | `version`[可选]: 使用 指定版本运行时。如不传， 则下拉选择。
92 |
93 | **选项**
94 |
95 | - `-g, --global`: 全局生效
96 | - `-p, --project`: 当前目录下生效
97 | - `-s, --session`: 当前 Shell 会话内生效
98 |
99 | ::: tip 默认作用域
100 | `Windows`: 默认`Global`作用域
101 |
102 | `Unix-like`: 默认`Session`作用域
103 |
104 | :::
105 |
106 | ## Unuse
107 |
108 | 从指定作用域取消设置运行时版本
109 |
110 | **用法**
111 |
112 | ```shell
113 | vfox unuse [options]
114 | ```
115 |
116 | `sdk-name`: SDK 名称
117 |
118 | **选项**
119 |
120 | - `-g, --global`: 从全局作用域移除
121 | - `-p, --project`: 从项目作用域移除（当前目录）
122 | - `-s, --session`: 从会话作用域移除（当前 Shell 会话）
123 |
124 | ::: tip 默认作用域
125 | `Windows`: 默认`Global`作用域
126 |
127 | `Unix-like`: 默认`Session`作用域
128 | :::
129 |
130 | ::: warning 效果
131 | 使用 `unuse` 后，SDK 将不再在指定作用域中处于活动状态。如果 SDK 在其他作用域中配置，那些将根据 vfox 的作用域层次结构优先生效（Session > Project > Global）。
132 | :::
133 |
134 | ## Uninstall
135 |
136 | 卸载指定版本的 SDK。
137 |
138 | **用法**
139 |
140 | ```shell
141 | vfox uninstall @
142 | vfox un @
143 | ```
144 |
145 | `sdk-name`: SDK 名
146 |
147 | `version`: 具体版本号
148 |
149 | ## List
150 |
151 | 查看当前已安装的所有 SDK 版本。
152 |
153 | **用法**
154 |
155 | ```shell
156 | vfox list []
157 |
158 | vfox ls[]
159 | ```
160 |
161 | `sdk-name`: SDK 名称， 不传展示所有。
162 |
163 | ## Current
164 |
165 | 查看当前 SDK 的版本。
166 |
167 | **用法**
168 |
169 | ```shell
170 | vfox current []
171 | vfox c
172 | ```
173 |
174 | ## Cd
175 |
176 | 在 `VFOX_HOME` 或 SDK 目录下启动 shell。
177 |
178 | **用法**
179 |
180 | ```shell
181 | vfox cd [options] []
182 | ```
183 |
184 | `sdk-name`: SDK 名称, 不传默认为 `VFOX_HOME`。
185 |
186 | **选项**
187 |
188 | - `-p, --plugin`: 在插件目录下启动 shell。
189 |
190 |
191 | ## Upgrade
192 |
193 | 升级 `vfox` 到最新版本。
194 |
195 | **用法**
196 |
197 | ```shell
198 | vfox upgrade
199 | ```
200 |
--------------------------------------------------------------------------------