limactl help and info flag should show available plugins

Signed-off-by: olalekan odukoya <[email protected]>

Author: jandubois

cmd/limactl/main.go

@@ -23,6 +23,7 @@ import (
 	"github.com/lima-vm/lima/v2/pkg/fsutil"
 	"github.com/lima-vm/lima/v2/pkg/limatype/dirnames"
 	"github.com/lima-vm/lima/v2/pkg/osutil"
+	"github.com/lima-vm/lima/v2/pkg/plugin"
 	"github.com/lima-vm/lima/v2/pkg/version"
 )
 
@@ -165,6 +166,10 @@ func newApp() *cobra.Command {
 	}
 	rootCmd.AddGroup(&cobra.Group{ID: "basic", Title: "Basic Commands:"})
 	rootCmd.AddGroup(&cobra.Group{ID: "advanced", Title: "Advanced Commands:"})
+	rootCmd.AddGroup(&cobra.Group{ID: "plugin", Title: "Available Plugins (Experimental):"})
+
+	// Discover and add plugins as commands
+	addPluginCommands(rootCmd)
 	rootCmd.AddCommand(
 		newCreateCommand(),
 		newStartCommand(),
@@ -215,14 +220,6 @@ func handleExitError(err error) {
 
 // executeWithPluginSupport handles command execution with plugin support.
 func executeWithPluginSupport(rootCmd *cobra.Command, args []string) error {
-	if len(args) > 0 {
-		cmd, _, err := rootCmd.Find(args)
-		if err != nil || cmd == rootCmd {
-			// Function calls os.Exit() if it found and executed the plugin
-			runExternalPlugin(rootCmd.Context(), args[0], args[1:])
-		}
-	}
-
 	rootCmd.SetArgs(args)
 	return rootCmd.Execute()
 }
@@ -232,7 +229,7 @@ func runExternalPlugin(ctx context.Context, name string, args []string) {
 		ctx = context.Background()
 	}
 
-	if err := updatePathEnv(); err != nil {
+	if err := plugin.UpdatePathForPlugins(); err != nil {
 		logrus.Warnf("failed to update PATH environment: %v", err)
 		// PATH update failure shouldn't prevent plugin execution
 	}
@@ -257,23 +254,30 @@ func runExternalPlugin(ctx context.Context, name string, args []string) {
 	logrus.Fatalf("external command %q failed: %v", execPath, err)
 }
 
-func updatePathEnv() error {
-	exe, err := os.Executable()
+func addPluginCommands(rootCmd *cobra.Command) {
+	plugins, err := plugin.DiscoverPlugins()
 	if err != nil {
-		return fmt.Errorf("failed to get executable path: %w", err)
+		logrus.Debugf("Failed to discover plugins: %v", err)
+		return
 	}
 
-	binDir := filepath.Dir(exe)
-	currentPath := os.Getenv("PATH")
-	newPath := binDir + string(filepath.ListSeparator) + currentPath
-
-	if err := os.Setenv("PATH", newPath); err != nil {
-		return fmt.Errorf("failed to set PATH environment: %w", err)
-	}
+	for _, p := range plugins {
+		pluginName := p.Name
+		pluginCmd := &cobra.Command{
+			Use:                pluginName,
+			Short:              p.Description,
+			GroupID:            "plugin",
+			DisableFlagParsing: true,
+			Run: func(cmd *cobra.Command, args []string) {
+				runExternalPlugin(cmd.Context(), pluginName, args)
+			},
+		}
 
-	logrus.Debugf("updated PATH to prioritize %s", binDir)
+		pluginCmd.SilenceUsage = true
+		pluginCmd.SilenceErrors = true
 
-	return nil
+		rootCmd.AddCommand(pluginCmd)
+	}
 }
 
 // WrapArgsError annotates cobra args error with some context, so the error message is more user-friendly.

pkg/limainfo/limainfo.go

@@ -17,6 +17,7 @@ import (
 	"github.com/lima-vm/lima/v2/pkg/limatype/dirnames"
 	"github.com/lima-vm/lima/v2/pkg/limatype/filenames"
 	"github.com/lima-vm/lima/v2/pkg/limayaml"
+	"github.com/lima-vm/lima/v2/pkg/plugin"
 	"github.com/lima-vm/lima/v2/pkg/registry"
 	"github.com/lima-vm/lima/v2/pkg/templatestore"
 	"github.com/lima-vm/lima/v2/pkg/usrlocalsharelima"
@@ -35,6 +36,7 @@ type LimaInfo struct {
 	HostOS          string                       `json:"hostOS"`       // since Lima v2.0.0
 	HostArch        string                       `json:"hostArch"`     // since Lima v2.0.0
 	IdentityFile    string                       `json:"identityFile"` // since Lima v2.0.0
+	Plugins         []plugin.Plugin              `json:"plugins"`      // since Lima v2.0.0
 }
 
 type DriverExt struct {
@@ -108,5 +110,15 @@ func New(ctx context.Context) (*LimaInfo, error) {
 			Location: bin,
 		}
 	}
+
+	plugins, err := plugin.DiscoverPlugins()
+	if err != nil {
+		logrus.WithError(err).Debug("Failed to discover plugins")
+		// Don't fail the entire info command if plugin discovery fails
+		info.Plugins = []plugin.Plugin{}
+	} else {
+		info.Plugins = plugins
+	}
+
 	return info, nil
 }

pkg/plugin/plugin.go

@@ -0,0 +1,194 @@
+// SPDX-FileCopyrightText: Copyright The Lima Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package plugin
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/lima-vm/lima/v2/pkg/usrlocalsharelima"
+)
+
+type Plugin struct {
+	Name        string `json:"name"`
+	Path        string `json:"path"`
+	Description string `json:"description,omitempty"`
+}
+
+func DiscoverPlugins() ([]Plugin, error) {
+	var plugins []Plugin
+	seen := make(map[string]bool)
+
+	dirs := getPluginDirectories()
+
+	for _, dir := range dirs {
+		pluginsInDir, err := scanDirectory(dir)
+		if err != nil {
+			logrus.Debugf("Failed to scan directory %s: %v", dir, err)
+			continue
+		}
+
+		for _, plugin := range pluginsInDir {
+			if !seen[plugin.Name] {
+				plugins = append(plugins, plugin)
+				seen[plugin.Name] = true
+			}
+		}
+	}
+
+	return plugins, nil
+}
+
+func getPluginDirectories() []string {
+	var dirs []string
+
+	selfPaths := []string{}
+
+	selfViaArgs0, err := usrlocalsharelima.ExecutableViaArgs0()
+	if err != nil {
+		logrus.WithError(err).Debug("failed to find executable")
+	} else {
+		selfPaths = append(selfPaths, selfViaArgs0)
+	}
+
+	selfViaOS, err := os.Executable()
+	if err != nil {
+		logrus.WithError(err).Debug("failed to find os.Executable()")
+	} else {
+		selfFinalPathViaOS, err := filepath.EvalSymlinks(selfViaOS)
+		if err != nil {
+			logrus.WithError(err).Debug("failed to resolve symlinks")
+			selfFinalPathViaOS = selfViaOS
+		}
+
+		if len(selfPaths) == 0 || selfFinalPathViaOS != selfPaths[0] {
+			selfPaths = append(selfPaths, selfFinalPathViaOS)
+		}
+	}
+
+	for _, self := range selfPaths {
+		binDir := filepath.Dir(self)
+		dirs = append(dirs, binDir)
+	}
+
+	pathEnv := os.Getenv("PATH")
+	if pathEnv != "" {
+		pathDirs := filepath.SplitList(pathEnv)
+		dirs = append(dirs, pathDirs...)
+	}
+
+	if prefixDir, err := usrlocalsharelima.Prefix(); err == nil {
+		libexecDir := filepath.Join(prefixDir, "libexec", "lima")
+		if _, err := os.Stat(libexecDir); err == nil {
+			dirs = append(dirs, libexecDir)
+		}
+	}
+
+	return dirs
+}
+
+func scanDirectory(dir string) ([]Plugin, error) {
+	var plugins []Plugin
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+
+		name := entry.Name()
+		if !strings.HasPrefix(name, "limactl-") {
+			continue
+		}
+
+		pluginName := strings.TrimPrefix(name, "limactl-")
+
+		if strings.Contains(pluginName, ".") {
+			if filepath.Ext(name) == ".exe" {
+				pluginName = strings.TrimSuffix(pluginName, ".exe")
+			} else {
+				continue
+			}
+		}
+
+		fullPath := filepath.Join(dir, name)
+
+		if !isExecutable(fullPath) {
+			continue
+		}
+
+		plugin := Plugin{
+			Name: pluginName,
+			Path: fullPath,
+		}
+
+		if desc := extractDescFromScript(fullPath); desc != "" {
+			plugin.Description = desc
+		}
+
+		plugins = append(plugins, plugin)
+	}
+
+	return plugins, nil
+}
+
+func isExecutable(path string) bool {
+	info, err := os.Stat(path)
+	if err != nil {
+		return false
+	}
+
+	mode := info.Mode()
+	if mode&0o111 != 0 {
+		return true
+	}
+
+	if filepath.Ext(path) == ".exe" {
+		return true
+	}
+
+	return false
+}
+
+func extractDescFromScript(path string) string {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		logrus.Debugf("Failed to read plugin script %s: %v", path, err)
+		return ""
+	}
+
+	lines := strings.Split(string(content), "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+
+		// Look for pattern: # <limactl-desc>Description text</limactl-desc>
+		if strings.HasPrefix(line, "#") && strings.Contains(line, "<limactl-desc>") && strings.Contains(line, "</limactl-desc>") {
+			start := strings.Index(line, "<limactl-desc>") + len("<limactl-desc>")
+			end := strings.Index(line, "</limactl-desc>")
+
+			if start < end {
+				desc := strings.TrimSpace(line[start:end])
+				logrus.Debugf("Plugin %s: extracted description from script: %q", filepath.Base(path), desc)
+				return desc
+			}
+		}
+	}
+
+	logrus.Debugf("Plugin %s: no <limactl-desc> found in script", filepath.Base(path))
+
+	return ""
+}
+
+func UpdatePathForPlugins() error {
+	pluginDirs := getPluginDirectories()
+	newPath := strings.Join(pluginDirs, string(filepath.ListSeparator))
+	return os.Setenv("PATH", newPath)
+}

pkg/usrlocalsharelima/usrlocalsharelima.go

@@ -19,14 +19,14 @@ import (
 	"github.com/lima-vm/lima/v2/pkg/limatype"
 )
 
-// executableViaArgs0 returns the absolute path to the executable used to start this process.
+// ExecutableViaArgs0 returns the absolute path to the executable used to start this process.
 // It will also append the file extension on Windows, if necessary.
 // This function is different from os.Executable(), which will use /proc/self/exe on Linux
 // and therefore will resolve any symlink used to locate the executable. This function will
 // return the symlink instead because we want to be able to locate ../share/lima relative
 // to the location of the symlink, and not the actual executable. This is important when
 // using Homebrew.
-var executableViaArgs0 = sync.OnceValues(func() (string, error) {
+var ExecutableViaArgs0 = sync.OnceValues(func() (string, error) {
 	if os.Args[0] == "" {
 		return "", errors.New("os.Args[0] has not been set")
 	}
@@ -47,7 +47,7 @@ var executableViaArgs0 = sync.OnceValues(func() (string, error) {
 func Dir() (string, error) {
 	selfPaths := []string{}
 
-	selfViaArgs0, err := executableViaArgs0()
+	selfViaArgs0, err := ExecutableViaArgs0()
 	if err != nil {
 		logrus.WithError(err).Warn("failed to find executable from os.Args[0]")
 	} else {