Add python runtime

Author: zhamborova

cmd/init.go

@@ -83,6 +83,7 @@ func configFileTemplate(tools []tools.Tool) string {
 
 	return fmt.Sprintf(`runtimes:
     - [email protected]
+    - [email protected]
 tools:
     - eslint@%s
 `, eslintVersion)

plugins/runtime-utils.go

@@ -24,10 +24,10 @@ type binary struct {
 
 // pluginConfig holds the structure of the plugin.yaml file
 type pluginConfig struct {
-	Name        string            `yaml:"name"`
-	Description string            `yaml:"description"`
-	Download    downloadConfig    `yaml:"download"`
-	Binaries    []binary          `yaml:"binaries"`
+	Name        string         `yaml:"name"`
+	Description string         `yaml:"description"`
+	Download    downloadConfig `yaml:"download"`
+	Binaries    []binary       `yaml:"binaries"`
 }
 
 // downloadConfig holds the download configuration from the plugin.yaml
@@ -36,6 +36,8 @@ type downloadConfig struct {
 	FileNameTemplate string            `yaml:"file_name_template"`
 	Extension        extensionConfig   `yaml:"extension"`
 	ArchMapping      map[string]string `yaml:"arch_mapping"`
+	OSMapping        map[string]string `yaml:"os_mapping"`
+	ReleaseVersion   string            `yaml:"release_version"`
 }
 
 // extensionConfig defines the file extension based on OS
@@ -46,11 +48,12 @@ type extensionConfig struct {
 
 // templateData holds the data to be used in template substitution
 type templateData struct {
-	Version   string
-	FileName  string
-	OS        string
-	Arch      string
-	Extension string
+	Version        string
+	FileName       string
+	OS             string
+	Arch           string
+	Extension      string
+	ReleaseVersion string
 }
 
 // runtimePlugin represents a runtime plugin with methods to interact with it
@@ -79,31 +82,30 @@ type RuntimeInfo struct {
 // ProcessRuntimes processes a list of runtime configurations and returns a map of runtime information
 func ProcessRuntimes(configs []RuntimeConfig, runtimesDir string) (map[string]*RuntimeInfo, error) {
 	result := make(map[string]*RuntimeInfo)
-	
+
 	for _, config := range configs {
 		runtimeInfo, err := processRuntime(config, runtimesDir)
 		if err != nil {
 			return nil, err
 		}
-		
+
 		result[config.Name] = runtimeInfo
 	}
-	
+
 	return result, nil
 }
 
-
 // ProcessRuntime processes a single runtime configuration and returns detailed runtime info
 func processRuntime(config RuntimeConfig, runtimesDir string) (*RuntimeInfo, error) {
 	plugin, err := loadPlugin(config.Name)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load plugin for runtime %s: %w", config.Name, err)
 	}
-	
+
 	fileName := plugin.getFileName(config.Version)
 	extension := plugin.getExtension(runtime.GOOS)
 	installDir := plugin.getInstallationDirectoryPath(runtimesDir, config.Version)
-	
+
 	// Create RuntimeInfo with essential information
 	info := &RuntimeInfo{
 		Name:        config.Name,
@@ -114,39 +116,38 @@ func processRuntime(config RuntimeConfig, runtimesDir string) (*RuntimeInfo, err
 		Extension:   extension,
 		Binaries:    make(map[string]string),
 	}
-	
+
 	// Process binary paths
 	for _, binary := range plugin.Config.Binaries {
 		binaryPath := path.Join(installDir, binary.Path)
-		
+
 		// Add file extension for Windows executables
 		if runtime.GOOS == "windows" && !strings.HasSuffix(binaryPath, ".exe") {
 			binaryPath += ".exe"
 		}
-		
+
 		info.Binaries[binary.Name] = binaryPath
 	}
-	
+
 	return info, nil
 }
 
-
 // LoadPlugin loads a plugin configuration from the specified plugin directory
 func loadPlugin(runtimeName string) (*runtimePlugin, error) {
 	pluginPath := filepath.Join("runtimes", runtimeName, "plugin.yaml")
-	
+
 	// Read from embedded filesystem
 	data, err := pluginsFS.ReadFile(pluginPath)
 	if err != nil {
 		return nil, fmt.Errorf("error reading plugin.yaml: %w", err)
 	}
-	
+
 	var config pluginConfig
 	err = yaml.Unmarshal(data, &config)
 	if err != nil {
 		return nil, fmt.Errorf("error parsing plugin.yaml: %w", err)
 	}
-	
+
 	return &runtimePlugin{
 		Config:     config,
 		ConfigPath: pluginPath,
@@ -175,67 +176,79 @@ func (p *runtimePlugin) getExtension(goos string) string {
 func (p *runtimePlugin) getFileName(version string) string {
 	goos := runtime.GOOS
 	goarch := runtime.GOARCH
-	
-	// Map Go architecture to runtime-specific architecture
+
+	// Map Go architecture and OS to runtime-specific values
 	mappedArch := p.getMappedArch(goarch)
-	
+	mappedOS := p.getMappedOS(goos)
+	releaseVersion := p.getReleaseVersion()
+
 	// Prepare template data
 	data := templateData{
-		Version: version,
-		OS:      goos,
-		Arch:    mappedArch,
+		Version:        version,
+		OS:             mappedOS,
+		Arch:           mappedArch,
+		ReleaseVersion: releaseVersion,
 	}
-	
+
 	// Execute template substitution for filename
 	tmpl, err := template.New("filename").Parse(p.Config.Download.FileNameTemplate)
 	if err != nil {
 		return ""
 	}
-	
+
 	var buf bytes.Buffer
 	err = tmpl.Execute(&buf, data)
 	if err != nil {
 		return ""
 	}
-	
+
 	return buf.String()
 }
 
+// GetReleaseVersion returns the release version from the plugin configuration
+func (p *runtimePlugin) getReleaseVersion() string {
+	return p.Config.Download.ReleaseVersion
+}
+
 // GetDownloadURL generates the download URL based on the template in plugin.yaml
 func (p *runtimePlugin) getDownloadURL(version string) string {
 	goos := runtime.GOOS
 	goarch := runtime.GOARCH
-	
-	// Map Go architecture to runtime-specific architecture
+
+	// Map Go architecture and OS to runtime-specific values
 	mappedArch := p.getMappedArch(goarch)
-	
+	mappedOS := p.getMappedOS(goos)
+
 	// Get the appropriate extension
 	extension := p.getExtension(goos)
-	
+
 	// Get the filename
 	fileName := p.getFileName(version)
-	
+
+	releaseVersion := p.getReleaseVersion()
+
 	// Prepare template data
 	data := templateData{
-		Version:   version,
-		FileName:  fileName,
-		OS:        goos,
-		Arch:      mappedArch,
-		Extension: extension,
+		Version:        version,
+		FileName:       fileName,
+		OS:             mappedOS,
+		Arch:           mappedArch,
+		Extension:      extension,
+		ReleaseVersion: releaseVersion,
 	}
-	
+
 	// Execute template substitution for URL
 	tmpl, err := template.New("url").Parse(p.Config.Download.URLTemplate)
 	if err != nil {
 		return ""
 	}
-	
+
 	var buf bytes.Buffer
 	err = tmpl.Execute(&buf, data)
 	if err != nil {
 		return ""
 	}
-	
+
 	return buf.String()
 }
 
@@ -244,3 +257,13 @@ func (p *runtimePlugin) getInstallationDirectoryPath(runtimesDir string, version
 	fileName := p.getFileName(version)
 	return path.Join(runtimesDir, fileName)
 }
+
+// GetMappedOS returns the OS mapping for the current system
+func (p *runtimePlugin) getMappedOS(goos string) string {
+	// Check if there's a mapping for this OS
+	if mappedOS, ok := p.Config.Download.OSMapping[goos]; ok {
+		return mappedOS
+	}
+	// Return the original OS if no mapping exists
+	return goos
+}

plugins/runtimes/python/plugin.yaml

@@ -0,0 +1,23 @@
+name: python
+description: Python runtime
+download:
+  url_template: "https://github.com/astral-sh/python-build-standalone/releases/download/{{.ReleaseVersion}}/cpython-{{.Version}}+{{.ReleaseVersion}}-{{.Arch}}-{{.OS}}-install_only.{{.Extension}}"
+  file_name_template: "cpython-{{.Version}}+{{.ReleaseVersion}}-{{.Arch}}-{{.OS}}"
+  release_version: "20250317"
+  extension:
+    windows: "tar.gz"
+    default: "tar.gz"
+  arch_mapping:
+    "386": "x86"
+    "amd64": "x86_64"
+    "arm": "armv7l"
+    "arm64": "aarch64"
+  os_mapping:
+    "darwin": "apple-darwin"
+    "linux": "unknown-linux-gnu"
+    "windows": "pc-windows-msvc"
+binaries:
+  - name: python3
+    path: "python/bin/python3"
+  - name: pip
+    path: "python/bin/pip"

utils/extract.go

@@ -2,10 +2,12 @@ package utils
 
 import (
 	"context"
-	"github.com/mholt/archiver/v4"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
+
+	"github.com/mholt/archiver/v4"
 )
 
 func ExtractTarGz(archive *os.File, targetDir string) error {
@@ -14,31 +16,33 @@ func ExtractTarGz(archive *os.File, targetDir string) error {
 		Archival:    archiver.Tar{},
 	}
 
+	// Create a map to store symlinks for later creation
+	symlinks := make(map[string]string)
+
 	handler := func(ctx context.Context, f archiver.File) error {
 		path := filepath.Join(targetDir, f.NameInArchive)
 
 		switch f.IsDir() {
 		case true:
 			// create a directory
-			//fmt.Println("creating:   " + f.NameInArchive)
 			err := os.MkdirAll(path, 0777)
 			if err != nil {
 				return err
 			}
 
 		case false:
-			//log.Print("extracting: " + f.NameInArchive)
-
-			// if is a symlink
+			// if is a symlink, store it for later
 			if f.LinkTarget != "" {
-				os.Remove(path)
-				err := os.Symlink(f.LinkTarget, path)
-				if err != nil {
-					return err
-				}
+				symlinks[path] = f.LinkTarget
 				return nil
 			}
 
+			// ensure parent directory exists
+			err := os.MkdirAll(filepath.Dir(path), 0777)
+			if err != nil {
+				return err
+			}
+
 			// write a file
 			w, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, f.Mode())
 			if err != nil {
@@ -62,6 +66,25 @@ func ExtractTarGz(archive *os.File, targetDir string) error {
 	if err != nil {
 		return err
 	}
+
+	// Create symlinks after all files have been extracted
+	for path, target := range symlinks {
+		// Remove any existing file/symlink
+		os.Remove(path)
+
+		// Ensure parent directory exists
+		err := os.MkdirAll(filepath.Dir(path), 0777)
+		if err != nil {
+			return err
+		}
+
+		// Create the symlink
+		err = os.Symlink(target, path)
+		if err != nil {
+			return fmt.Errorf("failed to create symlink %s -> %s: %w", path, target, err)
+		}
+	}
+
 	return nil
 }