fix: trace git command correctly (#39520) (#39524)

Backport #39520 by @wxiaoguang

Help  #39410

Co-authored-by: wxiaoguang <wxiaoguang@gmail.com>

custom/conf/app.example.ini

@@ -155,7 +155,7 @@
 ;; Username to use for the builtin SSH server. If blank, then it is the value of RUN_USER.
 ;BUILTIN_SSH_SERVER_USER =
 ;;
-;; Domain name to be exposed in clone URL, defaults to the domain part of ROOT_URL
+;; Domain name to be exposed in clone URL, defaults to DOMAIN or the domain part of ROOT_URL
 ;SSH_DOMAIN =
 ;;
 ;; Port number to be exposed in clone URL.
@@ -198,7 +198,7 @@
 ;; For the built-in SSH server, choose the keypair to offer as the host key
 ;; The private key should be at SSH_SERVER_HOST_KEY and the public SSH_SERVER_HOST_KEY.pub
 ;; relative paths are made absolute relative to the APP_DATA_PATH
-;SSH_SERVER_HOST_KEYS=ssh/gitea.rsa, ssh/gitea.ed25519, ssh/gitea.ecdsa, ssh/gogs.rsa
+;SSH_SERVER_HOST_KEYS=ssh/gitea.rsa, ssh/gogs.rsa
 ;;
 ;; Enable SSH Authorized Key Backup when rewriting all keys, default is false
 ;SSH_AUTHORIZED_KEYS_BACKUP = false
@@ -237,7 +237,7 @@
 ;SSH_PER_WRITE_PER_KB_TIMEOUT = 30s
 ;;
 ;; Indicate whether to check minimum key size with corresponding type
-;MINIMUM_KEY_SIZE_CHECK = true
+;MINIMUM_KEY_SIZE_CHECK = false
 ;;
 ;; TLS Settings: Either ACME or manual
 ;; (Other common TLS configuration are found before)
@@ -836,7 +836,7 @@ LEVEL = Info
 ;EMAIL_DOMAIN_BLOCKLIST =
 ;;
 ;; Disallow registration, only allow admins to create accounts.
-;DISABLE_REGISTRATION = true
+;DISABLE_REGISTRATION = false
 ;;
 ;; Allow registration only using gitea itself, it works only when DISABLE_REGISTRATION is false
 ;ALLOW_ONLY_INTERNAL_REGISTRATION = false
@@ -968,11 +968,12 @@ LEVEL = Info
 ;; Value for the domain part of the user's email address in the git log if user
 ;; has set KeepEmailPrivate to true. The user's email will be replaced with a
 ;; concatenation of the user name in lower case, "@" and NO_REPLY_ADDRESS. Default
-;; value is "noreply." + the domain part of ROOT_URL
-;NO_REPLY_ADDRESS =
+;; value is "noreply." + DOMAIN, where DOMAIN resolves to the value from server.DOMAIN
+;; Note: do not use the <DOMAIN> notation below
+;NO_REPLY_ADDRESS = ; noreply.<DOMAIN>
 ;;
-;; Show Registration button, defaults to true only if both DISABLE_REGISTRATION and ALLOW_ONLY_EXTERNAL_REGISTRATION are false
-;SHOW_REGISTRATION_BUTTON = false
+;; Show Registration button
+;SHOW_REGISTRATION_BUTTON = true
 ;;
 ;; Show milestones dashboard page - a view of all the user's milestones
 ;SHOW_MILESTONES_DASHBOARD_PAGE = true
@@ -1669,13 +1670,13 @@ LEVEL = Info
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
-;; General queue type, currently support: level, channel, redis, dummy
-;; default to level
-;TYPE = level
+;; General queue queue type, currently support: persistable-channel, channel, level, redis, dummy
+;; default to persistable-channel
+;TYPE = persistable-channel
 ;;
-;; data-dir for storing level queues, individual queues will default to `queues/common` meaning the queue is shared.
+;; data-dir for storing persistable queues and level queues, individual queues will default to `queues/common` meaning the queue is shared.
 ;; Relative paths will be made absolute against "APP_DATA_PATH"
-;DATADIR = queues/common
+;DATADIR = queues/
 ;;
 ;; Default queue length before a channel queue will block
 ;LENGTH = 100000
@@ -1683,7 +1684,7 @@ LEVEL = Info
 ;; Batch size to send for batched queues
 ;BATCH_LENGTH = 20
 ;;
-;; When `TYPE` is `level`, this provides a directory for the underlying leveldb
+;; When `TYPE` is `persistable-channel`, this provides a directory for the underlying leveldb
 ;; or additional options of the form `leveldb://path/to/db?option=value&....`, and will override `DATADIR`.
 ;; When `TYPE` is `redis` and this is left empty, it falls back to the shared [redis] CONN_STR.
 ;CONN_STR =
@@ -1751,6 +1752,7 @@ LEVEL = Info
 ;ENABLE_OPENID_SIGNIN = false
 ;;
 ;; Whether to allow registering via OpenID
+;; Do not include to rely on rhw DISABLE_REGISTRATION setting
 ;;ENABLE_OPENID_SIGNUP = false
 ;;
 ;; Allowed URI patterns (POSIX regexp).
@@ -2013,8 +2015,8 @@ LEVEL = Info
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; Either "memory", "file", "redis", "db", "mysql", "couchbase", "memcache" or "postgres"
-;; Default is "file". "db" will reuse the configuration in [database]
-;PROVIDER = file
+;; Default is "memory". "db" will reuse the configuration in [database]
+;PROVIDER = memory
 ;;
 ;; Provider config options
 ;; memory: doesn't have any config yet
@@ -2050,8 +2052,7 @@ LEVEL = Info
 ;; How Gitea deals with missing repository avatars
 ;; none = no avatar will be displayed; random = random avatar will be displayed; image = default image will be used
 ;REPOSITORY_AVATAR_FALLBACK = none
-;; Image URL for the "image" fallback, used as-is, defaults to Gitea's builtin repository avatar
-;REPOSITORY_AVATAR_FALLBACK_IMAGE =
+;REPOSITORY_AVATAR_FALLBACK_IMAGE = /img/repo_default.png
 ;;
 ;; Max Width and Height of uploaded avatars.
 ;; This is to limit the amount of RAM used when resizing the image.

models/actions/runner.go

@@ -200,7 +200,7 @@ func (r *ActionRunner) GenerateAndFillToken() {
 // CanMatchLabels checks whether the runner's labels can match a job's "runs-on"
 // See https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idruns-on
 func (r *ActionRunner) CanMatchLabels(jobRunsOn []string) bool {
-	return len(jobRunsOn) > 0 && !slices.ContainsFunc(jobRunsOn, func(label string) bool { return !util.SliceContainsString(r.AgentLabels, label, true) })
+	return !slices.ContainsFunc(jobRunsOn, func(label string) bool { return !util.SliceContainsString(r.AgentLabels, label, true) })
 }
 
 func init() {

models/actions/runner_test.go

@@ -86,5 +86,4 @@ func TestCanMatchLabelsCaseInsensitive(t *testing.T) {
 	runner := &ActionRunner{AgentLabels: []string{"self-hosted", "Linux", "X64"}}
 	assert.True(t, runner.CanMatchLabels([]string{"SELF-HOSTED", "linux"}))
 	assert.False(t, runner.CanMatchLabels([]string{"linux", "arm64"}))
-	assert.False(t, runner.CanMatchLabels(nil))
 }

models/auth/oauth2.go

@@ -564,12 +564,6 @@ func (grant *OAuth2Grant) SetNonce(ctx context.Context, nonce string) error {
 	return nil
 }
 
-func UpdateGrantScope(ctx context.Context, grant *OAuth2Grant, newScope string) error {
-	grant.Scope = newScope
-	_, err := db.GetEngine(ctx).ID(grant.ID).Cols("scope").Update(grant)
-	return err
-}
-
 // GetOAuth2GrantByID returns the grant with the given ID
 func GetOAuth2GrantByID(ctx context.Context, id int64) (grant *OAuth2Grant, err error) {
 	grant = new(OAuth2Grant)

models/git/commit_status.go

@@ -311,17 +311,17 @@ func (opts *CommitStatusOptions) ToConds() builder.Cond {
 func (opts *CommitStatusOptions) ToOrders() string {
 	switch opts.SortType {
 	case "oldest":
-		return "created_unix ASC, `index` ASC"
+		return "created_unix ASC"
 	case "recentupdate":
-		return "updated_unix DESC, `index` DESC"
+		return "updated_unix DESC"
 	case "leastupdate":
-		return "updated_unix ASC, `index` ASC"
+		return "updated_unix ASC"
 	case "leastindex":
 		return "`index` DESC"
 	case "highestindex":
 		return "`index` ASC"
 	default:
-		return "created_unix DESC, `index` DESC" // timestamps have 1s resolution, `index` keeps paging stable
+		return "created_unix DESC"
 	}
 }
 

models/git/commit_status_test.go

@@ -32,15 +32,28 @@ func TestGetCommitStatuses(t *testing.T) {
 	})
 	assert.NoError(t, err)
 	assert.Equal(t, 5, int(maxResults))
-	var indexes []int64
-	for _, status := range statuses {
-		indexes = append(indexes, status.Index)
-	}
-	assert.Equal(t, []int64{5, 4, 3, 2, 1}, indexes)
-	assert.Equal(t, "deploy/awesomeness", statuses[0].Context)
-	assert.Equal(t, commitstatus.CommitStatusError, statuses[0].State)
+	assert.Len(t, statuses, 5)
+
+	assert.Equal(t, "ci/awesomeness", statuses[0].Context)
+	assert.Equal(t, commitstatus.CommitStatusPending, statuses[0].State)
 	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/statuses/1234123412341234123412341234123412341234", statuses[0].APIURL(t.Context()))
 
+	assert.Equal(t, "cov/awesomeness", statuses[1].Context)
+	assert.Equal(t, commitstatus.CommitStatusWarning, statuses[1].State)
+	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/statuses/1234123412341234123412341234123412341234", statuses[1].APIURL(t.Context()))
+
+	assert.Equal(t, "cov/awesomeness", statuses[2].Context)
+	assert.Equal(t, commitstatus.CommitStatusSuccess, statuses[2].State)
+	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/statuses/1234123412341234123412341234123412341234", statuses[2].APIURL(t.Context()))
+
+	assert.Equal(t, "ci/awesomeness", statuses[3].Context)
+	assert.Equal(t, commitstatus.CommitStatusFailure, statuses[3].State)
+	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/statuses/1234123412341234123412341234123412341234", statuses[3].APIURL(t.Context()))
+
+	assert.Equal(t, "deploy/awesomeness", statuses[4].Context)
+	assert.Equal(t, commitstatus.CommitStatusError, statuses[4].State)
+	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/statuses/1234123412341234123412341234123412341234", statuses[4].APIURL(t.Context()))
+
 	statuses, maxResults, err = db.FindAndCount[git_model.CommitStatus](t.Context(), &git_model.CommitStatusOptions{
 		ListOptions: db.ListOptions{Page: 2, PageSize: 50},
 		RepoID:      repo1.ID,

models/user/search.go

@@ -40,8 +40,8 @@ type SearchUserOptions struct {
 	Keyword       string
 	Types         []UserType
 	UID           int64
-	LoginName     string                 // this option should be used only for admin user
-	SourceID      optional.Option[int64] // this option should be used only for admin user, Some(0) means local users
+	LoginName     string // this option should be used only for admin user
+	SourceID      int64  // this option should be used only for admin user
 	OrderBy       db.SearchOrderBy
 	Visible       []structs.VisibleType
 	Actor         *User // The user doing the search
@@ -106,8 +106,8 @@ func (opts *SearchUserOptions) toSearchQueryBase(ctx context.Context) db.Session
 		cond = cond.And(builder.Eq{"id": opts.UID})
 	}
 
-	if opts.SourceID.Has() {
-		cond = cond.And(builder.Eq{"login_source": opts.SourceID.Value()})
+	if opts.SourceID > 0 {
+		cond = cond.And(builder.Eq{"login_source": opts.SourceID})
 	}
 	if opts.LoginName != "" {
 		cond = cond.And(builder.Eq{"login_name": opts.LoginName})

modules/actions/jobparser/jobparser.go

@@ -225,6 +225,7 @@ func replaceScalars(node *yaml.Node, replace func(string) string) {
 // buildMatrixCombos builds one Job per matrix combination from src, baking the combination into the
 // strategy and interpolating the name, runs-on and continue-on-error with it.
 func buildMatrixCombos(jobID string, src *Job, matrixes []map[string]any, gitCtx *model.GithubContext, results map[string]*JobResult, vars map[string]string, inputs map[string]any) ([]*Job, error) {
+	srcRunsOn := model.RunsOnFromNode(src.RawRunsOn)
 	order, names := make([]int, len(matrixes)), make([]string, len(matrixes))
 	for index, matrix := range matrixes {
 		order[index], names[index] = index, matrixName(matrix)
@@ -258,15 +259,14 @@ func buildMatrixCombos(jobID string, src *Job, matrixes []map[string]any, gitCtx
 			if err := evaluator.EvaluateYamlNode(&rawRunsOn); err != nil {
 				return nil, fmt.Errorf("interpolate runs-on for job %q: %w", jobID, err)
 			}
-			if rawRunsOn.Kind != 0 && runsOnProblem(&rawRunsOn) != "" {
-				combo.RawRunsOn = rawRunsOn
-			} else {
-				runsOn := model.RunsOnFromNode(rawRunsOn)
-				for i := range runsOn {
-					runsOn[i] = escapeExpressions(runsOn[i])
-				}
-				combo.RawRunsOn = model.RunsOnNode(runsOn, "")
+			runsOn := model.RunsOnFromNode(rawRunsOn)
+			if len(runsOn) == 0 && len(srcRunsOn) > 0 { // match no runner rather than every runner
+				runsOn = []string{""}
 			}
+			for i := range runsOn {
+				runsOn[i] = escapeExpressions(runsOn[i])
+			}
+			combo.RawRunsOn = model.RunsOnNode(runsOn, "")
 		}
 		if err := evaluator.EvaluateYamlNode(&combo.RawContinueOnError); err != nil {
 			return nil, fmt.Errorf("evaluate continue-on-error for job %q: %w", jobID, err)

modules/actions/jobparser/jobparser_test.go

@@ -290,26 +290,17 @@ func TestParseInterpolatesRunName(t *testing.T) {
 	assert.Empty(t, result[0].RunName)
 }
 
-func TestParseRunsOnFromJSONKeepsWhatGitHubRejectsForTheJobToFail(t *testing.T) {
+func TestParseRunsOnFromJSONArray(t *testing.T) {
 	content := []byte("on: push\njobs:\n  build:\n    runs-on: ${{ fromJSON(vars.RUNNER) }}\n    steps: [{run: echo}]\n")
 	_, err := Parse(content)
 	require.NoError(t, err)
-	for runner, want := range map[string][]string{`["self-hosted", "linux"]`: {"self-hosted", "linux"}, "[]": {}, "{}": {}} {
+	for runner, want := range map[string][]string{`["self-hosted", "linux"]`: {"self-hosted", "linux"}, "[]": {""}} {
 		result, err := Parse(content, WithGitContext(&model.GithubContext{}), WithVars(map[string]string{"RUNNER": runner}))
 		require.NoError(t, err)
 		require.Len(t, result, 1)
 		_, job := result[0].Job()
 		assert.Equal(t, want, job.RunsOn(), runner)
 	}
-	for runner, problem := range map[string]string{`["a"]`: "", `""`: "Unexpected value ''", `[["a"]]`: "A sequence was not expected"} {
-		result, err := Parse(content, WithGitContext(&model.GithubContext{}), WithVars(map[string]string{"RUNNER": runner}))
-		require.NoError(t, err)
-		payload, err := result[0].Marshal()
-		require.NoError(t, err)
-		_, job, err := ParseRawSingleWorkflow(payload)
-		require.NoError(t, err)
-		assert.Equal(t, problem, job.RunsOnProblem(), runner)
-	}
 }
 
 func TestJobFieldsWithoutMatrix(t *testing.T) {
@@ -467,37 +458,6 @@ func TestReadWorkflowJobConditionContexts(t *testing.T) {
 	}
 }
 
-func TestValidateWorkflowStaticJobKindAndRunsOnLikeGitHub(t *testing.T) {
-	for job, want := range map[string]string{
-		"{runs-on: x, steps: [{run: echo}]}":      "",
-		"{uses: o/r/.gitea/workflows/c.yml@main}": "",
-		"{runs-on: []}": "",
-		"{runs-on: {}}": "",
-		"{runs-on: {group: org/g, labels: [a, 1]}}":           "",
-		"{runs-on: {group: '${{ vars.G }}'}}":                 "",
-		"{steps: [{run: echo}]}":                              "Required property is missing: runs-on",
-		"{with: {}}":                                          "Required property is missing: uses",
-		"{runs-on: x, uses: o/r/.gitea/workflows/c.yml@main}": "Unexpected value 'uses'",
-		"{Runs-On: x}":                                        "Unexpected value 'Runs-On'",
-		"{runs-on: ~}":                                        "runs-on: Unexpected value ''",
-		"{runs-on: ['']}":                                     "runs-on: Unexpected value ''",
-		"{runs-on: [[a]]}":                                    "runs-on: A sequence was not expected",
-		"{runs-on: {labels: {a: b}}}":                         "runs-on: A mapping was not expected",
-		"{runs-on: {foo: x}}":                                 "runs-on: Unexpected value 'foo'",
-		"{runs-on: {group: org/}}":                            "runs-on: Invalid runs-on group name 'org/'.",
-		"{runs-on: {group: a/b/c}}":                           "runs-on: Invalid runs-on group name 'a/b/c'. Please use 'organization/' or 'enterprise/' prefix to target a single runner group.",
-		"{if: true}": "There's not enough info to determine what you meant. Add one of these properties: " +
-			"cancel-timeout-minutes, container, continue-on-error, defaults, env, environment, outputs, runs-on, secrets, services, snapshot, steps, timeout-minutes, uses, with",
-	} {
-		_, err := ValidateWorkflowStatic([]byte("on: push\njobs:\n  build: " + job + "\n"))
-		if want == "" {
-			assert.NoError(t, err, job)
-		} else {
-			assert.EqualError(t, err, "job build: "+want, job)
-		}
-	}
-}
-
 func TestRejectsUnevaluatedMatrixFilters(t *testing.T) {
 	for _, filter := range []string{"include", "exclude"} {
 		t.Run(filter, func(t *testing.T) {

modules/actions/jobparser/model.go

@@ -174,14 +174,6 @@ func (j *Job) EraseNeeds() *Job {
 	return j
 }
 
-// RunsOnProblem returns github.com's error for the job's runs-on, "" if valid.
-func (j *Job) RunsOnProblem() string {
-	if j.RawRunsOn.Kind == 0 {
-		return ""
-	}
-	return runsOnProblem(&j.RawRunsOn)
-}
-
 // RunsOn returns the labels Gitea matches runners against, unescaped like DisplayName.
 func (j *Job) RunsOn() []string {
 	runsOn := model.RunsOnFromNode(j.RawRunsOn)

modules/actions/jobparser/validate.go

@@ -7,13 +7,10 @@ import (
 	"errors"
 	"fmt"
 	"slices"
-	"strings"
 
 	"gitea.dev/actionslib/pkg/expreval"
 	"gitea.dev/actionslib/pkg/exprparser"
 	"gitea.dev/actionslib/pkg/model"
-
-	"go.yaml.in/yaml/v4"
 )
 
 // jobConditionContexts are what github.com gives `jobs.<job_id>.if`, which it decides before the matrix, plus the `gitea` alias.
@@ -24,7 +21,7 @@ func ValidateWorkflowStatic(content []byte) ([]*Event, error) {
 	if err != nil {
 		return nil, err
 	}
-	// Keep unknown and case-distinct keys outside of jobs accepted for existing Gitea workflows.
+	// Keep unknown and case-distinct keys accepted for existing Gitea workflows.
 	workflow, err := readWorkflowDoc(doc)
 	if err != nil {
 		return nil, err
@@ -36,9 +33,6 @@ func ValidateWorkflowStatic(content []byte) ([]*Event, error) {
 	if err := validateWorkflowStructure(workflow); err != nil {
 		return nil, err
 	}
-	if err := validateJobKinds(doc); err != nil {
-		return nil, err
-	}
 	var header struct {
 		RunName string `yaml:"run-name"`
 	}
@@ -82,6 +76,7 @@ func validateWorkflowStructure(workflow *model.Workflow) error {
 		if job == nil {
 			return fmt.Errorf("job %q has no configuration", id)
 		}
+		// a job without runs-on is accepted and runs on any runner, github.com rejects it
 		for _, dependency := range job.Needs() {
 			if _, ok := workflow.Jobs[dependency]; !ok {
 				return fmt.Errorf("job %q needs unknown job %q", id, dependency)
@@ -115,116 +110,3 @@ func validateWorkflowStructure(workflow *model.Workflow) error {
 	}
 	return nil
 }
-
-// job keys of github.com's workflow schema, by the kind of job allowing them
-var (
-	stepsJobKeys  = []string{"cancel-timeout-minutes", "container", "continue-on-error", "defaults", "env", "environment", "outputs", "runs-on", "services", "snapshot", "steps", "timeout-minutes"}
-	callerJobKeys = []string{"secrets", "uses", "with"}
-	sharedJobKeys = []string{"concurrency", "if", "name", "needs", "permissions", "strategy"}
-)
-
-// validateJobKinds applies github.com's job kinds, decided by the first kind-specific key.
-func validateJobKinds(doc *yaml.Node) error {
-	jobs := mappingValue(doc.Content[0], "jobs")
-	for i := 0; i+1 < len(jobs.Content); i += 2 {
-		id, job := jobs.Content[i].Value, jobs.Content[i+1]
-		var required string
-		for j := 0; j+1 < len(job.Content); j += 2 {
-			key := job.Content[j].Value
-			isStepsKey, isCallerKey := slices.Contains(stepsJobKeys, key), slices.Contains(callerJobKeys, key)
-			switch {
-			case required == "runs-on" && isCallerKey, required == "uses" && isStepsKey, !isStepsKey && !isCallerKey && !slices.Contains(sharedJobKeys, key):
-				return fmt.Errorf("job %s: Unexpected value '%s'", id, key)
-			case required == "" && isStepsKey:
-				required = "runs-on"
-			case required == "" && isCallerKey:
-				required = "uses"
-			}
-		}
-		if required == "" {
-			keys := slices.Concat(stepsJobKeys, callerJobKeys)
-			slices.Sort(keys)
-			return fmt.Errorf("job %s: There's not enough info to determine what you meant. Add one of these properties: %s", id, strings.Join(keys, ", "))
-		}
-		value := mappingValue(job, required)
-		if value == nil {
-			return fmt.Errorf("job %s: Required property is missing: %s", id, required)
-		}
-		if required != "runs-on" {
-			continue
-		}
-		if problem := runsOnProblem(value); problem != "" {
-			return fmt.Errorf("job %s: runs-on: %s", id, problem)
-		}
-	}
-	return nil
-}
-
-// runsOnProblem returns github.com's schema error for a runs-on, "" if valid.
-func runsOnProblem(node *yaml.Node) string {
-	if node.Kind != yaml.MappingNode {
-		return runsOnLabelsProblem(node)
-	}
-	for i := 0; i+1 < len(node.Content); i += 2 {
-		var problem string
-		switch key := node.Content[i].Value; key {
-		case "labels":
-			problem = runsOnLabelsProblem(node.Content[i+1])
-		case "group":
-			problem = runsOnGroupProblem(node.Content[i+1])
-		default:
-			problem = fmt.Sprintf("Unexpected value '%s'", key)
-		}
-		if problem != "" {
-			return problem
-		}
-	}
-	return ""
-}
-
-func runsOnLabelsProblem(node *yaml.Node) string {
-	if node.Kind != yaml.SequenceNode {
-		return nonEmptyStringProblem(node)
-	}
-	for _, label := range node.Content {
-		if problem := nonEmptyStringProblem(label); problem != "" {
-			return problem
-		}
-	}
-	return ""
-}
-
-func runsOnGroupProblem(node *yaml.Node) string {
-	if problem := nonEmptyStringProblem(node); problem != "" || hasExpression(node.Value) {
-		return problem
-	}
-	switch prefix, name, found := strings.Cut(node.Value, "/"); {
-	case found && name == "":
-		return fmt.Sprintf("Invalid runs-on group name '%s'.", node.Value)
-	case found && (strings.Contains(name, "/") || !slices.Contains([]string{"org", "organization", "ent", "enterprise"}, prefix)):
-		return fmt.Sprintf("Invalid runs-on group name '%s'. Please use 'organization/' or 'enterprise/' prefix to target a single runner group.", node.Value)
-	}
-	return ""
-}
-
-// nonEmptyStringProblem mirrors github.com's non-empty-string, which also accepts non-string scalars.
-func nonEmptyStringProblem(node *yaml.Node) string {
-	switch {
-	case node.Kind == yaml.SequenceNode:
-		return "A sequence was not expected"
-	case node.Kind == yaml.MappingNode:
-		return "A mapping was not expected"
-	case node.Value == "" || node.ShortTag() == "!!null":
-		return "Unexpected value ''"
-	}
-	return ""
-}
-
-func mappingValue(node *yaml.Node, key string) *yaml.Node {
-	for i := 0; i+1 < len(node.Content); i += 2 {
-		if node.Content[i].Value == key {
-			return node.Content[i+1]
-		}
-	}
-	return nil
-}

modules/actions/workflows_test.go

@@ -30,23 +30,18 @@ jobs:
 
 func TestReadWorkflowEventsStaticErrors(t *testing.T) {
 	for content, static := range map[string]bool{
-		"on: push\njobs: {}": true,
-		"on: push\njobs: {test: {runs-on: x, needs: absent}}":                                             true,
-		"on: push\njobs: {one: {runs-on: x, needs: two}, two: {runs-on: x, needs: one}}":                  true,
-		"on: push\njobs: {test: {runs-on: x, strategy: {matrix: {os: []}}}}":                              true,
-		"on: push\nrun-name: ${{ secrets.TOKEN }}\njobs: {test: {runs-on: x}}":                            true,
-		"on: push\njobs: {test: {steps: [{run: echo}]}}":                                                  true,
-		"on: push\nrun-name: ${{ fromJSON(inputs.x) }}\njobs: {test: {runs-on: x, steps: [{run: echo}]}}": false,
+		"on: push\njobs: {}":                                                                  true,
+		"on: push\njobs: {test: {needs: absent}}":                                             true,
+		"on: push\njobs: {one: {needs: two}, two: {needs: one}}":                              true,
+		"on: push\njobs: {test: {strategy: {matrix: {os: []}}}}":                              true,
+		"on: push\nrun-name: ${{ secrets.TOKEN }}\njobs: {test: {}}":                          true,
+		"on: push\nrun-name: ${{ fromJSON(inputs.x) }}\njobs: {test: {steps: [{run: echo}]}}": false,
 	} {
 		_, gotStatic, err := readWorkflowEvents([]byte(content))
 		require.Error(t, err, content)
 		assert.Equal(t, static, gotStatic, content)
 	}
-	for _, content := range []string{
-		"on: push\njobs: {test: {runs-on: x, steps: [{run: echo}]}}",
-		"on: push\nrun-name: ${{ github.ref }}\njobs: {test: {runs-on: x}}",
-		"on: push\njobs: {call: {uses: ./.gitea/workflows/called.yml}}",
-	} {
+	for _, content := range []string{"on: push\njobs: {test: {steps: [{run: echo}]}}", "on: push\nrun-name: ${{ github.ref }}\njobs: {test: {}}"} {
 		_, _, err := readWorkflowEvents([]byte(content))
 		assert.NoError(t, err, content)
 	}

modules/git/repo_base_gogit.go

@@ -20,7 +20,6 @@ import (
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/storage/filesystem"
-	"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
 )
 
 const isGogit = true
@@ -32,8 +31,8 @@ type Repository struct {
 	gogitStorage *reindexingStorage
 }
 
-// reindexingStorage reloads the pack index when git added or removed packs after go-git loaded it
-// https://github.com/go-git/go-git/issues/2439 https://github.com/go-git/go-git/issues/1623
+// reindexingStorage picks up packs that git wrote after go-git loaded its index
+// https://github.com/go-git/go-git/issues/2439
 type reindexingStorage struct {
 	*filesystem.Storage
 	packs []plumbing.Hash
@@ -41,7 +40,7 @@ type reindexingStorage struct {
 
 func (s *reindexingStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
 	obj, err := s.Storage.EncodedObject(t, h)
-	if !errors.Is(err, plumbing.ErrObjectNotFound) && !errors.Is(err, dotgit.ErrPackfileNotFound) {
+	if !errors.Is(err, plumbing.ErrObjectNotFound) {
 		return obj, err
 	}
 	packs, _ := s.ObjectPacks()

modules/git/repo_branch_test.go

@@ -7,8 +7,6 @@ import (
 	"path/filepath"
 	"testing"
 
-	"gitea.dev/modules/git/gitcmd"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -41,26 +39,6 @@ func TestRepository_GetBranches(t *testing.T) {
 	assert.ElementsMatch(t, []string{}, branches)
 }
 
-func TestGetBranchNamesAfterRepack(t *testing.T) {
-	repoDir := t.TempDir()
-	require.NoError(t, gitcmd.NewCommand("init", "--bare").AddDynamicArguments(repoDir).Run(t.Context()))
-	for _, from := range []string{"", "from refs/heads/main^0\n"} {
-		stdin := "commit refs/heads/main\ncommitter a <a@a> 0 +0000\ndata 0\n" + from
-		require.NoError(t, gitcmd.NewCommand("fast-import").WithDir(repoDir).WithStdinBytes([]byte(stdin)).Run(t.Context()))
-		require.NoError(t, gitcmd.NewCommand("repack", "-d").WithDir(repoDir).Run(t.Context()))
-	}
-
-	repo, err := OpenRepositoryLocal(t.Context(), repoDir)
-	require.NoError(t, err)
-	defer repo.Close()
-	require.False(t, repo.IsObjectExist(t.Context(), "0000000000000000000000000000000000000001"))
-	require.NoError(t, gitcmd.NewCommand("repack", "-a", "-d").WithDir(repoDir).Run(t.Context()))
-
-	branches, _, err := repo.GetBranchNames(t.Context(), 0, 0)
-	require.NoError(t, err)
-	assert.Equal(t, []string{"main"}, branches)
-}
-
 func BenchmarkRepository_GetBranches(b *testing.B) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := OpenRepositoryLocal(b.Context(), bareRepo1Path)

options/locale/locale_en-US.json

@@ -433,7 +433,6 @@
   "auth.authorize_application_created_by": "This application was created by %s.",
   "auth.authorize_application_description": "If you grant access, it will be able to access and write to all your account information, including private repos and organizations.",
   "auth.authorize_application_with_scopes": "With scopes: %s",
-  "auth.authorize_application_new_scopes": "New scopes: %s",
   "auth.authorize_title": "Authorize \"%s\" to access your account?",
   "auth.authorization_failed": "Authorization failed",
   "auth.authorization_failed_desc": "The authorization failed because we detected an invalid request. Please contact the maintainer of the app you tried to authorize.",

options/locale/locale_zh-CN.json

@@ -277,10 +277,7 @@
   "install.domain_helper": "服务器的域名或主机地址。",
   "install.ssh_port": "SSH 服务端口",
   "install.ssh_port_helper": "SSH 服务器的端口号，为空则禁用它。",
-  "install.http_port": "HTTP 服务端口",
   "install.http_port_helper": "Gitea Web 服务器将侦听的端口号。",
-  "install.app_url": "Gitea 网站 URL",
-  "install.app_url_helper": "Gitea Web 应用程序用于 HTTP(S) 访问、克隆 URL 及电子邮件通知的公共 URL。",
   "install.optional_title": "可选设置",
   "install.email_title": "电子邮箱设置",
   "install.smtp_addr": "SMTP 主机地址",
@@ -293,11 +290,8 @@
   "install.register_confirm": "需要邮件确认注册",
   "install.mail_notify": "启用邮件通知提醒",
   "install.server_service_title": "服务器和第三方服务设置",
-  "install.disable_registration": "只有管理员可以创建用户帐户（禁止自助注册）",
   "install.enable_captcha": "启用注册验证码",
   "install.enable_captcha_popup": "要求在用户注册时输入预验证码",
-  "install.require_sign_in_view": "需要登录才能查看页面（推荐用于私有实例）",
-  "install.require_sign_in_view_popup": "仅允许已登录用户访问页面。访客只能看到注册和登录页。",
   "install.admin_setting_desc": "创建管理员帐户是可选的。第一个注册用户将自动成为管理员。",
   "install.admin_title": "管理员帐号设置",
   "install.admin_name": "管理员用户名",
@@ -320,7 +314,6 @@
   "install.default_allow_create_organization_popup": "默认情况下，允许新用户帐户创建组织。",
   "install.no_reply_address": "隐藏邮件域",
   "install.no_reply_address_helper": "具有隐藏邮箱地址的用户的域名。例如，如果隐藏邮箱域名设置为「noreply.example.org」，那么用户名「joe」在 Git 中将显示为「joe@noreply.example.org」。",
-  "install.enable_update_checker": "启用更新检查",
   "install.env_config_keys": "环境配置",
   "install.env_config_keys_prompt": "以下环境变量也将应用于您的配置文件：",
   "install.config_write_file_prompt": "这些配置选项将写入以下位置: %s",
@@ -1098,7 +1091,6 @@
   "repo.migrate.github_token_desc": "您可以在此处输入一个或多个令牌（以逗号分隔），以绕过 GitHub API 速率限制来加快迁移速度。警告：滥用此功能可能会违反服务提供商的政策并导致帐户被封禁。",
   "repo.migrate.clone_local_path": "或服务器本地路径",
   "repo.migrate.permission_denied": "您没有获得导入本地仓库的权限。",
-  "repo.migrate.permission_denied_blocked": "您不能从不允许的主机导入。请询问管理员以检查 [migrations] 部分中的ALLOWED_HOST_LIST/BLOCKED_HOST_LIST 设置。",
   "repo.migrate.invalid_local_path": "本地路径无效。它不存在或不是一个目录。",
   "repo.migrate.invalid_lfs_endpoint": "LFS 网址无效。",
   "repo.migrate.failed": "迁移失败：%v",
@@ -3904,11 +3896,6 @@
   "actions.workflow.has_no_workflow_dispatch": "工作流「%s」没有 workflow_dispatch 事件触发器。",
   "actions.need_approval_desc": "该工作流由派生仓库的合并请求所触发，需要批准方可运行。",
   "actions.approve_all_success": "所有工作流运行已成功批准。",
-  "actions.job_queue.title": "任务队列",
-  "actions.job_queue.runs_on": "运行于",
-  "actions.job_queue.waiting_or_started": "等待 / 已开始",
-  "actions.job_queue.no_jobs": "没有正在运行或等待处理的任务。",
-  "actions.job_queue.filter_owner_no_select": "所有所有者",
   "actions.job_queue.filter_repo_no_select": "所有仓库",
   "actions.variables": "变量",
   "actions.variables.management": "变量管理",

routers/api/v1/admin/user.go

@@ -400,7 +400,7 @@ func SearchUsers(ctx *context.APIContext) {
 	// parameters:
 	// - name: source_id
 	//   in: query
-	//   description: ID of the user's login source to search for, 0 means the local users
+	//   description: ID of the user's login source to search for
 	//   type: integer
 	//   format: int64
 	// - name: login_name
@@ -483,7 +483,7 @@ func SearchUsers(ctx *context.APIContext) {
 		Actor:         ctx.Doer,
 		Types:         []user_model.UserType{user_model.UserTypeIndividual},
 		LoginName:     ctx.FormTrim("login_name"),
-		SourceID:      ctx.FormOptionalInt64("source_id"),
+		SourceID:      ctx.FormInt64("source_id"),
 		Keyword:       ctx.FormTrim("q"),
 		Visible:       visible,
 		OrderBy:       orderBy,

routers/web/admin/users.go

@@ -48,13 +48,6 @@ const (
 // UserSearchDefaultAdminSort is the default sort type for admin view
 const UserSearchDefaultAdminSort = "alphabetically"
 
-// authSourceFilterOption is one radio item of the authentication source filter dropdown
-type authSourceFilterOption struct {
-	Value    string
-	Label    string
-	Selected bool
-}
-
 // Users show all the users
 func Users(ctx *context.Context) {
 	ctx.Data["Title"] = ctx.Tr("admin.users")
@@ -83,30 +76,6 @@ func Users(ctx *context.Context) {
 		"SortType":        sortType,
 	}
 
-	// inactive sources are listed too, users stay attached to a source after it is deactivated
-	sources, err := db.Find[auth.Source](ctx, auth.FindSourcesOptions{})
-	if err != nil {
-		ctx.ServerError("auth.Sources", err)
-		return
-	}
-	sourceIDFilter := ctx.FormOptionalInt64("source_id")
-	sourceNames := make(map[int64]string, len(sources))
-	authSourceFilterOptions := []*authSourceFilterOption{
-		{Value: "", Label: ctx.Locale.TrString("all"), Selected: !sourceIDFilter.Has()},
-		{Value: "0", Label: ctx.Locale.TrString("admin.users.local"), Selected: sourceIDFilter.Has() && sourceIDFilter.Value() == 0},
-	}
-	for _, source := range sources {
-		sourceNames[source.ID] = source.Name
-		authSourceFilterOptions = append(authSourceFilterOptions, &authSourceFilterOption{
-			Value:    strconv.FormatInt(source.ID, 10),
-			Label:    source.Name,
-			Selected: sourceIDFilter.Has() && sourceIDFilter.Value() == source.ID,
-		})
-	}
-	ctx.Data["HasAuthSources"] = len(sources) > 0
-	ctx.Data["SourceNames"] = sourceNames
-	ctx.Data["AuthSourceFilterOptions"] = authSourceFilterOptions
-
 	explore.RenderUserSearch(ctx, user_model.SearchUserOptions{
 		Actor: ctx.Doer,
 		Types: types,
@@ -119,7 +88,6 @@ func Users(ctx *context.Context) {
 		IsRestricted:       optional.ParseBool(statusFilterMap["is_restricted"]),
 		IsTwoFactorEnabled: optional.ParseBool(statusFilterMap["is_2fa_enabled"]),
 		IsProhibitLogin:    optional.ParseBool(statusFilterMap["is_prohibit_login"]),
-		SourceID:           sourceIDFilter,
 		OrderBy:            db.SearchOrderBy(sortType),
 	}, tplUsers)
 }

routers/web/auth/oauth2_provider.go

@@ -11,7 +11,6 @@ import (
 	"net/http"
 	"net/url"
 	"strconv"
-	"strings"
 
 	audit_model "gitea.dev/models/audit"
 	"gitea.dev/models/auth"
@@ -21,7 +20,6 @@ import (
 	"gitea.dev/modules/log"
 	"gitea.dev/modules/setting"
 	"gitea.dev/modules/templates"
-	"gitea.dev/modules/util"
 	"gitea.dev/modules/web"
 	"gitea.dev/services/audit"
 	auth_service "gitea.dev/services/auth"
@@ -323,18 +321,9 @@ func AuthorizeOAuth(ctx *context.Context) {
 		return
 	}
 
-	var addedScopes, removedScopes []string
-	if grant != nil {
-		if form.Scope == "" {
-			form.Scope = grant.Scope
-		}
-		addedScopes, removedScopes = util.DiffSlice(strings.Fields(grant.Scope), strings.Fields(form.Scope))
-	}
-	scopeChanged := len(addedScopes) > 0 || len(removedScopes) > 0
-
 	// Redirect if user already granted access and the application is confidential or trusted otherwise
 	// I.e. always require authorization for untrusted public clients as recommended by RFC 6749 Section 10.2
-	if (app.ConfidentialClient || app.SkipSecondaryAuthorization) && grant != nil && !scopeChanged {
+	if (app.ConfidentialClient || app.SkipSecondaryAuthorization) && grant != nil {
 		code, err := grant.GenerateNewAuthorizationCode(ctx, form.RedirectURI, form.CodeChallenge, form.CodeChallengeMethod)
 		if err != nil {
 			handleServerError(ctx, form.State, form.RedirectURI)
@@ -358,7 +347,6 @@ func AuthorizeOAuth(ctx *context.Context) {
 
 	// check if additional scopes
 	ctx.Data["AdditionalScopes"] = oauth2_provider.GrantAdditionalScopes(form.Scope) != auth.AccessTokenScopeAll
-	ctx.Data["AddedScopes"] = addedScopes
 
 	// show authorize page to grant access
 	ctx.Data["Application"] = app
@@ -444,10 +432,12 @@ func GrantApplicationOAuth(ctx *context.Context) {
 
 		audit.Record(ctx, audit_model.UserOAuth2ApplicationGrant, ctx.Doer, "oauth2_application", app.Name, "granted_scope", form.Scope)
 	} else if grant.Scope != form.Scope {
-		if err := auth.UpdateGrantScope(ctx, grant, form.Scope); err != nil {
-			handleServerError(ctx, form.State, form.RedirectURI)
-			return
-		}
+		handleAuthorizeError(ctx, AuthorizeError{
+			State:            form.State,
+			ErrorDescription: "a grant exists with different scope",
+			ErrorCode:        ErrorCodeServerError,
+		}, form.RedirectURI)
+		return
 	}
 
 	if len(form.Nonce) > 0 {

routers/web/auth/oauth_test.go

@@ -13,10 +13,6 @@ import (
 	"gitea.dev/models/unittest"
 	user_model "gitea.dev/models/user"
 	"gitea.dev/modules/egress/policy"
-	"gitea.dev/modules/session"
-	"gitea.dev/modules/web"
-	"gitea.dev/services/contexttest"
-	"gitea.dev/services/forms"
 	"gitea.dev/services/oauth2_provider"
 
 	"github.com/golang-jwt/jwt/v5"
@@ -109,27 +105,3 @@ func TestOAuth2AvatarClientBlocksCloudMetadata(t *testing.T) {
 	assert.ErrorIs(t, err, policy.ErrDenied,
 		"avatar client must refuse a link-local cloud-metadata address")
 }
-
-func TestOAuth2ScopeChange(t *testing.T) {
-	require.NoError(t, unittest.PrepareTestDatabase())
-	app := unittest.AssertExistsAndLoadBean(t, &auth.OAuth2Application{ID: 1})
-	doer := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
-	mockOpt := contexttest.MockContextOption{SessionStore: session.NewMockMemStore("oauth2-scope-change")}
-	authorize := func(scope string) int {
-		ctx, resp := contexttest.MockContext(t, "/login/oauth/authorize", mockOpt)
-		ctx.Doer = doer
-		web.SetForm(ctx, &forms.AuthorizationForm{ResponseType: "code", ClientID: app.ClientID, RedirectURI: app.RedirectURIs[0], State: "state", Scope: scope})
-		AuthorizeOAuth(ctx)
-		return resp.Code
-	}
-	assert.Equal(t, http.StatusSeeOther, authorize(""))
-	assert.Equal(t, http.StatusSeeOther, authorize("profile openid"))
-	assert.Equal(t, http.StatusOK, authorize("openid profile email"))
-
-	ctx, resp := contexttest.MockContext(t, "/login/oauth/grant", mockOpt)
-	ctx.Doer = doer
-	web.SetForm(ctx, &forms.GrantApplicationForm{ClientID: app.ClientID, Granted: true, RedirectURI: app.RedirectURIs[0], State: "state", Scope: "openid profile email"})
-	GrantApplicationOAuth(ctx)
-	assert.Equal(t, http.StatusSeeOther, resp.Code)
-	unittest.AssertExistsAndLoadBean(t, &auth.OAuth2Grant{ID: 1, Scope: "openid profile email"})
-}

routers/web/repo/actions/actions.go

@@ -569,7 +569,7 @@ func (data *actionRunListData) processActionRuns(ctx *context.Context) bool {
 					break
 				}
 			}
-			if job.Status.IsWaiting() && !job.IsReusableCaller {
+			if job.Status.IsWaiting() {
 				hasOnlineRunner := false
 				for _, runner := range runners {
 					if !runner.IsDisabled && runner.CanMatchLabels(job.RunsOn) {

routers/web/repo/actions/view.go

@@ -773,7 +773,7 @@ func describePendingJobDetail(ctx *context_module.Context, current *actions_mode
 		if pending := pendingNeeds(current, jobs); len(pending) > 0 {
 			return ctx.Locale.TrString("actions.runs.waiting_for_dependent_jobs", strings.Join(pending, ", "))
 		}
-	case current.Status.IsWaiting() && !current.IsReusableCaller: // a caller waits on its called jobs, never on a runner
+	case current.Status.IsWaiting():
 		// A waiting job has no runner to pick it up yet. A busy runner is still
 		// "online", so distinguish three cases: no runner online at all, online
 		// runners but none match the labels, and a matching runner that is busy.

services/actions/approve.go

@@ -15,7 +15,6 @@ import (
 	user_model "gitea.dev/models/user"
 	"gitea.dev/modules/container"
 	"gitea.dev/modules/log"
-	"gitea.dev/modules/timeutil"
 	"gitea.dev/modules/util"
 
 	"xorm.io/builder"
@@ -100,20 +99,6 @@ func ApproveRuns(ctx context.Context, repo *repo_model.Repository, doer *user_mo
 				if !slots.available(job) {
 					continue
 				}
-				if invalid := invalidRunsOn(job); invalid != nil {
-					job.Status, job.Stopped = actions_model.StatusFailure, timeutil.TimeStampNow()
-					n, err := actions_model.UpdateRunJob(ctx, job, nil, "status", "stopped")
-					if err != nil {
-						return err
-					}
-					if n > 0 {
-						updatedJobs = append(updatedJobs, job)
-					}
-					if err := upsertJobErrorSummary(ctx, job, "runs-on", invalid); err != nil {
-						return err
-					}
-					continue
-				}
 				var jobsToCancel []*actions_model.ActionRunJob
 				job.Status, jobsToCancel, err = PrepareToStartJobWithConcurrency(ctx, job)
 				if err != nil {

services/actions/context_test.go

@@ -98,7 +98,7 @@ jobs:
 	assert.NotEmpty(t, persisted.RawConcurrency)
 }
 
-func TestPrepareRunAndInsert_JobIfAndRunsOn(t *testing.T) {
+func TestPrepareRunAndInsert_JobIf(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	defer test.MockVariableValue(&EmitJobsIfReadyByRun, func(int64) error { return nil })()
 
@@ -123,10 +123,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - run: echo
-  unset-runs-on:
-    runs-on: ${{ vars.UNSET }}
-    steps:
-      - run: echo
 `, false)
 
 	jobs := map[string]*actions_model.ActionRunJob{}
@@ -138,12 +134,9 @@ jobs:
 	assert.False(t, jobs["skip"].IsConcurrencyEvaluated)
 	assert.Equal(t, actions_model.StatusSkipped, jobs["skip-caller"].Status)
 	assert.Equal(t, actions_model.StatusSkipped, jobs["invalid"].Status)
-	assert.Equal(t, actions_model.StatusFailure, jobs["unset-runs-on"].Status)
-	for id, key := range map[string]string{"invalid": "if", "unset-runs-on": "runs-on"} {
-		summary, err := actions_model.GetActionRunJobSummary(t.Context(), run.RepoID, run.ID, run.LatestAttemptID, jobs[id].ID, 0)
-		require.NoError(t, err)
-		assert.Contains(t, summary.Content, "Error when evaluating `"+key+"` for job `"+id+"`")
-	}
+	summary, err := actions_model.GetActionRunJobSummary(t.Context(), run.RepoID, run.ID, run.LatestAttemptID, jobs["invalid"].ID, 0)
+	require.NoError(t, err)
+	assert.Contains(t, summary.Content, "Error when evaluating `if` for job `invalid`")
 }
 
 func TestComputeReusableCallerOutputs(t *testing.T) {

services/actions/helper.go

@@ -183,18 +183,6 @@ func upsertJobErrorSummary(ctx context.Context, job *actions_model.ActionRunJob,
 	return actions_model.UpsertActionRunJobSummary(ctx, job.RepoID, job.RunID, job.RunAttemptID, job.ID, 0, actions_model.JobSummaryContentTypeMarkdown, []byte(content))
 }
 
-// invalidRunsOn returns github.com's error for the job's evaluated runs-on.
-func invalidRunsOn(job *actions_model.ActionRunJob) error {
-	parsed, err := job.ParseJob()
-	if err != nil {
-		return err
-	}
-	if problem := parsed.RunsOnProblem(); problem != "" {
-		return errors.New(problem)
-	}
-	return nil
-}
-
 func findJobNeedsAndFillJobResults(ctx context.Context, job *actions_model.ActionRunJob) (map[string]*jobparser.JobResult, error) {
 	taskNeeds, jobsByID, err := FindTaskNeeds(ctx, job)
 	if err != nil {

services/actions/invalid_workflow.go

@@ -32,46 +32,40 @@ func handleInvalidWorkflows(ctx context.Context, input *notifyInput, ref git.Ref
 		if actionsConfig.IsWorkflowDisabled(entryName) {
 			continue
 		}
-		insertInvalidWorkflowRun(ctx, &actions_model.ActionRun{
-			Title: commit.MessageTitle(), RepoID: input.Repo.ID, Repo: input.Repo, OwnerID: input.Repo.OwnerID,
+		now := timeutil.TimeStampNow()
+		run := &actions_model.ActionRun{
+			Title: util.EllipsisDisplayString(commit.MessageTitle(), 255), RepoID: input.Repo.ID, Repo: input.Repo, OwnerID: input.Repo.OwnerID,
 			WorkflowID: entryName, TriggerUserID: input.Doer.ID, TriggerUser: input.Doer, Ref: ref.String(),
 			CommitSHA: commit.ID.String(), Event: input.Event, TriggerEvent: string(input.Event), EventPayload: string(payload),
-			WorkflowRepoID: input.Repo.ID, WorkflowCommitSHA: commit.ID.String(),
-		}, parseErr)
+			WorkflowRepoID: input.Repo.ID, WorkflowCommitSHA: commit.ID.String(), Status: actions_model.StatusFailure, Started: now, Stopped: now,
+		}
+		if err := db.WithTx(ctx, func(ctx context.Context) error {
+			if run.Index, err = db.GetNextResourceIndex(ctx, "action_run_index", run.RepoID); err != nil {
+				return err
+			}
+			if err := db.Insert(ctx, run); err != nil {
+				return err
+			}
+			attempt := &actions_model.ActionRunAttempt{RepoID: run.RepoID, RunID: run.ID, Attempt: 1, TriggerUserID: run.TriggerUserID, Status: run.Status, Started: now, Stopped: now}
+			if err := db.Insert(ctx, attempt); err != nil {
+				return err
+			}
+			run.LatestAttemptID = attempt.ID
+			if err := actions_model.UpdateRun(ctx, run, "latest_attempt_id"); err != nil {
+				return err
+			}
+			content := fmt.Sprintf("**Invalid workflow file: %s**\n\n```\n%v\n```\n", entryName, parseErr)
+			return db.Insert(ctx, &actions_model.ActionRunJobSummary{
+				RepoID: run.RepoID, RunID: run.ID, RunAttemptID: attempt.ID, Content: content, ContentSize: int64(len(content)), ContentType: actions_model.JobSummaryContentTypeMarkdown,
+			})
+		}); err != nil {
+			log.Error("insert run for invalid workflow %q: %v", entryName, err)
+			continue
+		}
+		if err := createWorkflowCommitStatus(ctx, run.Repo, run.CommitSHA, entryName+" ("+run.TriggerEvent+")", run.WorkflowID,
+			commitstatus.CommitStatusFailure, run.Link(), "Invalid workflow file", false); err != nil {
+			log.Error("create commit status for invalid workflow %q: %v", entryName, err)
+		}
+		NotifyWorkflowRunStatusUpdate(ctx, run)
 	}
 }
-
-// insertInvalidWorkflowRun records run as failed with parseErr as its summary.
-func insertInvalidWorkflowRun(ctx context.Context, run *actions_model.ActionRun, parseErr error) {
-	now := timeutil.TimeStampNow()
-	run.Title = util.EllipsisDisplayString(run.Title, 255)
-	run.Status, run.Started, run.Stopped = actions_model.StatusFailure, now, now
-	if err := db.WithTx(ctx, func(ctx context.Context) (err error) {
-		if run.Index, err = db.GetNextResourceIndex(ctx, "action_run_index", run.RepoID); err != nil {
-			return err
-		}
-		if err := db.Insert(ctx, run); err != nil {
-			return err
-		}
-		attempt := &actions_model.ActionRunAttempt{RepoID: run.RepoID, RunID: run.ID, Attempt: 1, TriggerUserID: run.TriggerUserID, Status: run.Status, Started: now, Stopped: now}
-		if err := db.Insert(ctx, attempt); err != nil {
-			return err
-		}
-		run.LatestAttemptID = attempt.ID
-		if err := actions_model.UpdateRun(ctx, run, "latest_attempt_id"); err != nil {
-			return err
-		}
-		content := fmt.Sprintf("**Invalid workflow file: %s**\n\n```\n%v\n```\n", run.WorkflowID, parseErr)
-		return db.Insert(ctx, &actions_model.ActionRunJobSummary{
-			RepoID: run.RepoID, RunID: run.ID, RunAttemptID: attempt.ID, Content: content, ContentSize: int64(len(content)), ContentType: actions_model.JobSummaryContentTypeMarkdown,
-		})
-	}); err != nil {
-		log.Error("insert run for invalid workflow %q: %v", run.WorkflowID, err)
-		return
-	}
-	if err := createWorkflowCommitStatus(ctx, run.Repo, run.CommitSHA, run.WorkflowID+" ("+run.TriggerEvent+")", run.WorkflowID,
-		commitstatus.CommitStatusFailure, run.Link(), "Invalid workflow file", false); err != nil {
-		log.Error("create commit status for invalid workflow %q: %v", run.WorkflowID, err)
-	}
-	NotifyWorkflowRunStatusUpdate(ctx, run)
-}

services/actions/job_emitter.go

@@ -590,14 +590,6 @@ func (r *jobStatusResolver) resolve(ctx context.Context) (map[int64]actions_mode
 			continue
 		}
 
-		if err := invalidRunsOn(actionRunJob); err != nil {
-			if err := upsertJobErrorSummary(ctx, actionRunJob, "runs-on", err); err != nil {
-				return nil, err
-			}
-			ret[id] = actions_model.StatusFailure
-			continue
-		}
-
 		// update concurrency and check whether the job can run now
 		if err := updateConcurrencyEvaluationForJobWithNeeds(ctx, actionRunJob, r.vars); errors.Is(err, util.ErrInvalidArgument) {
 			if err := upsertJobErrorSummary(ctx, actionRunJob, "concurrency", err); err != nil {

services/actions/job_emitter_test.go

@@ -173,15 +173,6 @@ jobs:
 			want: map[int64]actions_model.Status{2: actions_model.StatusFailure},
 			note: "Error when evaluating `concurrency` for job `job2`.",
 		},
-		{
-			name: "invalid evaluated `runs-on` fails the job with an annotation",
-			jobs: actions_model.ActionJobList{
-				{ID: 1, RepoID: 1, JobID: "job1", Status: actions_model.StatusSuccess},
-				{ID: 2, RepoID: 1, JobID: "job2", Status: actions_model.StatusBlocked, Needs: []string{"job1"}, WorkflowPayload: []byte("jobs: {job2: {runs-on: ''}}")},
-			},
-			want: map[int64]actions_model.Status{2: actions_model.StatusFailure},
-			note: "Error when evaluating `runs-on` for job `job2`.",
-		},
 		{
 			name: "max-parallel: a freed slot promotes the lowest blocked job id",
 			jobs: actions_model.ActionJobList{

services/actions/notifier_helper.go

@@ -394,14 +394,6 @@ func buildApproveAndInsertRun(
 		IsScopedRun:       isScopedRun,
 	}
 
-	if err := validateCalledWorkflows(ctx, run, dwf.Content); err != nil {
-		if isScopedRun {
-			return err
-		}
-		insertInvalidWorkflowRun(ctx, run, err)
-		return nil
-	}
-
 	approvalUsers, err := getApprovalUsers(ctx, input, isForkPullRequest)
 	if err != nil {
 		return err

services/actions/reusable_workflow.go

@@ -7,8 +7,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"maps"
-	"slices"
 	"strings"
 
 	"gitea.dev/actionslib/pkg/model"
@@ -99,50 +97,6 @@ func loadReusableWorkflowSource(ctx context.Context, run *actions_model.ActionRu
 	}
 }
 
-// validateCalledWorkflows validates all workflows content calls, recursively.
-func validateCalledWorkflows(ctx context.Context, run *actions_model.ActionRun, content []byte) error {
-	validated := make(container.Set[string])
-	var validate func(content []byte, source *actions_model.ActionRunJob, level int) error
-	validate = func(content []byte, source *actions_model.ActionRunJob, level int) error {
-		workflow, err := jobparser.ReadWorkflow(content)
-		if err != nil {
-			return err
-		}
-		for _, id := range slices.Sorted(maps.Keys(workflow.Jobs)) {
-			uses := workflow.Jobs[id].Uses
-			if uses == "" {
-				continue
-			}
-			if level > MaxReusableCallLevels {
-				return errCallLevelExceeded(uses)
-			}
-			if !validated.Add(fmt.Sprintf("%d@%s:%s", source.WorkflowSourceRepoID, source.WorkflowSourceCommitSHA, uses)) {
-				continue
-			}
-			ref, err := ResolveUses(ctx, uses)
-			if err != nil {
-				return fmt.Errorf("job %s: %w", id, err)
-			}
-			called, repoID, commitSHA, err := loadReusableWorkflowSource(ctx, run, source, ref)
-			if err != nil {
-				return fmt.Errorf("job %s: %w", id, err)
-			}
-			if _, err = jobparser.ValidateWorkflowStatic(called); err == nil {
-				err = validate(called, &actions_model.ActionRunJob{WorkflowSourceRepoID: repoID, WorkflowSourceCommitSHA: commitSHA}, level+1)
-			}
-			if err != nil {
-				return fmt.Errorf("job %s: Error from called workflow %s: %w", id, uses, err)
-			}
-		}
-		return nil
-	}
-	return validate(content, &actions_model.ActionRunJob{WorkflowSourceRepoID: run.WorkflowRepoID, WorkflowSourceCommitSHA: run.WorkflowCommitSHA}, 0)
-}
-
-func errCallLevelExceeded(uses string) error {
-	return fmt.Errorf("reusable workflow call exceeds the maximum nesting level of %d at %q", MaxReusableCallLevels, uses)
-}
-
 // resolveSameRepoWorkflowSourceCommit returns the commit to read a same-repo reusable workflow from.
 // pull_request_target runs must resolve local `uses:` at the PR base commit, not a stored head SHA.
 func resolveSameRepoWorkflowSourceCommit(run *actions_model.ActionRun, caller *actions_model.ActionRunJob) string {
@@ -195,7 +149,7 @@ func checkCallerChain(ctx context.Context, caller *actions_model.ActionRunJob) e
 		current = next
 		depth++
 		if depth > MaxReusableCallLevels {
-			return errCallLevelExceeded(caller.CallUses)
+			return fmt.Errorf("reusable workflow call exceeds the maximum nesting level of %d at %q", MaxReusableCallLevels, caller.CallUses)
 		}
 		if current.IsReusableCaller && current.CallUses != "" && !visited.Add(canonicalCallUses(current)) {
 			return fmt.Errorf("reusable workflow call cycle detected: %q", current.CallUses)
@@ -271,9 +225,6 @@ func expandReusableWorkflowCaller(ctx context.Context, run *actions_model.Action
 	if err := checkResolvedCallerCycle(ctx, caller, contentSourceRepoID, contentSourceCommitSHA, ref.Path); err != nil {
 		return err
 	}
-	if _, err := jobparser.ValidateWorkflowStatic(content); err != nil {
-		return fmt.Errorf("invalid called workflow: %w", err)
-	}
 
 	// 4. Parse the called workflow's spec (used by both secret validation and input evaluation).
 	wcSpec, err := jobparser.ParseWorkflowCallConfig(content)

services/actions/run.go

@@ -5,7 +5,6 @@ package actions
 
 import (
 	"context"
-	"errors"
 	"fmt"
 
 	act_model "gitea.dev/actionslib/pkg/model"
@@ -13,7 +12,6 @@ import (
 	"gitea.dev/models/db"
 	"gitea.dev/modules/actions/jobparser"
 	"gitea.dev/modules/log"
-	"gitea.dev/modules/timeutil"
 	"gitea.dev/modules/util"
 
 	"go.yaml.in/yaml/v4"
@@ -187,7 +185,6 @@ func insertRunJob(ctx context.Context, run *actions_model.ActionRun, runAttempt
 	id, job := workflowJob.Job()
 	needs := job.Needs()
 	isMatrixDeferred := jobparser.HasDeferredMatrix(job)
-	runsOnProblem := job.RunsOnProblem() // SetJob's encoding drops the node's null tag
 	if err := workflowJob.SetJob(id, job.EraseNeeds()); err != nil {
 		return nil, nil, false, err
 	}
@@ -241,15 +238,10 @@ func insertRunJob(ctx context.Context, run *actions_model.ActionRun, runAttempt
 	}
 
 	// a skipped job must neither cancel its group peers nor take a slot
-	invalidErr, err := decideJobIf(ctx, run, runAttempt, runJob, vars)
+	invalidIf, err := decideJobIf(ctx, run, runAttempt, runJob, vars)
 	if err != nil {
 		return nil, nil, false, fmt.Errorf("evaluate job if: %w", err)
 	}
-	invalidKey := "if"
-	if runsOnProblem != "" && runJob.Status.IsWaiting() && slots.available(runJob) {
-		invalidKey, invalidErr = "runs-on", errors.New(runsOnProblem)
-		runJob.Status, runJob.Stopped = actions_model.StatusFailure, timeutil.TimeStampNow()
-	}
 
 	var cancelledConcurrencyJobs []*actions_model.ActionRunJob
 	// check job concurrency
@@ -283,8 +275,8 @@ func insertRunJob(ctx context.Context, run *actions_model.ActionRun, runAttempt
 	if err := db.Insert(ctx, runJob); err != nil {
 		return nil, nil, false, err
 	}
-	if invalidErr != nil {
-		if err := upsertJobErrorSummary(ctx, runJob, invalidKey, invalidErr); err != nil {
+	if invalidIf != nil {
+		if err := upsertJobErrorSummary(ctx, runJob, "if", invalidIf); err != nil {
 			return nil, nil, false, err
 		}
 	}
@@ -295,8 +287,8 @@ func insertRunJob(ctx context.Context, run *actions_model.ActionRun, runAttempt
 		}
 	}
 
-	// the emitter resolves an expanded caller's children and a skipped or failed job's dependents
-	return runJob, cancelledConcurrencyJobs, runJob.IsExpanded || runJob.Status.In(actions_model.StatusSkipped, actions_model.StatusFailure), nil
+	// the emitter resolves an expanded caller's children and a skipped job's dependents
+	return runJob, cancelledConcurrencyJobs, runJob.IsExpanded || runJob.Status == actions_model.StatusSkipped, nil
 }
 
 func expandInlineReusableCaller(ctx context.Context, run *actions_model.ActionRun, runAttempt *actions_model.ActionRunAttempt, caller *actions_model.ActionRunJob, vars map[string]string) error {

services/actions/schedule_tasks.go

@@ -17,7 +17,6 @@ import (
 	repo_model "gitea.dev/models/repo"
 	"gitea.dev/models/unit"
 	user_model "gitea.dev/models/user"
-	"gitea.dev/modules/actions/jobparser"
 	"gitea.dev/modules/json"
 	"gitea.dev/modules/log"
 	"gitea.dev/modules/timeutil"
@@ -145,14 +144,6 @@ func CreateScheduleTaskBySpec(ctx context.Context, spec *actions_model.ActionSch
 		WorkflowCommitSHA: cron.CommitSHA,
 	}
 
-	_, err := jobparser.ValidateWorkflowStatic(cron.Content)
-	if err == nil {
-		err = validateCalledWorkflows(ctx, run, cron.Content)
-	}
-	if err != nil {
-		return fmt.Errorf("invalid workflow: %w", err)
-	}
-
 	// FIXME cron.Content might be outdated if the workflow file has been changed.
 	// Load the latest sha from default branch
 	// Insert the action run and its associated jobs into the database

services/actions/schedule_tasks_test.go

@@ -103,7 +103,7 @@ func TestStartTasks(t *testing.T) {
 	}
 
 	due := timeutil.TimeStamp(time.Now().Add(-time.Minute).Unix())
-	validWorkflow := "on:\n  schedule:\n    - cron: '0 0 * * *'\njobs:\n  job:\n    runs-on: ubuntu-latest\n    steps:\n      - run: true\n"
+	validWorkflow := "jobs:\n  job:\n    runs-on: ubuntu-latest\n    steps:\n      - run: true\n"
 
 	// specs are processed by ascending id, so the broken one runs first and used to abort the whole pass
 	broken := insertSchedule(1, 2, "broken.yml", "@every 1m", "this: [is: not: a: workflow", due)

services/actions/workflow.go

@@ -140,10 +140,7 @@ func DispatchActionWorkflow(ctx reqctx.RequestContext, doer *user_model.User, re
 		return 0, err
 	}
 
-	if _, err = jobparser.ValidateWorkflowStatic(content); err == nil {
-		err = validateCalledWorkflows(ctx, run, content)
-	}
-	if err != nil {
+	if _, err := jobparser.ValidateWorkflowStatic(content); err != nil {
 		return 0, util.ErrorWrapTranslatable(util.NewInvalidArgumentErrorf("invalid workflow %q: %v", workflowID, err), "actions.runs.invalid_workflow_helper", err.Error())
 	}
 	workflow, err := jobparser.ReadWorkflow(content)

templates/admin/user/list.tmpl

@@ -47,20 +47,6 @@
 						</div>
 					</div>
 
-					<!-- Authentication Source Filter Menu Item -->
-					{{if .HasAuthSources}}
-						<div class="ui dropdown type jump item">
-							<span class="text">{{ctx.Locale.Tr "admin.users.auth_source"}}</span>
-							{{svg "octicon-triangle-down" 14 "dropdown icon"}}
-							<div class="menu flex-items-menu">
-								{{range $index, $option := .AuthSourceFilterOptions}}
-									{{if eq $index 1}}<div class="divider"></div>{{end}}
-									<label class="item"><input type="radio" name="source_id" value="{{$option.Value}}" {{if $option.Selected}}checked{{end}}> {{$option.Label}}</label>
-								{{end}}
-							</div>
-						</div>
-					{{end}}
-
 					<!-- Sort Menu Item -->
 					<div class="ui dropdown type jump item">
 						<span class="text">
@@ -89,7 +75,6 @@
 							{{SortArrow "alphabetically" "reversealphabetically" $.SortType true}}
 						</th>
 						<th>{{ctx.Locale.Tr "email"}}</th>
-						<th>{{ctx.Locale.Tr "admin.users.auth_source"}}</th>
 						<th>{{ctx.Locale.Tr "admin.users.activated"}}</th>
 						<th>{{ctx.Locale.Tr "admin.users.restricted"}}</th>
 						<th>{{ctx.Locale.Tr "admin.users.2fa"}}</th>
@@ -117,7 +102,6 @@
 								{{template "shared/user/user_type_label" .}}
 							</td>
 							<td class="gt-ellipsis tw-max-w-48">{{.Email}}</td>
-							<td class="gt-ellipsis tw-max-w-32">{{if .LoginSource}}{{index $.SourceNames .LoginSource}}{{else}}{{ctx.Locale.Tr "admin.users.local"}}{{end}}</td>
 							<td>{{svg (Iif .IsActive "octicon-check" "octicon-x")}}</td>
 							<td>{{svg (Iif .IsRestricted "octicon-check" "octicon-x")}}</td>
 							<td>{{svg (Iif (index $.UsersTwoFaStatus .ID) "octicon-check" "octicon-x")}}</td>
@@ -135,7 +119,7 @@
 							</td>
 						</tr>
 					{{else}}
-						<tr class="no-results-row"><td class="tw-text-center" colspan="10">{{ctx.Locale.Tr "no_results_found"}}</td></tr>
+						<tr class="no-results-row"><td class="tw-text-center" colspan="9">{{ctx.Locale.Tr "no_results_found"}}</td></tr>
 					{{end}}
 				</tbody>
 			</table>

templates/swagger/v1-openapi3.generated.json

@@ -11939,7 +11939,7 @@
         "operationId": "adminSearchUsers",
         "parameters": [
           {
-            "description": "ID of the user's login source to search for, 0 means the local users",
+            "description": "ID of the user's login source to search for",
             "in": "query",
             "name": "source_id",
             "schema": {

templates/swagger/v1-swagger.generated.json

@@ -825,7 +825,7 @@
           {
             "type": "integer",
             "format": "int64",
-            "description": "ID of the user's login source to search for, 0 means the local users",
+            "description": "ID of the user's login source to search for",
             "name": "source_id",
             "in": "query"
           },

templates/user/auth/grant.tmpl

@@ -12,7 +12,6 @@
 				{{end}}
 				{{ctx.Locale.Tr "auth.authorize_application_created_by" .ApplicationCreatorLinkHTML}}<br>
 				{{ctx.Locale.Tr "auth.authorize_application_with_scopes" (HTMLFormat "<b>%s</b>" .Scope)}}
-				{{if .AddedScopes}}<br>{{ctx.Locale.Tr "auth.authorize_application_new_scopes" (HTMLFormat "<b>%s</b>" (StringUtils.Join .AddedScopes " "))}}{{end}}
 			</p>
 		</div>
 		<div class="ui attached segment">

tests/e2e/file-view-render.test.ts

@@ -39,18 +39,6 @@ test('pdf file', async ({page, request}) => {
   await assertFlushWithParent(container, page.locator('.file-view'));
 });
 
-test('code line anchors', async ({page, request}) => {
-  const repoName = `e2e-line-anchor-${randomString(8)}`;
-  const owner = env.GITEA_TEST_E2E_USER;
-  await apiCreateRepo(request, {name: repoName});
-  await apiCreateFiles(request, owner, repoName, [{path: 'test.txt', content: 'a\n'}]);
-  const url = `/${owner}/${repoName}/src/branch/main/test.txt`;
-  await page.goto(`${url}#L0`);
-  await page.goto(`${url}#L1`);
-  await expect(page.locator('.code-view tr.active')).toHaveCount(1);
-  await assertNoJsError(page);
-});
-
 test('asciicast file', async ({page, request}) => {
   const repoName = `e2e-asciicast-render-${randomString(8)}`;
   const owner = env.GITEA_TEST_E2E_USER;

tests/integration/actions_invalid_workflow_test.go

@@ -33,7 +33,7 @@ func TestActionsInvalidWorkflowPush(t *testing.T) {
 			content    string
 			wantErrors []string
 		}{
-			{"expression", "on: push\nrun-name: '${{ github.ref'\njobs: {check: {runs-on: ubuntu-latest, if: unknown.x}}\n", []string{"Unrecognized named-value: 'unknown'", "unclosed expression"}},
+			{"expression", "on: push\nrun-name: '${{ github.ref'\njobs: {check: {if: unknown.x}}\n", []string{"Unrecognized named-value: 'unknown'", "unclosed expression"}},
 			{"trigger", "on:\njobs: {check: {runs-on: ubuntu-latest, steps: [{run: echo hello}]}}\n", []string{"invalid event"}},
 		} {
 			t.Run(testCase.name, func(t *testing.T) {

tests/integration/actions_reusable_workflow_test.go

@@ -405,8 +405,8 @@ jobs:
       from: 'consumer'
 `)
 
-			// Phase 1: no grant.
-			assertInvalidWorkflowRun(t, consumerRepo.ID, "cross-caller.yaml", "reusable workflow repository user2/reusable-lib-private does not exist or is not readable")
+			// Phase 1: no grant. The cross-repo read check fails, and NO ActionRun row gets persisted.
+			assert.Equal(t, 0, unittest.GetCount(t, &actions_model.ActionRun{RepoID: consumerRepo.ID}))
 			runner.fetchNoTask(t)
 
 			// Phase 2: user2 (libRepo owner) adds user4 (consumer owner) as a Collaborative Owner of libRepo.
@@ -418,7 +418,7 @@ jobs:
 			// Phase 3: trigger the workflow again
 			createRepoWorkflowFile(t, user4, user4Token, consumerRepo, "marker.txt", "trigger after grant")
 
-			run := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{RepoID: consumerRepo.ID, Index: 2})
+			run := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{RepoID: consumerRepo.ID})
 			crossJob := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRunJob{RunID: run.ID, JobID: "cross_job"})
 			assert.True(t, crossJob.IsReusableCaller)
 			assert.True(t, crossJob.IsExpanded)
@@ -484,7 +484,8 @@ jobs:
     uses: user2/reusable-lib-public-denied/.gitea/workflows/reusable_lib.yaml@main
 `)
 
-			assertInvalidWorkflowRun(t, consumerRepo.ID, "cross-caller.yaml", "reusable workflow repository user2/reusable-lib-public-denied does not exist or is not readable")
+			// Denied: the cross-repo read check fails for the public caller, so NO ActionRun is persisted and no task is dispatched.
+			assert.Equal(t, 0, unittest.GetCount(t, &actions_model.ActionRun{RepoID: consumerRepo.ID}))
 			runner.fetchNoTask(t)
 		})
 
@@ -562,32 +563,35 @@ jobs:
 			unittest.AssertNotExistsBean(t, &actions_model.ActionRunJob{RunID: run.ID, JobID: "util_consumer_job"})
 		})
 
-		t.Run("Missing or invalid callee fails the run as an invalid workflow file", func(t *testing.T) {
-			for name, testCase := range map[string]struct{ callee, want string }{
-				"missing":    {"", "job call: read user2/caller-missing-callee@"},
-				"no-runs-on": {"on: workflow_call\njobs:\n  inner:\n    steps:\n      - run: echo\n", "job call: Error from called workflow ./.gitea/workflows/callee.yml: job inner: Required property is missing: runs-on"},
-			} {
-				apiRepo := createActionsTestRepo(t, user2Token, "caller-"+name+"-callee", false)
-				repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-				if testCase.callee != "" {
-					createRepoWorkflowFile(t, user2, user2Token, repo, ".gitea/workflows/callee.yml", testCase.callee)
-				}
-				createRepoWorkflowFile(t, user2, user2Token, repo, ".gitea/workflows/caller.yaml",
-					"on: push\njobs:\n  plain_job:\n    runs-on: ubuntu-latest\n    steps:\n      - run: echo\n  call:\n    needs: plain_job\n    uses: ./.gitea/workflows/callee.yml\n")
-				assertInvalidWorkflowRun(t, repo.ID, "caller.yaml", testCase.want)
-			}
+		t.Run("Missing callee file", func(t *testing.T) {
+			// A caller workflow references a callee path that does not exist in the repo.
+
+			apiRepo := createActionsTestRepo(t, user2Token, "caller-missing-callee", false)
+			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
+
+			createRepoWorkflowFile(t, user2, user2Token, repo, ".gitea/workflows/caller.yaml",
+				`name: Caller
+on: push
+jobs:
+  plain_job:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo 'job'
+  call_missing:
+    uses: ./.gitea/workflows/does-not-exist.yml
+`)
+
+			assert.Equal(t, 0, unittest.GetCount(t, &actions_model.ActionRun{RepoID: repo.ID}))
 		})
 
-		t.Run("Nested caller failing to expand fails with the error as summary instead of blocking", func(t *testing.T) {
-			// When the expansion hits a terminal error, the emitter must fail the caller and let the run finish as failed, not retry the expansion forever.
-			apiRepo := createActionsTestRepo(t, user2Token, "nested-caller-bad-callee", false)
+		t.Run("Nested caller with missing callee fails with the error as summary instead of blocking", func(t *testing.T) {
+			// When the expansion hits a terminal error (e.g. missing callee), the emitter must fail the caller and let the run finish as failed, not retry the expansion forever.
+			apiRepo := createActionsTestRepo(t, user2Token, "nested-caller-missing-callee", false)
 			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
 
 			runner := newMockRunner()
 			runner.registerAsRepoRunner(t, repo.OwnerName, repo.Name, "mock-runner", []string{"ubuntu-latest"}, false)
 
-			createRepoWorkflowFile(t, user2, user2Token, repo, ".gitea/workflows/lib.yml",
-				"on:\n  workflow_call:\n    secrets:\n      token:\n        required: true\njobs:\n  inner:\n    runs-on: ubuntu-latest\n    steps:\n      - run: echo\n")
 			createRepoWorkflowFile(t, user2, user2Token, repo, ".gitea/workflows/caller.yaml",
 				`name: Caller
 on: push
@@ -598,7 +602,7 @@ jobs:
       - run: echo 'job'
   bad_caller:
     needs: plain_job
-    uses: ./.gitea/workflows/lib.yml
+    uses: ./.gitea/workflows/does-not-exist.yml
 `)
 
 			plainTask := runner.fetchTask(t)
@@ -610,7 +614,7 @@ jobs:
 
 			runner.execTask(t, plainTask, &mockTaskOutcome{result: runnerv1.Result_RESULT_SUCCESS})
 
-			// The emitter now tries to expand bad_caller, misses the required secret, and fails the caller.
+			// The emitter now tries to expand bad_caller, hits the missing callee, and fails the caller.
 			badCaller := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRunJob{ID: badCallerPre.ID})
 			assert.Equal(t, actions_model.StatusFailure, badCaller.Status)
 			// No children were inserted (the terminal error precedes the child inserts).
@@ -622,7 +626,7 @@ jobs:
 			runner.fetchNoTask(t) // no task scheduled for the failed caller; the run is not stuck
 			summary, err := actions_model.GetActionRunJobSummary(t.Context(), repo.ID, run.ID, badCaller.RunAttemptID, badCaller.ID, 0)
 			require.NoError(t, err)
-			assert.Contains(t, summary.Content, "secret token is required, but not provided while calling")
+			assert.Contains(t, summary.Content, "does-not-exist.yml")
 		})
 
 		t.Run("Fork PR with secrets: inherit does not leak base repo secrets", func(t *testing.T) {
@@ -985,16 +989,6 @@ jobs:
 	})
 }
 
-func assertInvalidWorkflowRun(t *testing.T, repoID int64, workflowID, want string) {
-	t.Helper()
-	run := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{RepoID: repoID, WorkflowID: workflowID})
-	assert.Equal(t, actions_model.StatusFailure, run.Status)
-	assert.Zero(t, unittest.GetCount(t, &actions_model.ActionRunJob{RunID: run.ID}))
-	summary, err := actions_model.GetActionRunJobSummary(t.Context(), repoID, run.ID, run.LatestAttemptID, 0, 0)
-	require.NoError(t, err)
-	assert.Contains(t, summary.Content, want)
-}
-
 // token must belong to u (the commit identity) and have write access to repo. Reuse the caller's
 // existing token rather than logging in per call, which would re-run bcrypt password verification each time.
 func createRepoWorkflowFile(t *testing.T, u *user_model.User, token string, repo *repo_model.Repository, treePath, content string) {

tests/integration/admin_user_test.go

@@ -16,10 +16,8 @@ import (
 	"gitea.dev/modules/setting"
 	api "gitea.dev/modules/structs"
 	"gitea.dev/modules/test"
-	"gitea.dev/services/auth/source/ldap"
 	"gitea.dev/tests"
 
-	"github.com/PuerkitoBio/goquery"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -36,49 +34,6 @@ func TestAdminViewUsers(t *testing.T) {
 	session.MakeRequest(t, req, http.StatusForbidden)
 }
 
-func TestAdminViewUsersFilterAuthSource(t *testing.T) {
-	defer tests.PrepareTestEnv(t)()
-
-	source := &auth_model.Source{Type: auth_model.LDAP, Name: "test-user-list-filter", IsActive: false, Cfg: &ldap.Source{}} // users stay attached to a deactivated source
-	require.NoError(t, auth_model.CreateSource(t.Context(), source))
-
-	user2 := &user_model.User{ID: 2, LoginType: auth_model.LDAP, LoginSource: source.ID}
-	require.NoError(t, user_model.UpdateUserCols(t.Context(), user2, "login_type", "login_source"))
-
-	session := loginUser(t, "user1")
-	listUsers := func(query string) (*HTMLDoc, []string) {
-		req := NewRequest(t, "GET", "/-/admin/users?"+query)
-		resp := session.MakeRequest(t, req, http.StatusOK)
-		doc := NewHTMLParser(t, resp.Body)
-		return doc, doc.Find("table tbody tr td:nth-child(2) a").Map(func(_ int, s *goquery.Selection) string {
-			return s.Text()
-		})
-	}
-
-	doc, users := listUsers("source_id=") // the "All" option submits an empty value
-	AssertHTMLElement(t, doc, `input[name="source_id"][value=""][checked]`, true)
-	assert.Subset(t, users, []string{"user1", "user2"})
-
-	doc, users = listUsers(fmt.Sprintf("source_id=%d", source.ID)) // the "test-user-list-filter" LDAP source
-	AssertHTMLElement(t, doc, fmt.Sprintf(`input[name="source_id"][value="%d"][checked]`, source.ID), true)
-	assert.Equal(t, []string{"user2"}, users)
-	assert.Equal(t, source.Name, doc.Find("table tbody tr td:nth-child(4)").Text())
-
-	_, users = listUsers("source_id=0") // 0 means the "Local" source
-	assert.Contains(t, users, "user1")
-	assert.NotContains(t, users, "user2")
-
-	token := getUserToken(t, "user1", auth_model.AccessTokenScopeReadAdmin)
-	req := NewRequest(t, "GET", "/api/v1/admin/users?source_id=0").AddTokenAuth(token) // the API also treats 0 as local users
-	apiUsers := DecodeJSON(t, MakeRequest(t, req, http.StatusOK), []api.User{})
-	apiUserNames := make([]string, 0, len(apiUsers))
-	for _, u := range apiUsers {
-		apiUserNames = append(apiUserNames, u.UserName)
-	}
-	assert.Contains(t, apiUserNames, "user1")
-	assert.NotContains(t, apiUserNames, "user2")
-}
-
 func TestAdminViewUser(t *testing.T) {
 	defer tests.PrepareTestEnv(t)()
 

web_src/js/features/repo-code.ts

@@ -58,7 +58,6 @@ function selectRange(range: string): Element | null {
     stopLineNum = tmp;
     range = `${stop}-${start}`;
   }
-  if (startLineNum < 1) return null;
 
   const first = elLineNums[startLineNum - 1] ?? null;
   for (let i = startLineNum - 1; i <= stopLineNum - 1 && i < elLineNums.length; i++) {

web_src/js/modules/errors.test.ts

@@ -17,11 +17,7 @@ test('isGiteaError', () => {
   expect(isGiteaError('', `Error\n    at chrome-extension://abc/content.js:1:1`)).toBe(false);
   expect(isGiteaError('', `Error\n    at https://other-site.com/script.js:1:1`)).toBe(false);
   expect(isGiteaError('', `Error\n    at ${origin}/assets/js/index.abc123.js:1:1`)).toBe(true);
-  expect(isGiteaError('', `Error\n    at ${origin}/web_src/js/index.ts:1:1`)).toBe(false);
   expect(isGiteaError(`${origin}/assets/js/index.js`, `Error\n    at chrome-extension://abc/content.js:1:1`)).toBe(false);
-  vi.spyOn(window.config, 'runModeIsProd', 'get').mockReturnValue(false);
-  expect(isGiteaError('', `Error\n    at ${origin}/web_src/js/index.ts:1:1`)).toBe(true);
-  vi.restoreAllMocks();
 });
 
 test('showGlobalErrorMessage', () => {

web_src/js/modules/errors.ts

@@ -58,7 +58,6 @@ export function isGiteaError(filename: string, stack: string): boolean {
   if (extensionRe.test(filename) || extensionRe.test(stack)) return false;
   const assetBaseUrl = new URL(`${windowConfig()?.assetUrlPrefix}/`, window.location.origin).href;
   if (filename && !filename.startsWith(assetBaseUrl) && !filename.startsWith(window.location.origin)) return false;
-  if (!windowConfig()?.runModeIsProd && stack.includes(`${window.location.origin}/web_src/`)) return true;
   return !stack || stack.includes(assetBaseUrl);
 }