0
0
package workflow
import (
"context"
"encoding/json"
"errors"
"fmt"
"maps"
"regexp"
"strings"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/sandbox"
)
var (
expressionPattern = regexp.MustCompile(`\$\{\{\s*([\s\S]+?)\s*\}\}`)
alwaysPattern = regexp.MustCompile(`(?:^|[^A-Za-z0-9_])always\(\)`)
failurePattern = regexp.MustCompile(`(?:^|[^A-Za-z0-9_])failure\(\)`)
)
type guardResult struct {
run bool
always bool
failure bool
}
func (e *Executor) evaluateGuard(ctx context.Context, condition any) (guardResult, error) {
result := guardResult{run: true}
if condition == nil {
return result, nil
}
text, isText := condition.(string)
if isText {
result.always = alwaysPattern.MatchString(text)
result.failure = failurePattern.MatchString(text)
}
switch typed := condition.(type) {
case bool:
result.run = typed
case int:
result.run = typed != 0
case int64:
result.run = typed != 0
case float64:
result.run = typed != 0
case string:
trimmed := strings.ToLower(strings.TrimSpace(typed))
switch {
case trimmed == "":
result.run = false
case trimmed == "true" || trimmed == "1":
result.run = true
case trimmed == "false" || trimmed == "0":
result.run = false
default:
expression := typed
if !strings.Contains(expression, "${{") {
expression = "${{ " + expression + " }}"
}
evaluated, err := e.evaluateExpression(ctx, expression)
if err != nil {
return result, err
}
if strings.Contains(evaluated, "${{") {
return result, fmt.Errorf("could not evaluate expression %q", typed)
}
evaluated = strings.ToLower(strings.TrimSpace(evaluated))
if evaluated == "__github_actions_always__" {
result.run = true
} else if evaluated == "false" || evaluated == "0" || evaluated == "" || evaluated == "null" || evaluated == "undefined" {
result.run = false
} else {
result.run = true
}
}
}
if e.jobFailed {
result.run = result.always || result.failure
} else if result.failure {
result.run = false
}
return result, nil
}
func (e *Executor) evaluateExpression(ctx context.Context, expression string) (string, error) {
if !strings.Contains(expression, "${{") {
return expression, nil
}
matches := expressionPattern.FindAllStringSubmatchIndex(expression, -1)
if len(matches) == 0 {
return expression, nil
}
var builder strings.Builder
last := 0
for _, match := range matches {
builder.WriteString(expression[last:match[0]])
inner := strings.TrimSpace(expression[match[2]:match[3]])
value, err := e.evaluateInnerExpression(ctx, inner)
if err != nil {
return "", err
}
builder.WriteString(value)
last = match[1]
}
builder.WriteString(expression[last:])
return builder.String(), nil
}
func (e *Executor) evaluateInnerExpression(ctx context.Context, inner string) (string, error) {
value, err := e.evaluateUsingJavaScript(ctx, inner)
if err == nil {
return value, nil
}
if ctx.Err() != nil {
return "", ctx.Err()
}
data := e.expressionData()
if resolved := resolvePropertyPath(inner, data); resolved != nil {
return fmt.Sprintf("%v", resolved), nil
}
return "", fmt.Errorf("could not evaluate expression %q: %w", inner, err)
}
func (e *Executor) expressionData() map[string]any {
return map[string]any{
"github": e.buildGitHubContext(),
"steps": e.Context.Outputs,
"inputs": e.Context.Inputs,
"env": e.Context.Env,
"secrets": e.Context.Secrets,
"vars": e.Context.Vars,
"needs": e.Context.JobResults,
"matrix": map[string]any{},
}
}
func (e *Executor) evaluateUsingJavaScript(ctx context.Context, inner string) (string, error) {
githubContext, err := json.Marshal(e.buildGitHubContext())
if err != nil {
return "", err
}
steps, err := json.Marshal(e.Context.Outputs)
if err != nil {
return "", err
}
inputs, err := json.Marshal(e.Context.Inputs)
if err != nil {
return "", err
}
env, err := json.Marshal(e.Context.Env)
if err != nil {
return "", err
}
secrets, err := json.Marshal(e.Context.Secrets)
if err != nil {
return "", err
}
vars, err := json.Marshal(e.Context.Vars)
if err != nil {
return "", err
}
needs, err := json.Marshal(e.Context.JobResults)
if err != nil {
return "", err
}
matrix, err := json.Marshal(map[string]any{})
if err != nil {
return "", err
}
failed := "false"
if e.jobFailed {
failed = "true"
}
script := `console.log(String((() => {
function always() { return "__GITHUB_ACTIONS_ALWAYS__"; }
function success() { return !__pe_failed; }
function failure() { return __pe_failed; }
function cancelled() { return false; }
function fromJSON(value) { return JSON.parse(value); }
function toJSON(value) { return JSON.stringify(value); }
function contains(haystack, needle) {
if (Array.isArray(haystack)) return haystack.includes(needle);
if (typeof haystack === "string") return haystack.includes(needle);
return false;
}
function startsWith(value, prefix) { return typeof value === "string" && value.startsWith(prefix); }
function endsWith(value, suffix) { return typeof value === "string" && value.endsWith(suffix); }
function format(value) {
const args = Array.prototype.slice.call(arguments, 1);
return String(value).replace(/\{(\d+)\}/g, (match, index) => args[Number(index)] !== undefined ? String(args[Number(index)]) : match);
}
function join(value, separator) { return Array.isArray(value) ? value.join(separator === undefined ? "," : separator) : String(value); }
function hashFiles() { return ""; }
const __pe_failed = ` + failed + `;
const github = ` + string(githubContext) + `;
const runner = {"debug":1};
const steps = ` + string(steps) + `;
const inputs = ` + string(inputs) + `;
const env = ` + string(env) + `;
const secrets = ` + string(secrets) + `;
const vars = ` + string(vars) + `;
const needs = ` + string(needs) + `;
const matrix = ` + string(matrix) + `;
return (` + transformPropertyAccessors(inner) + `);
})()))
`
stdout, stderr, err := e.runDeno(ctx, script, nil)
if err != nil {
return "", fmt.Errorf("deno evaluation failed: %w: %s", err, strings.TrimSpace(stderr))
}
return strings.TrimSpace(stdout), nil
}
func (e *Executor) buildGitHubContext() map[string]any {
context := make(map[string]any)
for key, value := range e.Context.Env {
if !strings.HasPrefix(key, "GITHUB_") {
continue
}
name := strings.Replace(strings.ToLower(key), "github_", "", 1)
context[name] = value
}
if _, exists := context["token"]; !exists {
context["token"] = e.Context.Secrets["GITHUB_TOKEN"]
}
context["event"] = map[string]any{"inputs": e.Context.Inputs}
return context
}
func resolvePropertyPath(path string, data map[string]any) any {
var current any = data
for part := range strings.SplitSeq(path, ".") {
object, ok := current.(map[string]any)
if !ok {
return nil
}
value, exists := object[part]
if !exists {
return nil
}
current = value
}
return current
}
func transformPropertyAccessors(code string) string {
var builder strings.Builder
index := 0
for index < len(code) {
character := code[index]
if character == '"' || character == '\'' {
quote := character
builder.WriteByte(character)
index++
for index < len(code) {
builder.WriteByte(code[index])
if code[index] == quote {
index++
break
}
index++
}
continue
}
if character == '.' {
builder.WriteString("['")
index++
start := index
for index < len(code) && isPropertyByte(code[index]) {
index++
}
builder.WriteString(code[start:index])
builder.WriteString("']")
continue
}
builder.WriteByte(character)
index++
}
return builder.String()
}
func isPropertyByte(value byte) bool {
return (value >= 'a' && value <= 'z') || (value >= 'A' && value <= 'Z') || (value >= '0' && value <= '9') || value == '_' || value == '-'
}
var errOutputExceeded = errors.New("policy action output exceeded")
func (e *Executor) runDeno(ctx context.Context, script string, extraEnv map[string]string) (string, string, error) {
if e.opts.Sandbox == nil || !e.opts.Sandbox.Available() {
return "", "", fmt.Errorf("deno runtime unavailable")
}
if !e.opts.Sandbox.Fenced() {
return "", "", fmt.Errorf("the %s sandbox runner enforces no fence; policy code is not run there", e.opts.Sandbox.Kind())
}
env := make(map[string]string, len(extraEnv)+2)
maps.Copy(env, extraEnv)
if _, exists := env["NO_COLOR"]; !exists {
env["NO_COLOR"] = "1"
}
if _, exists := env["DENO_NO_UPDATE_CHECK"]; !exists {
env["DENO_NO_UPDATE_CHECK"] = "1"
}
result, err := e.opts.Sandbox.Run(ctx, sandbox.Program{Source: script, Net: true, Env: env})
if ctxErr := ctx.Err(); ctxErr != nil {
return result.Stdout, result.Stderr, ctxErr
}
if err != nil {
return result.Stdout, result.Stderr, err
}
if result.TimedOut {
return result.Stdout, result.Stderr, fmt.Errorf("the policy sandbox outlived its deadline")
}
if result.StdoutTruncated {
return result.Stdout, result.Stderr, fmt.Errorf("%w %d bytes", errOutputExceeded, sandbox.OutputLimit)
}
if result.ExitCode != 0 {
return result.Stdout, result.Stderr, fmt.Errorf("policy code exited with %d", result.ExitCode)
}
return result.Stdout, result.Stderr, nil
}