Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

21.1 KB
Raw Blame
package repo

import (
	"encoding/json"
	"errors"
	"fmt"
	"slices"
	"sort"
	"strings"
	"time"
	"unicode/utf8"

	"agentflow/internal/domain"

	"gorm.io/gorm"
)

// ---------- Users ----------

type userWithConfig struct {
	ID                           int64      `gorm:"column:id"`
	StaffID                      int        `gorm:"column:staff_id"`
	LoginName                    string     `gorm:"column:login_name"`
	ChineseName                  string     `gorm:"column:chinese_name"`
	DeptID                       int        `gorm:"column:dept_id"`
	DeptName                     string     `gorm:"column:dept_name"`
	PlatformRole                 string     `gorm:"column:platform_role"`
	GitToken                     *string    `gorm:"column:git_token"`
	GitSSHKeyConfigured          bool       `gorm:"column:git_ssh_key_configured"`
	GitHTTPCredentialsConfigured bool       `gorm:"column:git_http_credentials_configured"`
	GitHubCredentialConfigured   bool       `gorm:"column:github_credential_configured"`
	GongfengRefreshToken         *string    `gorm:"column:gongfeng_refresh_token"`
	GongfengTokenExpiresAt       *time.Time `gorm:"column:gongfeng_token_expires_at"`
	CodeBuddyAPIKey              *string    `gorm:"column:codebuddy_api_key"`
	CodeBuddyInternetEnvironment string     `gorm:"column:codebuddy_internet_environment"`
	CodeBuddyModels              *string    `gorm:"column:codebuddy_models"`
	CodexAPIKey                  *string    `gorm:"column:codex_api_key"`
	CodexBaseURL                 *string    `gorm:"column:codex_base_url"`
	CodexModels                  *string    `gorm:"column:codex_models"`
	ClaudeCodeAPIKey             *string    `gorm:"column:claude_code_api_key"`
	ClaudeCodeBaseURL            *string    `gorm:"column:claude_code_base_url"`
	ClaudeCodeModels             *string    `gorm:"column:claude_code_models"`
	AgentCLICredentials          *string    `gorm:"column:agent_cli_credentials"`
	Created                      *time.Time `gorm:"column:created_at"`
	Updated                      *time.Time `gorm:"column:updated_at"`
}

const userSelectColumns = `u.id, u.staff_id, u.login_name, u.chinese_name, u.dept_id, u.dept_name,
	COALESCE(u.platform_role, '') AS platform_role,
	c.git_token, EXISTS (SELECT 1 FROM user_git_ssh_keys k WHERE k.user_id = u.id) AS git_ssh_key_configured,
	EXISTS (SELECT 1 FROM user_git_http_credentials h WHERE h.user_id = u.id) AS git_http_credentials_configured,
	EXISTS (SELECT 1 FROM user_git_http_credentials h WHERE h.user_id = u.id AND h.host = 'github.com') AS github_credential_configured,
	c.gongfeng_refresh_token, c.gongfeng_token_expires_at, c.codebuddy_api_key, COALESCE(c.codebuddy_internet_environment, '') AS codebuddy_internet_environment, c.codebuddy_models,
	c.codex_api_key, c.codex_base_url, c.codex_models, c.claude_code_api_key, c.claude_code_base_url, c.claude_code_models,
	c.agent_cli_credentials,
	u.created_at, u.updated_at`

func (r userWithConfig) toDomain() domain.User {
	u := domain.User{
		ID: r.ID, StaffID: r.StaffID, LoginName: r.LoginName, ChineseName: r.ChineseName,
		DeptID: r.DeptID, DeptName: r.DeptName, PlatformRole: r.PlatformRole,
		CodeBuddyInternetEnvironment: r.CodeBuddyInternetEnvironment,
		CodeBuddyModels:              decodeCLIModels(r.CodeBuddyModels),
		GitSSHKeyConfigured:          r.GitSSHKeyConfigured,
		GitHTTPCredentialsConfigured: r.GitHTTPCredentialsConfigured,
		GitHubCredentialConfigured:   r.GitHubCredentialConfigured,
	}
	if r.GitToken != nil {
		u.GitToken = *r.GitToken
	}
	if r.GongfengRefreshToken != nil {
		u.GongfengRefreshToken = *r.GongfengRefreshToken
	}
	if r.GongfengTokenExpiresAt != nil {
		u.GongfengTokenExpiresAt = *r.GongfengTokenExpiresAt
	}
	if r.CodeBuddyAPIKey != nil {
		u.CodeBuddyAPIKey = *r.CodeBuddyAPIKey
	}
	if r.CodexAPIKey != nil {
		u.CodexAPIKey = *r.CodexAPIKey
	}
	if r.CodexBaseURL != nil {
		u.CodexBaseURL = *r.CodexBaseURL
	}
	u.CodexModels = decodeCLIModels(r.CodexModels)
	if r.ClaudeCodeAPIKey != nil {
		u.ClaudeCodeAPIKey = *r.ClaudeCodeAPIKey
	}
	if r.ClaudeCodeBaseURL != nil {
		u.ClaudeCodeBaseURL = *r.ClaudeCodeBaseURL
	}
	u.ClaudeCodeModels = decodeCLIModels(r.ClaudeCodeModels)
	if r.AgentCLICredentials != nil {
		_ = json.Unmarshal([]byte(*r.AgentCLICredentials), &u.AgentCLICredentials)
	}
	if r.Created != nil {
		u.CreatedAt = *r.Created
	}
	if r.Updated != nil {
		u.UpdatedAt = *r.Updated
	}
	if _, managed := managedGitHTTPCredential(u); managed {
		u.GitHTTPCredentialsConfigured = true
	}
	return u
}

func (r *UsersRepo) userQuery(where string, args ...any) (domain.User, bool) {
	var row userWithConfig
	q := r.DB.Raw(`SELECT `+userSelectColumns+` FROM users u LEFT JOIN user_configs c ON c.user_id=u.id WHERE `+where, args...)
	if err := q.Scan(&row).Error; err != nil || row.ID == 0 {
		return domain.User{}, false
	}
	return row.toDomain(), true
}

func (r *UsersRepo) Users() []domain.User {
	var rows []userWithConfig
	if err := r.DB.Raw(`SELECT ` + userSelectColumns + ` FROM users u LEFT JOIN user_configs c ON c.user_id=u.id ORDER BY u.login_name ASC`).Scan(&rows).Error; err != nil {
		return []domain.User{}
	}
	out := make([]domain.User, 0, len(rows))
	for _, row := range rows {
		out = append(out, row.toDomain())
	}
	sort.Slice(out, func(i, j int) bool { return out[i].LoginName < out[j].LoginName })
	return out
}

func (r *UsersRepo) User(id int64) (domain.User, bool) {
	if id <= 0 {
		return domain.User{}, false
	}
	return r.userQuery("u.id=?", id)
}

func (r *UsersRepo) UserByLoginName(loginName string) (domain.User, bool) {
	if r.isMySQL() {
		// MySQL collation is already case-insensitive and keeps index usage.
		return r.userQuery("u.login_name=?", loginName)
	}
	return r.userQuery("LOWER(u.login_name) = LOWER(?)", loginName)
}

func (r *UsersRepo) UserByStaffID(staffID int) (domain.User, bool) {
	return r.userQuery("u.staff_id=?", staffID)
}

func (r *UsersRepo) PutUser(v domain.User) error {
	if v.LoginName == "" && v.StaffID == 0 && v.ID == 0 {
		return errors.New("user loginName, staffId, or ID is required")
	}
	now := time.Now().UTC()
	var old domain.User
	var ok bool
	if v.ID > 0 {
		old, ok = r.User(v.ID)
	} else if v.LoginName != "" {
		old, ok = r.UserByLoginName(v.LoginName)
	}
	if ok {
		if v.ID == 0 {
			v.ID = old.ID
		}
		v.CreatedAt = old.CreatedAt
		// Authentication refreshes identity fields only. Credentials are managed
		// through UpdateUserCredentials and must survive every login refresh.
		v.GitToken = old.GitToken
		v.GongfengRefreshToken = old.GongfengRefreshToken
		v.GongfengTokenExpiresAt = old.GongfengTokenExpiresAt
		v.CodexAPIKey, v.CodexBaseURL, v.CodexModels = old.CodexAPIKey, old.CodexBaseURL, old.CodexModels
		v.ClaudeCodeAPIKey, v.ClaudeCodeBaseURL, v.ClaudeCodeModels = old.ClaudeCodeAPIKey, old.ClaudeCodeBaseURL, old.ClaudeCodeModels
		v.CodeBuddyAPIKey = old.CodeBuddyAPIKey
		v.CodeBuddyInternetEnvironment = old.CodeBuddyInternetEnvironment
		v.CodeBuddyModels = old.CodeBuddyModels
		v.AgentCLICredentials = old.AgentCLICredentials
		if strings.TrimSpace(v.PlatformRole) == "" {
			v.PlatformRole = old.PlatformRole
		}
	} else {
		v.CreatedAt = now
	}
	if IsAllowlistedPlatformAdmin(v.LoginName) {
		v.PlatformRole = domain.PlatformRoleAdmin
	}
	v.UpdatedAt = now
	saved, err := r.writeUser(v)
	if err != nil {
		return err
	}
	if !ok && userHasConfig(saved) {
		if err := r.writeUserConfig(saved); err != nil {
			return err
		}
	}
	return nil
}

func (r *UsersRepo) writeUser(v domain.User) (domain.User, error) {
	if v.ID > 0 {
		err := upsert(r.DB, "users", map[string]any{
			"id": v.ID, "staff_id": v.StaffID, "login_name": v.LoginName, "chinese_name": v.ChineseName,
			"dept_id": v.DeptID, "dept_name": v.DeptName, "platform_role": v.PlatformRole,
			"created_at": timePtr(v.CreatedAt), "updated_at": timePtr(v.UpdatedAt),
		})
		return v, err
	}
	inserted, err := insertIgnore(r.DB, "users", map[string]any{
		"staff_id": v.StaffID, "login_name": v.LoginName, "chinese_name": v.ChineseName,
		"dept_id": v.DeptID, "dept_name": v.DeptName, "platform_role": v.PlatformRole,
		"created_at": timePtr(v.CreatedAt), "updated_at": timePtr(v.UpdatedAt),
	})
	if err != nil {
		return domain.User{}, err
	}
	if !inserted {
		// The unique login already exists: adopt that row and refresh it.
		var existing userRow
		if err := r.DB.Where("login_name = ?", v.LoginName).Take(&existing).Error; err != nil {
			return domain.User{}, err
		}
		if err := r.DB.Model(&userRow{}).Where("id = ?", existing.ID).Updates(map[string]any{
			"staff_id": v.StaffID, "chinese_name": v.ChineseName, "dept_id": v.DeptID,
			"dept_name": v.DeptName, "platform_role": v.PlatformRole, "updated_at": timePtr(v.UpdatedAt),
		}).Error; err != nil {
			return domain.User{}, err
		}
		v.ID = existing.ID
		return v, nil
	}
	var row userRow
	if err := r.DB.Where("login_name = ?", v.LoginName).Take(&row).Error; err != nil {
		return domain.User{}, err
	}
	v.ID = row.ID
	return v, nil
}

func userHasConfig(user domain.User) bool {
	return user.GitToken != "" ||
		user.GongfengRefreshToken != "" ||
		user.CodeBuddyAPIKey != "" ||
		user.CodeBuddyInternetEnvironment != "" ||
		len(user.CodeBuddyModels) > 0 ||
		user.CodexAPIKey != "" ||
		user.CodexBaseURL != "" ||
		len(user.CodexModels) > 0 ||
		user.ClaudeCodeAPIKey != "" ||
		user.ClaudeCodeBaseURL != "" ||
		len(user.ClaudeCodeModels) > 0 ||
		len(user.AgentCLICredentials) > 0
}

type UserCredentialUpdate struct {
	CodeBuddyAPIKey              string             `json:"codeBuddyApiKey"`
	CodeBuddyAPIKeyClear         bool               `json:"codeBuddyApiKeyClear"`
	CodeBuddyInternetEnvironment *string            `json:"codeBuddyInternetEnvironment"`
	CodeBuddyModels              *[]domain.CLIModel `json:"codeBuddyModels"`
	CodexAPIKey                  string             `json:"codexApiKey"`
	CodexAPIKeyClear             bool               `json:"codexApiKeyClear"`
	CodexBaseURL                 *string            `json:"codexBaseUrl"`
	CodexModels                  *[]domain.CLIModel `json:"codexModels"`
	ClaudeCodeAPIKey             string             `json:"claudeCodeApiKey"`
	ClaudeCodeAPIKeyClear        bool               `json:"claudeCodeApiKeyClear"`
	ClaudeCodeBaseURL            *string            `json:"claudeCodeBaseUrl"`
	ClaudeCodeModels             *[]domain.CLIModel `json:"claudeCodeModels"`
	// AgentCLICredentials updates the agent CLIs by kind; absent fields keep
	// the stored value. CodeBuddy, Codex and Claude Code stay on their own columns.
	AgentCLICredentials map[string]AgentCLICredentialUpdate `json:"agentCliCredentials"`
}

type AgentCLICredentialUpdate struct {
	APIKey      string             `json:"apiKey"`
	APIKeyClear bool               `json:"apiKeyClear"`
	BaseURL     *string            `json:"baseUrl"`
	Protocol    *string            `json:"protocol"`
	Models      *[]domain.CLIModel `json:"models"`
	// DiscoveredForKey prevents a refresh for an old key from replacing the
	// new key's models.
	DiscoveredForKey string `json:"-"`
}

func (r *UsersRepo) UpdateUserCredentials(id int64, update UserCredentialUpdate) (domain.User, error) {
	var user domain.User
	err := r.DB.Transaction(func(tx *gorm.DB) error {
		// Serialize edits and CLI discovery for this user even when they
		// arrive at different server instances or before a config row exists.
		var owner userRow
		if err := r.locking(tx.Select("id")).Where("id = ?", id).Take(&owner).Error; err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return errors.New("user not found")
			}
			return err
		}
		credentials := &UsersRepo{deps: &deps{DB: tx}}
		var err error
		user, err = credentials.updateUserCredentials(id, update)
		return err
	})
	if err != nil {
		return domain.User{}, err
	}
	return user, nil
}

func (r *UsersRepo) updateUserCredentials(id int64, update UserCredentialUpdate) (domain.User, error) {
	user, ok := r.User(id)
	if !ok {
		return domain.User{}, errors.New("user not found")
	}
	if update.CodeBuddyAPIKeyClear {
		user.CodeBuddyAPIKey = ""
	} else if value := strings.TrimSpace(update.CodeBuddyAPIKey); value != "" {
		user.CodeBuddyAPIKey = value
	}
	if update.CodeBuddyInternetEnvironment != nil {
		user.CodeBuddyInternetEnvironment = strings.TrimSpace(*update.CodeBuddyInternetEnvironment)
	}
	if update.CodeBuddyModels != nil {
		models, err := normalizeCLIModels(*update.CodeBuddyModels)
		if err != nil {
			return domain.User{}, err
		}
		user.CodeBuddyModels = models
	}
	if update.CodexAPIKeyClear {
		user.CodexAPIKey = ""
	} else if value := strings.TrimSpace(update.CodexAPIKey); value != "" {
		user.CodexAPIKey = value
	}
	if update.ClaudeCodeAPIKeyClear {
		user.ClaudeCodeAPIKey = ""
	} else if value := strings.TrimSpace(update.ClaudeCodeAPIKey); value != "" {
		user.ClaudeCodeAPIKey = value
	}
	if update.CodexBaseURL != nil {
		user.CodexBaseURL = strings.TrimSpace(*update.CodexBaseURL)
	}
	if update.ClaudeCodeBaseURL != nil {
		user.ClaudeCodeBaseURL = strings.TrimSpace(*update.ClaudeCodeBaseURL)
	}
	if update.CodexModels != nil {
		models, err := normalizeCLIModels(*update.CodexModels)
		if err != nil {
			return domain.User{}, err
		}
		user.CodexModels = models
	}
	if update.ClaudeCodeModels != nil {
		models, err := normalizeCLIModels(*update.ClaudeCodeModels)
		if err != nil {
			return domain.User{}, err
		}
		user.ClaudeCodeModels = models
	}
	if err := applyAgentCLICredentialUpdates(&user, update.AgentCLICredentials); err != nil {
		return domain.User{}, err
	}
	user.UpdatedAt = time.Now().UTC()
	if err := r.writeUserConfig(user); err != nil {
		return domain.User{}, err
	}
	return user, nil
}

// SaveGongfengOAuth stores an OAuth access token in the git credential slot
// and keeps the refresh token so a later use can renew it.
func (r *UsersRepo) SaveGongfengOAuth(id int64, accessToken, refreshToken string, expiresAt time.Time) (domain.User, error) {
	user, ok := r.User(id)
	if !ok {
		return domain.User{}, errors.New("user not found")
	}
	user.GitToken = strings.TrimSpace(accessToken)
	user.GongfengRefreshToken = strings.TrimSpace(refreshToken)
	user.GongfengTokenExpiresAt = expiresAt.UTC()
	user.UpdatedAt = time.Now().UTC()
	if err := r.writeUserConfig(user); err != nil {
		return domain.User{}, err
	}
	return user, nil
}

func (r *UsersRepo) writeUserConfig(v domain.User) error {
	values := map[string]any{
		"user_id":                v.ID,
		"git_token":              nullableString(v.GitToken),
		"gongfeng_refresh_token": nullableString(v.GongfengRefreshToken), "gongfeng_token_expires_at": timePtr(v.GongfengTokenExpiresAt),
		"codebuddy_api_key":              nullableString(v.CodeBuddyAPIKey),
		"codebuddy_internet_environment": v.CodeBuddyInternetEnvironment,
		"codebuddy_models":               encodeCLIModels(v.CodeBuddyModels),
		"codex_api_key":                  nullableString(v.CodexAPIKey), "codex_base_url": nullableString(v.CodexBaseURL), "codex_models": encodeCLIModels(v.CodexModels),
		"claude_code_api_key": nullableString(v.ClaudeCodeAPIKey), "claude_code_base_url": nullableString(v.ClaudeCodeBaseURL), "claude_code_models": encodeCLIModels(v.ClaudeCodeModels),
		"agent_cli_credentials": encodeAgentCLICredentials(v.AgentCLICredentials),
		"created_at":            timePtr(v.CreatedAt), "updated_at": timePtr(v.UpdatedAt),
	}
	return upsert(r.DB, "user_configs", values)
}

func nullableString(v string) any {
	if v == "" {
		return nil
	}
	return v
}

func applyAgentCLICredentialUpdates(user *domain.User, updates map[string]AgentCLICredentialUpdate) error {
	if len(updates) == 0 {
		return nil
	}
	merged := make(map[string]domain.AgentCLICredential, len(user.AgentCLICredentials)+len(updates))
	for kind, cred := range user.AgentCLICredentials {
		merged[kind] = cred
	}
	for kind, update := range updates {
		kind = strings.TrimSpace(kind)
		if !domain.IsAgentCLIKind(kind) {
			return fmt.Errorf("不支持的 CLI:%s", kind)
		}
		cred := merged[kind]
		previousKey := cred.APIKey
		if update.APIKeyClear {
			cred.APIKey = ""
		} else if value := strings.TrimSpace(update.APIKey); value != "" {
			cred.APIKey = value
		}
		// Cursor's catalog and effort variants belong to the key's plan.
		// A replacement key starts with its own list unless the edit also
		// supplies a catalog.
		if kind == "cursor" && cred.APIKey != previousKey && update.Models == nil {
			cred.Models = nil
			cred.ModelsCustomized = false
		}
		if update.BaseURL != nil {
			cred.BaseURL = strings.TrimSpace(*update.BaseURL)
		}
		if update.Protocol != nil {
			protocol := strings.TrimSpace(*update.Protocol)
			if protocol != "" && domain.NormalizeAgentCLIProtocol(kind, protocol) != protocol {
				return fmt.Errorf("%s 不支持协议 %s", kind, protocol)
			}
			cred.Protocol = protocol
		}
		discovered := update.DiscoveredForKey != ""
		if update.Models != nil && (!discovered || (!cred.ModelsCustomized && cred.APIKey == update.DiscoveredForKey)) {
			models, err := normalizeCLIModels(*update.Models)
			if err != nil {
				return err
			}
			cred.Models = models
			if kind == "cursor" {
				cred.ModelsCustomized = !discovered && len(models) != 0
			}
		}
		if cred.APIKey == "" && cred.BaseURL == "" && cred.Protocol == "" && len(cred.Models) == 0 {
			delete(merged, kind)
			continue
		}
		merged[kind] = cred
	}
	if len(merged) == 0 {
		merged = nil
	}
	user.AgentCLICredentials = merged
	return nil
}

func encodeAgentCLICredentials(creds map[string]domain.AgentCLICredential) any {
	if len(creds) == 0 {
		return nil
	}
	raw, err := json.Marshal(creds)
	if err != nil || string(raw) == "{}" || string(raw) == "null" {
		return nil
	}
	return string(raw)
}

const (
	maxCLIModels        = 100
	maxCLIModelIDLen    = 128
	maxCLIModelNameRune = 64
)

func decodeCLIModels(raw *string) []domain.CLIModel {
	if raw == nil || strings.TrimSpace(*raw) == "" {
		return nil
	}
	var models []domain.CLIModel
	if json.Unmarshal([]byte(*raw), &models) != nil {
		return nil
	}
	return models
}

func encodeCLIModels(models []domain.CLIModel) any {
	if len(models) == 0 {
		return nil
	}
	raw, err := json.Marshal(models)
	if err != nil {
		return nil
	}
	return string(raw)
}

func normalizeCLIModels(models []domain.CLIModel) ([]domain.CLIModel, error) {
	if len(models) > maxCLIModels {
		return nil, fmt.Errorf("模型目录最多 %d 个", maxCLIModels)
	}
	out := make([]domain.CLIModel, 0, len(models))
	seen := map[string]bool{}
	for _, model := range models {
		id, name := strings.TrimSpace(model.ID), strings.TrimSpace(model.Name)
		if err := validCLIModelID(id); err != nil {
			return nil, err
		}
		if seen[id] {
			return nil, fmt.Errorf("模型 ID %s 重复", id)
		}
		seen[id] = true
		if utf8.RuneCountInString(name) > maxCLIModelNameRune {
			return nil, fmt.Errorf("显示名称长度不能超过 %d 个字符", maxCLIModelNameRune)
		}
		for _, r := range name {
			if r < ' ' || r == 0x7f {
				return nil, errors.New("显示名称不能包含控制字符")
			}
		}
		if name == id {
			name = ""
		}
		efforts, defaultEffort, err := normalizeCLIModelEfforts(model.Efforts, model.DefaultEffort)
		if err != nil {
			return nil, fmt.Errorf("模型 %s:%w", id, err)
		}
		reasoningEfforts, err := normalizeCLIReasoningEfforts(model.ReasoningEfforts)
		if err != nil {
			return nil, fmt.Errorf("模型 %s:%w", id, err)
		}
		discoveredEfforts, err := normalizeCLIReasoningEfforts(model.DiscoveredReasoningEfforts)
		if err != nil {
			return nil, fmt.Errorf("模型 %s:%w", id, err)
		}
		out = append(out, domain.CLIModel{
			ID: id, Name: name, Efforts: efforts, DefaultEffort: defaultEffort,
			ReasoningEfforts: reasoningEfforts, DiscoveredReasoningEfforts: discoveredEfforts,
		})
	}
	return out, nil
}

func normalizeCLIReasoningEfforts(raw *[]string) (*[]string, error) {
	if raw == nil {
		return nil, nil
	}
	levels := make([]string, 0, len(*raw))
	for _, level := range *raw {
		level = strings.TrimSpace(level)
		supported := false
		for _, allowed := range domain.ExecutorEffortLevels {
			if slices.Contains(allowed, level) {
				supported = true
				break
			}
		}
		if !supported {
			return nil, fmt.Errorf("不支持思考强度 %q", level)
		}
		if !slices.Contains(levels, level) {
			levels = append(levels, level)
		}
	}
	return &levels, nil
}

func validCLIModelID(id string) error {
	if id == "" {
		return errors.New("模型 ID 不能为空")
	}
	if len(id) > maxCLIModelIDLen {
		return fmt.Errorf("模型 ID 长度不能超过 %d 个字符", maxCLIModelIDLen)
	}
	for _, r := range id {
		if r <= ' ' || r == 0x7f || r == '"' || r == '\'' || r == '`' || r == '\\' {
			return fmt.Errorf("模型 ID %q 不能包含空格、引号、反斜杠或控制字符", id)
		}
	}
	return nil
}

// normalizeCLIModelEfforts checks the effort→model ID mapping of a Cursor
// model family: efforts are Cursor's levels and every target is a valid
// model ID. A default outside the mapping is dropped.
func normalizeCLIModelEfforts(efforts map[string]string, defaultEffort string) (map[string]string, string, error) {
	if len(efforts) == 0 {
		return nil, "", nil
	}
	levels := domain.ExecutorEffortLevels["cursor"]
	out := make(map[string]string, len(efforts))
	for effort, raw := range efforts {
		effort, raw = strings.TrimSpace(effort), strings.TrimSpace(raw)
		if !slices.Contains(levels, effort) {
			return nil, "", fmt.Errorf("不支持思考强度 %q", effort)
		}
		if err := validCLIModelID(raw); err != nil {
			return nil, "", err
		}
		out[effort] = raw
	}
	defaultEffort = strings.TrimSpace(defaultEffort)
	if _, ok := out[defaultEffort]; !ok {
		defaultEffort = ""
	}
	return out, defaultEffort, nil
}