0
0
package bundledactions
import (
"embed"
"fmt"
"io/fs"
"path"
"sort"
"strings"
"gopkg.in/yaml.v3"
)
//go:embed all:workflows all:tangy
var assets embed.FS
type Input struct {
Default string `yaml:"default"`
}
type Action struct {
Uses string
Path string
Using string
Main string
Inputs map[string]Input
Source []byte
YAML []byte
}
type actionDef struct {
Runs struct {
Using string `yaml:"using"`
Main string `yaml:"main"`
} `yaml:"runs"`
Inputs map[string]Input `yaml:"inputs"`
}
func Lookup(uses string) (*Action, error) {
value := strings.TrimSpace(uses)
if value == "" {
return nil, fmt.Errorf("action uses is empty")
}
if strings.HasPrefix(value, "./") || strings.HasPrefix(value, "/") {
return nil, fmt.Errorf("net-only sandbox refuses local action %q", value)
}
parts := strings.SplitN(value, "@", 2)
if len(parts) != 2 || strings.TrimSpace(parts[1]) == "" {
return nil, fmt.Errorf("unsupported uses format (expected org/repo@version): %q", value)
}
orgRepo := strings.TrimSpace(parts[0])
if !strings.HasPrefix(orgRepo, "tangy/") {
return nil, fmt.Errorf("action %q is not bundled; remote action downloads are disabled", orgRepo)
}
clean := path.Clean(orgRepo)
if clean != orgRepo || strings.Contains(clean, "..") || !fs.ValidPath(clean) {
return nil, fmt.Errorf("invalid bundled action path %q", orgRepo)
}
dir := clean
yamlPath := path.Join(dir, "action.yml")
yamlBytes, err := assets.ReadFile(yamlPath)
if err != nil {
yamlPath = path.Join(dir, "action.yaml")
yamlBytes, err = assets.ReadFile(yamlPath)
if err != nil {
return nil, fmt.Errorf("bundled action %q not found", orgRepo)
}
}
var def actionDef
if err := yaml.Unmarshal(yamlBytes, &def); err != nil {
return nil, fmt.Errorf("parse %s: %w", yamlPath, err)
}
main := strings.TrimSpace(def.Runs.Main)
if main == "" {
return nil, fmt.Errorf("bundled action %q has no main", orgRepo)
}
if !fs.ValidPath(main) || strings.Contains(main, "..") {
return nil, fmt.Errorf("bundled action %q has invalid main %q", orgRepo, main)
}
source, err := assets.ReadFile(path.Join(dir, main))
if err != nil {
return nil, fmt.Errorf("bundled action %q main %q not found", orgRepo, main)
}
return &Action{
Uses: value,
Path: "bundled-actions/" + orgRepo,
Using: strings.TrimSpace(def.Runs.Using),
Main: main,
Inputs: def.Inputs,
Source: source,
YAML: yamlBytes,
}, nil
}
func Workflows() map[string]string {
entries, err := fs.ReadDir(assets, "workflows")
if err != nil {
return map[string]string{}
}
out := make(map[string]string)
for _, entry := range entries {
name := entry.Name()
if entry.IsDir() || !strings.HasSuffix(name, ".yml") {
continue
}
data, err := assets.ReadFile(path.Join("workflows", name))
if err != nil {
continue
}
out[strings.TrimSuffix(name, ".yml")] = string(data)
}
return out
}
func Workflow(name string) ([]byte, bool) {
clean := strings.TrimSpace(name)
if clean == "" || strings.Contains(clean, "/") || strings.Contains(clean, "..") {
return nil, false
}
data, err := assets.ReadFile(path.Join("workflows", clean+".yml"))
if err != nil {
return nil, false
}
return data, true
}
func Names() []string {
all := Workflows()
out := make([]string, 0, len(all))
for name := range all {
out = append(out, name)
}
sort.Strings(out)
return out
}