26 improve binary mask feature (#29)

* update binary mask

* add support to public repos

* add template var

Author: iignatevich

action.yaml

@@ -11,11 +11,23 @@ action:
       title: Password
       type: string
       default: ""
+    - name: target
+      title: Target version
+      description: Specific version to install
+      default: ""
     - name: config
       title: Config file
       description: Use specified config with metadata for update
       default: ""
-    - name: target
-      title: Target version
-      description: Specific version to install
+    - name: repository-url
+      title: Repository URL
+      description: URL do download binary from
+      default: ""
+    - name: release-file-mask
+      title: Release file mask
+      description: Specify URL for pinned release file with version. Available template vars are [URL, Version, OS, Arch, Ext]. Example - {{.URL}}/release
+      default: ""
+    - name: bin-mask
+      title: Binary file mask
+      description: Specify URL download mask for binary. Available template vars are [URL, Version, OS, Arch, Ext] Example - {{.URL}}/{{.Version}}
       default: ""

config.go

@@ -1,15 +1,23 @@
 package plasmactlupdate
 
 import (
+	"bytes"
 	"fmt"
+	"net/url"
 	"os"
 	"path/filepath"
-	"reflect"
+	"strings"
+	"text/template"
 
 	"github.com/launchrctl/launchr"
 	"gopkg.in/yaml.v3"
 )
 
+const (
+	defaultPinnedReleaseTpl = "{{.URL}}/stable_release"
+	defaultBinTpl           = "{{.URL}}/{{.Version}}/{{.Name}}_{{.OS}}_{{.Arch}}{{.Ext}}"
+)
+
 type config struct {
 	RepositoryURL string `yaml:"repository_url"`
 	PinnedRelease string `yaml:"pinned_release_file"`
@@ -24,9 +32,13 @@ func SetUpdateConfig(cfg *config) {
 	updateConfig = cfg
 }
 
-// GetDefaultConfig returns the global default configuration
+// GetDefaultConfig returns the global default configuration copy
 func getUpdateConfig() *config {
-	return updateConfig
+	if updateConfig == nil {
+		return &config{}
+	}
+	cfgCopy := *updateConfig
+	return &cfgCopy
 }
 
 // LoadConfigFromBytesAndSet parses the configuration from a byte slice and sets it as the global default configuration.
@@ -68,21 +80,70 @@ func parseConfigFromBytes(data []byte) (*config, error) {
 
 // validateConfig checks if all fields are filled and not empty
 func validateConfig(cfg *config) error {
-	v := reflect.ValueOf(cfg).Elem()
-	t := reflect.TypeOf(cfg).Elem()
-
-	for i := 0; i < v.NumField(); i++ {
-		field := v.Field(i)
-		fieldType := t.Field(i)
-
-		// Check if field is empty
-		if field.Kind() == reflect.String && field.String() == "" {
-			yamlTag := fieldType.Tag.Get("yaml")
-			if yamlTag == "" {
-				yamlTag = fieldType.Name
-			}
-			return fmt.Errorf("field '%s' is required and cannot be empty", yamlTag)
-		}
+	if cfg.RepositoryURL == "" {
+		return fmt.Errorf("field 'repository_url' is required and cannot be empty")
+	}
+
+	return nil
+}
+
+type templateVars struct {
+	URL     string
+	Name    string
+	Version string
+	OS      string
+	Arch    string
+	Ext     string
+}
+
+// formatURL formats a template string with the provided variables
+func formatURL(templateStr string, vars templateVars) (string, error) {
+	tmpl, err := template.New("url").Parse(templateStr)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse template: %w", err)
+	}
+
+	var buf bytes.Buffer
+	err = tmpl.Execute(&buf, vars)
+	if err != nil {
+		return "", fmt.Errorf("failed to execute template: %w", err)
+	}
+
+	result := strings.TrimSpace(buf.String())
+
+	// Validate the resulting URL
+	if err = validateURL(result); err != nil {
+		return "", fmt.Errorf("invalid URL generated from template: %w", err)
+	}
+
+	return result, nil
+}
+
+// validateURL checks if the URL is valid and doesn't contain unwanted characters
+func validateURL(rawURL string) error {
+	// Check for newlines, tabs, and other control characters
+	if strings.ContainsAny(rawURL, "\n\r\t\v\f") {
+		return fmt.Errorf("URL contains invalid control characters")
+	}
+
+	// Parse the URL to ensure it's valid
+	parsedURL, err := url.Parse(rawURL)
+	if err != nil {
+		return fmt.Errorf("invalid URL format: %w", err)
+	}
+
+	// Check if scheme is present and valid
+	if parsedURL.Scheme == "" {
+		return fmt.Errorf("URL missing scheme (http/https)")
+	}
+
+	if parsedURL.Scheme != "http" && parsedURL.Scheme != "https" {
+		return fmt.Errorf("invalid URL scheme: %s (expected http or https)", parsedURL.Scheme)
+	}
+
+	// Check if host is present
+	if parsedURL.Host == "" {
+		return fmt.Errorf("URL missing host")
 	}
 
 	return nil

plugin.go

@@ -4,6 +4,7 @@ package plasmactlupdate
 import (
 	"context"
 	_ "embed"
+	"fmt"
 
 	"github.com/launchrctl/keyring"
 	"github.com/launchrctl/launchr"
@@ -61,12 +62,45 @@ func (p *Plugin) DiscoverActions(_ context.Context) ([]*action.Action, error) {
 			return err
 		}
 
+		var cfg *config
+		// Check if the user submitted a custom config file.
+		externalCfg := input.Opt("config").(string)
+		if externalCfg != "" {
+			cfgExternal, err := parseConfigFromPath(externalCfg)
+			if err != nil {
+				return fmt.Errorf("error parsing external config file %s: %v", externalCfg, err)
+			}
+			cfg = cfgExternal
+		} else {
+			cfg = getUpdateConfig()
+			// Update the config with the user input if present.
+			repoURL := input.Opt("repository-url").(string)
+			if repoURL != "" {
+				cfg.RepositoryURL = repoURL
+			}
+			pinnedRelease := input.Opt("release-file-mask").(string)
+			if pinnedRelease != "" {
+				cfg.PinnedRelease = pinnedRelease
+			}
+			binMask := input.Opt("bin-mask").(string)
+			if binMask != "" {
+				cfg.BinMask = binMask
+			}
+		}
+
+		// Fallback to default config values if they are empty.
+		if cfg.PinnedRelease == "" {
+			cfg.PinnedRelease = defaultPinnedReleaseTpl
+		}
+		if cfg.BinMask == "" {
+			cfg.BinMask = defaultBinTpl
+		}
+
 		u := &updateAction{
 			k:             p.k,
 			credentials:   ci,
 			sudoCmd:       cmd,
-			cfg:           getUpdateConfig(),
-			externalCfg:   input.Opt("config").(string),
+			cfg:           cfg,
 			targetVersion: input.Opt("target").(string),
 		}
 		u.SetLogger(log)