gitea-MIRROR/models/repo/repo_unit_actions.go

// Copyright 2026 The Gitea Authors. All rights reserved.
// SPDX-License-Identifier: MIT

package repo

import (
	"slices"

	"gitea.dev/models/db"
	"gitea.dev/models/perm"
	"gitea.dev/models/unit"
	"gitea.dev/modules/json"
	"gitea.dev/modules/util"
)

// ActionsTokenPermissionMode defines the default permission mode for Actions tokens
type ActionsTokenPermissionMode string

const (
	// ActionsTokenPermissionModePermissive - write access by default (current behavior, backwards compatible)
	ActionsTokenPermissionModePermissive ActionsTokenPermissionMode = "permissive"
	// ActionsTokenPermissionModeRestricted - read access by default
	ActionsTokenPermissionModeRestricted ActionsTokenPermissionMode = "restricted"
)

func (ActionsTokenPermissionMode) EnumValues() []ActionsTokenPermissionMode {
	return []ActionsTokenPermissionMode{ActionsTokenPermissionModePermissive /* default */, ActionsTokenPermissionModeRestricted}
}

// ActionsTokenPermissions defines the permissions for different repository units
type ActionsTokenPermissions struct {
	UnitAccessModes map[unit.Type]perm.AccessMode `json:"unit_access_modes,omitempty"`
	IDToken         bool                          `json:"id_token,omitempty"` // default modes never grant it, like on GitHub
}

var ActionsTokenUnitTypes = []unit.Type{
	unit.TypeCode,
	unit.TypeIssues,
	unit.TypePullRequests,
	unit.TypePackages,
	unit.TypeActions,
	unit.TypeWiki,
	unit.TypeReleases,
	unit.TypeProjects,
}

func MakeActionsTokenPermissions(unitAccessMode perm.AccessMode) (ret ActionsTokenPermissions) {
	ret.UnitAccessModes = make(map[unit.Type]perm.AccessMode)
	for _, u := range ActionsTokenUnitTypes {
		ret.UnitAccessModes[u] = unitAccessMode
	}
	return ret
}

func MakeWriteAllActionsTokenPermissions() ActionsTokenPermissions {
	ret := MakeActionsTokenPermissions(perm.AccessModeWrite)
	ret.IDToken = true
	return ret
}

// ClampActionsTokenPermissions ensures that the given permissions don't exceed the maximum
func ClampActionsTokenPermissions(p1, p2 ActionsTokenPermissions) (ret ActionsTokenPermissions) {
	ret.UnitAccessModes = make(map[unit.Type]perm.AccessMode)
	for _, ut := range ActionsTokenUnitTypes {
		ret.UnitAccessModes[ut] = min(p1.UnitAccessModes[ut], p2.UnitAccessModes[ut])
	}
	ret.IDToken = p1.IDToken && p2.IDToken
	return ret
}

// MakeRestrictedPermissions returns the restricted permissions
func MakeRestrictedPermissions() ActionsTokenPermissions {
	ret := MakeActionsTokenPermissions(perm.AccessModeNone)
	ret.UnitAccessModes[unit.TypeCode] = perm.AccessModeRead
	ret.UnitAccessModes[unit.TypePackages] = perm.AccessModeRead
	ret.UnitAccessModes[unit.TypeReleases] = perm.AccessModeRead
	return ret
}

type ActionsConfig struct {
	DisabledWorkflows []string
	// DisabledScopedWorkflows maps a scoped workflow's source repository ID to the entry names opted out of in this repository.
	DisabledScopedWorkflows map[int64][]string
	// CollaborativeOwnerIDs is a list of owner IDs used to share actions from private repos.
	// Only workflows from the private repos whose owners are in CollaborativeOwnerIDs can access the current repo's actions.
	CollaborativeOwnerIDs []int64
	// TokenPermissionMode defines the default permission mode (permissive, restricted, or custom)
	TokenPermissionMode ActionsTokenPermissionMode `json:"token_permission_mode,omitempty"`
	// MaxTokenPermissions defines the absolute maximum permissions any token can have in this context.
	// Workflow YAML "permissions" keywords can reduce permissions but never exceed this ceiling.
	MaxTokenPermissions *ActionsTokenPermissions `json:"max_token_permissions,omitempty"`
	// OverrideOwnerConfig indicates if this repository should override the owner-level configuration (User or Org)
	OverrideOwnerConfig bool `json:"override_owner_config,omitempty"`
}

func (cfg *ActionsConfig) EnableWorkflow(file string) {
	cfg.DisabledWorkflows = util.SliceRemoveAll(cfg.DisabledWorkflows, file)
}

func (cfg *ActionsConfig) IsWorkflowDisabled(file string) bool {
	return slices.Contains(cfg.DisabledWorkflows, file)
}

func (cfg *ActionsConfig) DisableWorkflow(file string) {
	if slices.Contains(cfg.DisabledWorkflows, file) {
		return
	}

	cfg.DisabledWorkflows = append(cfg.DisabledWorkflows, file)
}

func (cfg *ActionsConfig) IsScopedWorkflowDisabled(sourceRepoID int64, workflowID string) bool {
	return slices.Contains(cfg.DisabledScopedWorkflows[sourceRepoID], workflowID)
}

func (cfg *ActionsConfig) DisableScopedWorkflow(sourceRepoID int64, workflowID string) {
	if slices.Contains(cfg.DisabledScopedWorkflows[sourceRepoID], workflowID) {
		return
	}
	if cfg.DisabledScopedWorkflows == nil {
		cfg.DisabledScopedWorkflows = make(map[int64][]string)
	}
	cfg.DisabledScopedWorkflows[sourceRepoID] = append(cfg.DisabledScopedWorkflows[sourceRepoID], workflowID)
}

func (cfg *ActionsConfig) EnableScopedWorkflow(sourceRepoID int64, workflowID string) {
	workflowIDs := util.SliceRemoveAll(cfg.DisabledScopedWorkflows[sourceRepoID], workflowID)
	if len(workflowIDs) == 0 {
		delete(cfg.DisabledScopedWorkflows, sourceRepoID)
		return
	}
	cfg.DisabledScopedWorkflows[sourceRepoID] = workflowIDs
}

func (cfg *ActionsConfig) AddCollaborativeOwner(ownerID int64) {
	if !slices.Contains(cfg.CollaborativeOwnerIDs, ownerID) {
		cfg.CollaborativeOwnerIDs = append(cfg.CollaborativeOwnerIDs, ownerID)
	}
}

func (cfg *ActionsConfig) RemoveCollaborativeOwner(ownerID int64) {
	cfg.CollaborativeOwnerIDs = util.SliceRemoveAll(cfg.CollaborativeOwnerIDs, ownerID)
}

func (cfg *ActionsConfig) IsCollaborativeOwner(ownerID int64) bool {
	return slices.Contains(cfg.CollaborativeOwnerIDs, ownerID)
}

// GetDefaultTokenPermissions returns the default token permissions by its TokenPermissionMode.
// It does not apply MaxTokenPermissions; callers must clamp if needed.
func (cfg *ActionsConfig) GetDefaultTokenPermissions() ActionsTokenPermissions {
	switch cfg.TokenPermissionMode {
	case ActionsTokenPermissionModeRestricted:
		return MakeRestrictedPermissions()
	case ActionsTokenPermissionModePermissive:
		return MakeActionsTokenPermissions(perm.AccessModeWrite)
	default:
		return ActionsTokenPermissions{}
	}
}

// GetMaxTokenPermissions returns the maximum allowed permissions
func (cfg *ActionsConfig) GetMaxTokenPermissions() ActionsTokenPermissions {
	if cfg.MaxTokenPermissions != nil {
		return *cfg.MaxTokenPermissions
	}
	// Default max is write for everything
	return MakeWriteAllActionsTokenPermissions()
}

// ClampPermissions ensures that the given permissions don't exceed the maximum
func (cfg *ActionsConfig) ClampPermissions(perms ActionsTokenPermissions) ActionsTokenPermissions {
	maxPerms := cfg.GetMaxTokenPermissions()
	return ClampActionsTokenPermissions(perms, maxPerms)
}

func (cfg *ActionsConfig) FromDB(bs []byte) error {
	db.UnmarshalFromDB(bs, cfg)
	cfg.TokenPermissionMode, _ = util.EnumValue(cfg.TokenPermissionMode)
	return nil
}

func (cfg *ActionsConfig) ToDB() ([]byte, error) {
	return json.Marshal(cfg)
}