feat(actions): Add Actions API endpoints for workflow run management and logs (#35382)

Implements the missing REST API endpoints for Actions workflow run
management:

1. `POST /actions/runs/{run}/cancel` cancels a run and its jobs, `409`
when it already finished
1. `POST /actions/runs/{run}/approve` approves a run awaiting approval,
idempotent, `409` when it never awaited one
1. `GET /actions/runs/{run}/logs` downloads the latest attempt's job
logs as a zip archive

`ActionWorkflowRun` gains `created_at`, `updated_at` and the `jobs_url`,
`logs_url`, `artifacts_url`, `cancel_url` and `rerun_url` fields, and
now always emits `conclusion` and `head_branch`.

Cancellation is shared with the web handler in `services/actions`.

Fixes https://github.com/go-gitea/gitea/issues/35176
Fixes https://github.com/go-gitea/gitea/issues/36554

---------

Co-authored-by: Claude Sonnet 4.6 <claude-sonnet-4-6@anthropic.com>
Co-authored-by: OpenCode Agent <opencode@rossgolder.com>
Co-authored-by: Nicolas <bircni@icloud.com>
Co-authored-by: silverwind <me@silverwind.io>
Co-authored-by: wxiaoguang <wxiaoguang@gmail.com>

modules/util/filename.go

@@ -0,0 +1,54 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package util
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// FileNameJoinFields joins the fields by separator "-" as a safe filename,
+// the last field is used as extname (no sep is added before it).
+// This function does its best to avoid the filename exceeding the max filename length (255 bytes on Linux),
+// Each field needs at least about 3 bytes, if the caller passes too many fields (e.g.: 100 fields),
+// then it's unavoidable, just do not write such code in real world.
+func FileNameJoinFields(fields ...any) string {
+	// linux max filename length is 255, we leave some space for the separators and extname
+	const maxFilenameLen = 210
+	return fileNameJoinFields(maxFilenameLen, fields...)
+}
+
+func fileNameJoinFields(stemNameLimit int, fields ...any) string {
+	// stemNameLimit is just a suggested limit, when adding more fields, the length might still exceed a little
+	sb := strings.Builder{}
+	for i, f := range fields {
+		var field string
+		switch v := f.(type) {
+		case string:
+			field = v
+		case int64:
+			field = strconv.FormatInt(v, 10)
+		default:
+			field = fmt.Sprint(v)
+		}
+		field = PathNameValidator().InvalidChars.ReplaceAllString(field, "_")
+		if i < len(fields)-1 {
+			field = strings.ReplaceAll(strings.ReplaceAll(field, ".", "_"), "-", "_")
+			estimatedRemainingLen := (len(fields) - 1 - i) * 3
+			estimatedLimit := stemNameLimit - estimatedRemainingLen
+			if sb.Len()+len(field) > estimatedLimit {
+				field = TruncateStringBytes(field, estimatedLimit-sb.Len()-2) + "__"
+			}
+			sb.WriteString(field)
+			if i < len(fields)-2 {
+				sb.WriteString("-")
+			}
+		} else {
+			// last field is extname, no need to do more processing
+			sb.WriteString(field)
+		}
+	}
+	return sb.String()
+}

modules/util/filename_test.go

@@ -0,0 +1,20 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFileNameJoinFields(t *testing.T) {
+	assert.Equal(t, "a_b-1.txt", FileNameJoinFields("a-b", 1, ".txt"))
+	assert.Equal(t, "a-____-b.txt", FileNameJoinFields("a", "/../", "b", ".txt"))
+	assert.Equal(t, "a-____-b.txt", FileNameJoinFields("a", "\\..\\", "b", ".txt"))
+
+	assert.Equal(t, "🌞-🌛.txt", fileNameJoinFields(14, "🌞", "🌛", ".txt"))
+	assert.Equal(t, "🌞-🌛__.txt", fileNameJoinFields(14, "🌞", "🌛🌛🌛🌛", ".txt"))
+	assert.Equal(t, "🌞__-__.txt", fileNameJoinFields(14, "🌞🌞🌞🌞", "🌛🌛🌛🌛", ".txt"))
+}

modules/util/path.go

@@ -10,9 +10,27 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"regexp"
 	"strings"
+	"sync"
 )
 
+var PathNameValidator = sync.OnceValue(func() (ret struct {
+	InvalidChars *regexp.Regexp
+	InvalidNames *regexp.Regexp
+},
+) {
+	ret.InvalidChars = regexp.MustCompile(`(?i)[<>:"/\\|?*\x{0000}-\x{001F}]`)
+	// invalid filename contents, based on https://github.com/sindresorhus/filename-reserved-regex
+	// "COM10" needs to be opened with UNC "\\.\COM10" on Windows, so itself is valid
+	ret.InvalidNames = regexp.MustCompile(`(?i)^(con|prn|aux|nul|com\d|lpt\d)$`)
+	return ret
+})
+
+func PathBaseStem(s string) string {
+	return strings.TrimSuffix(path.Base(s), path.Ext(s))
+}
+
 // PathJoinRel joins the path elements into a single path, each element is cleaned by path.Clean separately.
 // It only returns the following values (like path.Join), any redundant part (empty, relative dots, slashes) is removed.
 // It's caller's duty to make every element not bypass its own directly level, to avoid security issues.

modules/util/truncate.go

@@ -130,3 +130,17 @@ func TruncateRunes(str string, limit int) string {
 	}
 	return string([]rune(str)[:limit])
 }
+
+// TruncateStringBytes returns a truncated string with given byte limit,
+// it returns input string if its byte length doesn't exceed the limit.
+func TruncateStringBytes(str string, limit int) string {
+	l := 0
+	for i, r := range str {
+		rl := utf8.RuneLen(r)
+		if l+rl > limit {
+			return str[:i]
+		}
+		l += rl
+	}
+	return str
+}