Files
kandev/apps/backend/internal/user/service/service.go
T
2026-09-06 17:18:09 +01:00

1109 lines
41 KiB
Go

package service
import (
"context"
"encoding/json"
"errors"
"fmt"
"reflect"
"sort"
"strings"
"time"
"github.com/kandev/kandev/internal/auth/authn"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/events"
"github.com/kandev/kandev/internal/events/bus"
"github.com/kandev/kandev/internal/lsp/installer"
"github.com/kandev/kandev/internal/user/models"
"github.com/kandev/kandev/internal/user/store"
"go.uber.org/zap"
)
// ErrUserSettingsConflict marks an exhausted conditional settings update.
var (
ErrUserNotFound = errors.New("user not found")
ErrValidation = errors.New("validation error")
ErrUserSettingsConflict = store.ErrUserSettingsRevisionConflict
ErrAgentProfileRecentUseConflict = store.ErrAgentProfileRecentUseRevisionConflict
)
const (
changesPanelLayoutFlat = "flat"
changesPanelLayoutTree = "tree"
maxUserSettingsCASAttempts = 3
)
type Service struct {
repo store.Repository
recentUseRepo store.AgentProfileRecentUseRepository
eventBus bus.EventBus
logger *logger.Logger
defaultUser string
}
type UpdateUserSettingsRequest struct {
WorkspaceID *string
KanbanViewMode *string
StartupPage *string
WorkflowFilterID *string
RepositoryIDs *[]string
TasksListSort *string
TasksListGroup *string
TasksListShowDetails *bool
InitialSetupComplete *bool
PreferredShell *string
DefaultEditorID *string
EnablePreviewOnClick *bool
ChatSubmitKey *string
ReviewAutoMarkOnScroll *bool
ConfirmTaskArchive *bool
PreventAutoStartAgentOnOpen *bool
UnreadDivider *bool
AgentGeneratedTaskTitles *bool
MCPTaskAgentProfileDefault *string
ShowAnchoredPromptBar *bool
ShowScrollToLastPrompt *bool
ShowScrollToStart *bool
ShowTranscriptAutoScrollControl *bool
ShowTodoListPanel *bool
ShowTodoListPanelOnlyWhenNotEmpty *bool
ShowReleaseNotification *bool
ReleaseNotesLastSeenVersion *string
LspAutoStartLanguages *[]string
LspAutoInstallLanguages *[]string
LspServerConfigs *map[string]map[string]interface{}
LspStatusLocation *string
SavedLayouts *[]models.SavedLayout
SidebarViews *[]models.SidebarView
SidebarActiveViewID *string
SidebarDraft **models.SidebarViewDraft
ThreadViews *[]models.ThreadView
ThreadActiveViewID *string
ThreadViewDraft **models.ThreadViewDraft
SidebarTaskPrefs *models.SidebarTaskPrefs
SidebarTaskColorAutomation *models.SidebarTaskColorAutomation
SidebarTaskColorPatch *models.SidebarTaskColorPatch
TaskCreateLastUsed *models.TaskCreateLastUsed
JiraSavedViews **json.RawMessage
JiraTaskPresets **json.RawMessage
GitHubSavedPresets **json.RawMessage
GitHubDefaultQueryPresets **json.RawMessage
GitLabSavedPresets **json.RawMessage
AzureDevOpsBrowsePreferences **json.RawMessage
DefaultUtilityAgentID *string
DefaultUtilityModel *string
DefaultUtilityAgentProfileID *string
KeyboardShortcuts *map[string]interface{}
TerminalLinkBehavior *string
TerminalFontFamily *string
TerminalFontSize *int
ChangesPanelLayout *string
LastSeenDisplay *string
SystemMetricsDisplay *SystemMetricsDisplaySettingsPatch
AppStatusBarEnabled *bool
ResolveSessionHostnames *bool
AppStatusBarOrder *models.AppStatusBarOrder
QuickChatTabOrderByWorkspace *map[string][]string
KanbanHiddenStepIDs *map[string][]string
WorkflowIDsWithAutoHideEmptySteps *[]string
}
type SystemMetricsDisplaySettingsPatch struct {
ShowInTopbar *bool
Simplified *bool
}
// NewService builds the user settings service with its repository, event bus,
// and logger.
func NewService(repo store.Repository, eventBus bus.EventBus, log *logger.Logger) *Service {
recentUseRepo, _ := repo.(store.AgentProfileRecentUseRepository)
if recentUseLogger, ok := repo.(interface {
SetAgentProfileRecentUseLogger(*logger.Logger)
}); ok {
recentUseLogger.SetAgentProfileRecentUseLogger(log.WithFields(zap.String("component", "user-store")))
}
return &Service{
repo: repo,
recentUseRepo: recentUseRepo,
eventBus: eventBus,
logger: log.WithFields(zap.String("component", "user-service")),
defaultUser: store.DefaultUserID,
}
}
// settingsUserID resolves the effective user for settings operations:
// the authenticated identity when present, otherwise the default user.
func (s *Service) settingsUserID(ctx context.Context) string {
identity, ok := authn.IdentityFromContext(ctx)
if !ok || identity.Synthetic || identity.UserID == "" {
return s.defaultUser
}
return identity.UserID
}
// GetCurrentUser returns the current (or default) user, mapping a missing
// row to ErrUserNotFound.
func (s *Service) GetCurrentUser(ctx context.Context) (*models.User, error) {
user, err := s.repo.GetUser(ctx, s.settingsUserID(ctx))
if err != nil {
return nil, ErrUserNotFound
}
return user, nil
}
// GetUserSettings returns the current user's persisted settings.
func (s *Service) GetUserSettings(ctx context.Context) (*models.UserSettings, error) {
settings, err := s.repo.GetUserSettings(ctx, s.settingsUserID(ctx))
if err != nil {
return nil, err
}
return settings, nil
}
// PreferredShell returns the user's configured shell.
func (s *Service) PreferredShell(ctx context.Context) (string, error) {
settings, err := s.repo.GetUserSettings(ctx, s.settingsUserID(ctx))
if err != nil {
return "", err
}
return settings.PreferredShell, nil
}
// GetDefaultUtilitySettings returns the user's default utility agent/model settings.
func (s *Service) GetDefaultUtilitySettings(ctx context.Context) (agentID, model string, err error) {
settings, err := s.repo.GetUserSettings(ctx, s.settingsUserID(ctx))
if err != nil {
return "", "", err
}
return settings.DefaultUtilityAgentID, settings.DefaultUtilityModel, nil
}
// GetDefaultUtilityAgentProfileID returns the profile used by new built-in utility actions.
func (s *Service) GetDefaultUtilityAgentProfileID(ctx context.Context) (string, error) {
settings, err := s.repo.GetUserSettings(ctx, s.settingsUserID(ctx))
if err != nil {
return "", err
}
return settings.DefaultUtilityAgentProfileID, nil
}
// UpdateUserSettings applies a partial settings patch field by field,
// validates each group, persists the result under expected-revision CAS, and
// publishes the settings update event.
func (s *Service) UpdateUserSettings(ctx context.Context, req *UpdateUserSettingsRequest) (*models.UserSettings, error) {
var taskCreatePatch *models.TaskCreateLastUsed
if req.TaskCreateLastUsed != nil && !taskCreateLastUsedPatchEmpty(*req.TaskCreateLastUsed) {
taskCreatePatch = req.TaskCreateLastUsed
}
settings, err := s.updateUserSettingsCAS(ctx, func(settings *models.UserSettings) (bool, error) {
// The shallow copy is safe only while every apply* helper replaces
// reference fields (slices, maps, and json.RawMessage) instead of
// mutating them in place. In-place mutation would alias before and make
// DeepEqual miss the write.
before := *settings
if err := applyBasicSettings(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := s.applyChatSubmitKey(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := applyLSPSettings(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := applySavedLayouts(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := applySidebarViews(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := applySidebarViewState(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := applyThreadViews(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := applyThreadViewState(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := applySidebarTaskColorAutomation(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := applySidebarTaskColors(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
if err := applyUserPreferenceBlobs(settings, req); err != nil {
return false, fmt.Errorf("%w: %s", ErrValidation, err.Error())
}
return !reflect.DeepEqual(*settings, before), nil
}, taskCreatePatch)
if err != nil {
return nil, err
}
return settings, nil
}
// applySidebarTaskColorAutomation replaces the complete personal automatic
// color rule set after validating its discriminated target and output shape.
func applySidebarTaskColorAutomation(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.SidebarTaskColorAutomation == nil {
return nil
}
value := *req.SidebarTaskColorAutomation
if err := models.ValidateSidebarTaskColorAutomation(value); err != nil {
return err
}
encoded, err := json.Marshal(value)
if err != nil {
return fmt.Errorf("automatic colors must be serializable: %w", err)
}
var replacement models.SidebarTaskColorAutomation
if err := json.Unmarshal(encoded, &replacement); err != nil {
return fmt.Errorf("automatic colors must be serializable: %w", err)
}
if replacement.Rules == nil {
replacement.Rules = []models.SidebarTaskColorRule{}
}
settings.SidebarTaskColorAutomation = replacement
return nil
}
// updateUserSettingsCAS applies a full-blob user-settings write under
// expected-revision CAS with bounded retry. apply is evaluated against every
// freshly read model and reports whether it mutated it; the immutable
// taskCreatePatch is passed to every attempt so a retry re-applies the same
// task-create merge against the fresh row. A no-op (apply returned false and
// no patch) writes and publishes nothing and returns the freshly read
// (current) settings. Exactly one event is published per successful write.
func (s *Service) updateUserSettingsCAS(
ctx context.Context,
apply func(*models.UserSettings) (bool, error),
taskCreatePatch *models.TaskCreateLastUsed,
) (*models.UserSettings, error) {
userID := s.settingsUserID(ctx)
var lastErr error
for attempt := 0; attempt < maxUserSettingsCASAttempts; attempt++ {
settings, err := s.repo.GetUserSettings(ctx, userID)
if err != nil {
return nil, err
}
applied, err := apply(settings)
if err != nil {
return nil, err
}
if !applied && taskCreatePatch == nil {
// No-op: report the freshly read (current) settings, write nothing,
// publish nothing.
return settings, nil
}
updated, err := s.repo.UpsertUserSettingsPreservingTaskCreateLastUsed(ctx, settings, taskCreatePatch, settings.Revision)
if err == nil {
s.publishUserSettingsEvent(ctx, updated)
return updated, nil
}
if !errors.Is(err, store.ErrUserSettingsRevisionConflict) {
return nil, err
}
lastErr = err
}
s.logger.Warn("user settings update exhausted CAS retries",
zap.Int("attempts", maxUserSettingsCASAttempts),
zap.Error(lastErr),
)
return nil, fmt.Errorf("user settings update exhausted after %d attempts: %w", maxUserSettingsCASAttempts, lastErr)
}
// RecordTaskCreateLastUsed persists the last task-creation choices (a no-op
// for an empty patch) and publishes the settings update event.
func (s *Service) RecordTaskCreateLastUsed(ctx context.Context, patch models.TaskCreateLastUsed) error {
if taskCreateLastUsedPatchEmpty(patch) {
return nil
}
settings, err := s.updateTaskCreateLastUsed(ctx, patch)
if err != nil {
return err
}
s.publishUserSettingsEvent(ctx, settings)
return nil
}
// updateTaskCreateLastUsed delegates the patch to the repository.
func (s *Service) updateTaskCreateLastUsed(ctx context.Context, patch models.TaskCreateLastUsed) (*models.UserSettings, error) {
return s.repo.UpdateTaskCreateLastUsed(ctx, s.settingsUserID(ctx), patch)
}
// taskCreateLastUsedPatchEmpty reports whether every field of the patch is
// unset, i.e. nothing to record.
func taskCreateLastUsedPatchEmpty(patch models.TaskCreateLastUsed) bool {
return patch.RepositoryID == "" &&
patch.Branch == "" &&
patch.AgentProfileID == "" &&
patch.ExecutorProfileID == "" &&
len(patch.WorkflowIDsByWorkspace) == 0
}
// applyBasicSettings copies simple (non-validated) fields from req to settings.
func applyBasicSettings(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if err := applyWorkspaceAndTaskListPreferences(settings, req); err != nil {
return err
}
if err := applyTaskActionPreferences(settings, req); err != nil {
return err
}
applyUtilityPreferences(settings, req)
if err := applyKeyboardShortcuts(settings, req.KeyboardShortcuts); err != nil {
return err
}
if err := applyTerminalLinkBehavior(settings, req.TerminalLinkBehavior); err != nil {
return err
}
if err := applyChangesPanelLayout(settings, req.ChangesPanelLayout); err != nil {
return err
}
if err := applyLastSeenDisplay(settings, req.LastSeenDisplay); err != nil {
return err
}
applySystemMetricsDisplay(settings, req.SystemMetricsDisplay)
if req.AppStatusBarEnabled != nil {
settings.AppStatusBarEnabled = *req.AppStatusBarEnabled
}
if req.ResolveSessionHostnames != nil {
settings.ResolveSessionHostnames = *req.ResolveSessionHostnames
}
if req.AppStatusBarOrder != nil {
settings.AppStatusBarOrder = *req.AppStatusBarOrder
}
if req.QuickChatTabOrderByWorkspace != nil {
if err := validateQuickChatTabOrder(*req.QuickChatTabOrderByWorkspace); err != nil {
return err
}
settings.QuickChatTabOrderByWorkspace = store.CloneStringSliceMap(*req.QuickChatTabOrderByWorkspace)
}
if err := applyTerminalFontPreferences(settings, req); err != nil {
return err
}
return nil
}
// applyWorkspaceAndTaskListPreferences copies workspace, board, and task-list
// fields from the patch, validating the hidden-step map and list sort/group.
func applyWorkspaceAndTaskListPreferences(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.WorkspaceID != nil {
settings.WorkspaceID = *req.WorkspaceID
}
if req.KanbanViewMode != nil {
settings.KanbanViewMode = *req.KanbanViewMode
}
if err := applyStartupPage(settings, req.StartupPage); err != nil {
return err
}
if req.WorkflowFilterID != nil {
settings.WorkflowFilterID = *req.WorkflowFilterID
}
if req.RepositoryIDs != nil {
settings.RepositoryIDs = *req.RepositoryIDs
}
if err := applyTasksListPreferences(settings, req.TasksListSort, req.TasksListGroup); err != nil {
return err
}
if req.TasksListShowDetails != nil {
settings.TasksListShowDetails = *req.TasksListShowDetails
}
if req.InitialSetupComplete != nil {
settings.InitialSetupComplete = *req.InitialSetupComplete
}
if req.PreferredShell != nil {
settings.PreferredShell = strings.TrimSpace(*req.PreferredShell)
}
if req.DefaultEditorID != nil {
settings.DefaultEditorID = strings.TrimSpace(*req.DefaultEditorID)
}
if req.EnablePreviewOnClick != nil {
settings.EnablePreviewOnClick = *req.EnablePreviewOnClick
}
if req.KanbanHiddenStepIDs != nil {
if err := validateKanbanHiddenStepIDs(*req.KanbanHiddenStepIDs); err != nil {
return err
}
settings.KanbanHiddenStepIDs = *req.KanbanHiddenStepIDs
}
if req.WorkflowIDsWithAutoHideEmptySteps != nil {
workflowIDs, err := normalizeWorkflowIDsWithAutoHideEmptySteps(
*req.WorkflowIDsWithAutoHideEmptySteps,
)
if err != nil {
return err
}
settings.WorkflowIDsWithAutoHideEmptySteps = workflowIDs
}
return nil
}
const (
maxQuickChatTabOrderWorkspaces = 200
maxQuickChatTabOrderReferencesPerWorkspace = 200
maxQuickChatTabOrderTotalBytes = maxUserPreferenceBlobBytes
maxKanbanHiddenStepWorkflows = 200
maxKanbanHiddenStepIDsPerWorkflow = 200
// maxKanbanHiddenStepIDsTotalBytes matches maxUserPreferenceBlobBytes, the
// sibling cap for other free-form settings blobs. The count caps above
// bound shape (how many entries), not size (how long each string is); an
// attacker who stays under both count limits could otherwise still submit
// a handful of multi-megabyte ids. This bounds total content regardless
// of shape, and — unlike an HTTP-only body-size guard — it runs inside
// validateKanbanHiddenStepIDs, which both the REST and WebSocket update
// paths call, so it isn't bypassable by whichever transport skips a
// transport-level guard.
maxKanbanHiddenStepIDsTotalBytes = maxUserPreferenceBlobBytes
maxWorkflowIDsWithAutoHideEmptySteps = 200
)
// validateQuickChatTabOrder bounds the client-supplied mixed-tab order before
// it is copied into the settings model. The shape limits keep map and slice
// allocation bounded, while the serialized limit also bounds long opaque ids.
func validateQuickChatTabOrder(orderByWorkspace map[string][]string) error {
if len(orderByWorkspace) > maxQuickChatTabOrderWorkspaces {
return fmt.Errorf(
"quick_chat_tab_order_by_workspace: max %d workspaces allowed",
maxQuickChatTabOrderWorkspaces,
)
}
for workspaceID, references := range orderByWorkspace {
if len(references) > maxQuickChatTabOrderReferencesPerWorkspace {
return fmt.Errorf(
"quick_chat_tab_order_by_workspace[%s]: max %d tab references allowed",
workspaceID,
maxQuickChatTabOrderReferencesPerWorkspace,
)
}
}
serialized, err := json.Marshal(orderByWorkspace)
if err != nil {
return fmt.Errorf("quick_chat_tab_order_by_workspace: must be serializable: %w", err)
}
if len(serialized) > maxQuickChatTabOrderTotalBytes {
return fmt.Errorf(
"quick_chat_tab_order_by_workspace: max %d bytes allowed",
maxQuickChatTabOrderTotalBytes,
)
}
return nil
}
func normalizeWorkflowIDsWithAutoHideEmptySteps(workflowIDs []string) ([]string, error) {
unique := make(map[string]struct{}, len(workflowIDs))
for _, workflowID := range workflowIDs {
unique[workflowID] = struct{}{}
}
if len(unique) > maxWorkflowIDsWithAutoHideEmptySteps {
return nil, fmt.Errorf(
"workflow_ids_with_auto_hide_empty_steps: max %d workflow ids allowed",
maxWorkflowIDsWithAutoHideEmptySteps,
)
}
totalBytes := 0
normalized := make([]string, 0, len(unique))
for workflowID := range unique {
totalBytes += len(workflowID)
if totalBytes > maxUserPreferenceBlobBytes {
return nil, fmt.Errorf(
"workflow_ids_with_auto_hide_empty_steps: max %d bytes allowed",
maxUserPreferenceBlobBytes,
)
}
normalized = append(normalized, workflowID)
}
sort.Strings(normalized)
return normalized, nil
}
// validateKanbanHiddenStepIDs bounds the per-workflow hidden-step-id map so a
// single settings write cannot grow the users.settings JSON blob unboundedly
// on the shared single-writer SQLite connection.
func validateKanbanHiddenStepIDs(hidden map[string][]string) error {
if len(hidden) > maxKanbanHiddenStepWorkflows {
return fmt.Errorf("kanban_hidden_step_ids: max %d workflows allowed", maxKanbanHiddenStepWorkflows)
}
totalBytes := 0
for workflowID, ids := range hidden {
if len(ids) > maxKanbanHiddenStepIDsPerWorkflow {
return fmt.Errorf(
"kanban_hidden_step_ids[%s]: max %d step ids allowed",
workflowID,
maxKanbanHiddenStepIDsPerWorkflow,
)
}
totalBytes += len(workflowID)
for _, id := range ids {
totalBytes += len(id)
}
if totalBytes > maxKanbanHiddenStepIDsTotalBytes {
return fmt.Errorf("kanban_hidden_step_ids: max %d bytes allowed", maxKanbanHiddenStepIDsTotalBytes)
}
}
return nil
}
// applyStartupPage validates and applies the startup page enum.
func applyStartupPage(settings *models.UserSettings, value *string) error {
if value == nil {
return nil
}
v := strings.TrimSpace(*value)
switch v {
case models.StartupPageTaskOverview, models.StartupPageLastTask:
settings.StartupPage = v
return nil
default:
return fmt.Errorf("startup_page must be %q or %q", models.StartupPageTaskOverview, models.StartupPageLastTask)
}
}
// applyTaskActionPreferences copies the task-action preference group
// (archive confirmation, auto-start prevention, transcript display toggles,
// MCP default profile, release notification) from the patch.
func applyTaskActionPreferences(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.ReviewAutoMarkOnScroll != nil {
settings.ReviewAutoMarkOnScroll = *req.ReviewAutoMarkOnScroll
}
if req.ConfirmTaskArchive != nil {
settings.ConfirmTaskArchive = *req.ConfirmTaskArchive
}
if req.PreventAutoStartAgentOnOpen != nil {
settings.PreventAutoStartAgentOnOpen = *req.PreventAutoStartAgentOnOpen
}
if req.UnreadDivider != nil {
settings.UnreadDivider = *req.UnreadDivider
}
if req.AgentGeneratedTaskTitles != nil {
settings.AgentGeneratedTaskTitles = *req.AgentGeneratedTaskTitles
}
if err := applyMCPTaskAgentProfileDefault(settings, req.MCPTaskAgentProfileDefault); err != nil {
return err
}
if req.ShowAnchoredPromptBar != nil {
settings.ShowAnchoredPromptBar = *req.ShowAnchoredPromptBar
}
if req.ShowScrollToLastPrompt != nil {
settings.ShowScrollToLastPrompt = *req.ShowScrollToLastPrompt
}
if req.ShowScrollToStart != nil {
settings.ShowScrollToStart = *req.ShowScrollToStart
}
if req.ShowTranscriptAutoScrollControl != nil {
settings.ShowTranscriptAutoScrollControl = *req.ShowTranscriptAutoScrollControl
}
if req.ShowTodoListPanel != nil {
settings.ShowTodoListPanel = *req.ShowTodoListPanel
}
if req.ShowTodoListPanelOnlyWhenNotEmpty != nil {
settings.ShowTodoListPanelOnlyWhenNotEmpty = *req.ShowTodoListPanelOnlyWhenNotEmpty
}
if req.ShowReleaseNotification != nil {
settings.ShowReleaseNotification = *req.ShowReleaseNotification
}
return nil
}
// applyUtilityPreferences copies the utility-agent defaults and release-notes
// version from the patch.
func applyUtilityPreferences(settings *models.UserSettings, req *UpdateUserSettingsRequest) {
if req.ReleaseNotesLastSeenVersion != nil {
settings.ReleaseNotesLastSeenVersion = *req.ReleaseNotesLastSeenVersion
}
if req.DefaultUtilityAgentID != nil {
settings.DefaultUtilityAgentID = strings.TrimSpace(*req.DefaultUtilityAgentID)
}
if req.DefaultUtilityModel != nil {
settings.DefaultUtilityModel = strings.TrimSpace(*req.DefaultUtilityModel)
}
if req.DefaultUtilityAgentProfileID != nil {
settings.DefaultUtilityAgentProfileID = strings.TrimSpace(*req.DefaultUtilityAgentProfileID)
}
}
// applyKeyboardShortcuts validates and applies the keyboard shortcut map.
func applyKeyboardShortcuts(settings *models.UserSettings, value *map[string]interface{}) error {
if value == nil {
return nil
}
if err := validateKeyboardShortcuts(*value); err != nil {
return err
}
settings.KeyboardShortcuts = *value
return nil
}
// applySystemMetricsDisplay applies the topbar metrics display patch.
func applySystemMetricsDisplay(settings *models.UserSettings, value *SystemMetricsDisplaySettingsPatch) {
if value == nil {
return
}
if value.ShowInTopbar != nil {
settings.SystemMetricsDisplay.ShowInTopbar = *value.ShowInTopbar
}
if value.Simplified != nil {
settings.SystemMetricsDisplay.Simplified = *value.Simplified
}
}
// applyTerminalFontPreferences applies the terminal font family and validates
// the font size range.
func applyTerminalFontPreferences(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.TerminalFontFamily != nil {
settings.TerminalFontFamily = strings.TrimSpace(*req.TerminalFontFamily)
}
if req.TerminalFontSize == nil {
return nil
}
v := *req.TerminalFontSize
if v != 0 && (v < 8 || v > 24) {
return errors.New("terminal_font_size must be 0 (default) or between 8 and 24")
}
settings.TerminalFontSize = v
return nil
}
// applyMCPTaskAgentProfileDefault validates and applies the MCP task agent
// profile default enum.
func applyMCPTaskAgentProfileDefault(settings *models.UserSettings, value *string) error {
if value == nil {
return nil
}
switch *value {
case models.MCPTaskAgentProfileDefaultCurrentTask, models.MCPTaskAgentProfileDefaultWorkspaceDefault:
settings.MCPTaskAgentProfileDefault = *value
return nil
default:
return fmt.Errorf("mcp_task_agent_profile_default must be %q or %q",
models.MCPTaskAgentProfileDefaultCurrentTask,
models.MCPTaskAgentProfileDefaultWorkspaceDefault,
)
}
}
// applyTasksListPreferences validates and applies the task list sort and
// group enums, defaulting empty values.
func applyTasksListPreferences(settings *models.UserSettings, sortValue, groupValue *string) error {
if sortValue != nil {
v := strings.TrimSpace(*sortValue)
if v == "" {
v = models.TasksListSortDefault
}
if !models.IsValidTasksListSort(v) {
return fmt.Errorf("tasks_list_sort must be one of %s", strings.Join(models.TasksListSortValues(), ", "))
}
settings.TasksListSort = v
}
if groupValue != nil {
v := strings.TrimSpace(*groupValue)
if v == "" {
v = models.TasksListGroupDefault
}
if !models.IsValidTasksListGroup(v) {
return fmt.Errorf("tasks_list_group must be one of %s", strings.Join(models.TasksListGroupValues(), ", "))
}
settings.TasksListGroup = v
}
return nil
}
// applyTerminalLinkBehavior validates and applies the terminal link behavior
// enum.
func applyTerminalLinkBehavior(settings *models.UserSettings, value *string) error {
if value == nil {
return nil
}
v := strings.TrimSpace(*value)
if v != "new_tab" && v != "browser_panel" {
return errors.New("terminal_link_behavior must be 'new_tab' or 'browser_panel'")
}
settings.TerminalLinkBehavior = v
return nil
}
// applyChangesPanelLayout validates and applies the changes panel layout
// enum (flat or tree).
func applyChangesPanelLayout(settings *models.UserSettings, value *string) error {
if value == nil {
return nil
}
v := strings.TrimSpace(*value)
if v != changesPanelLayoutFlat && v != changesPanelLayoutTree {
return errors.New("changes_panel_layout must be 'flat' or 'tree'")
}
settings.ChangesPanelLayout = v
return nil
}
// applyLastSeenDisplay validates and applies the last-seen display enum
// (absolute or relative).
func applyLastSeenDisplay(settings *models.UserSettings, value *string) error {
if value == nil {
return nil
}
v := strings.TrimSpace(*value)
if v != models.LastSeenDisplayAbsolute && v != models.LastSeenDisplayRelative {
return errors.New("last_seen_display must be 'absolute' or 'relative'")
}
settings.LastSeenDisplay = v
return nil
}
// applyChatSubmitKey validates and applies the chat_submit_key setting.
func (s *Service) applyChatSubmitKey(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.ChatSubmitKey == nil {
return nil
}
key := strings.TrimSpace(*req.ChatSubmitKey)
if key != "enter" && key != "cmd_enter" {
return errors.New("chat_submit_key must be 'enter' or 'cmd_enter'")
}
s.logger.Info("[Settings] Setting ChatSubmitKey", zap.String("value", key))
settings.ChatSubmitKey = key
return nil
}
// applyLSPSettings validates and applies LSP-related settings.
func applyLSPSettings(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.LspAutoStartLanguages != nil {
if err := validateLSPLanguages(*req.LspAutoStartLanguages); err != nil {
return fmt.Errorf("lsp_auto_start_languages: %w", err)
}
settings.LspAutoStartLanguages = *req.LspAutoStartLanguages
}
if req.LspAutoInstallLanguages != nil {
if err := validateLSPAutoInstallLanguages(*req.LspAutoInstallLanguages); err != nil {
return fmt.Errorf("lsp_auto_install_languages: %w", err)
}
settings.LspAutoInstallLanguages = *req.LspAutoInstallLanguages
}
if req.LspServerConfigs != nil {
settings.LspServerConfigs = *req.LspServerConfigs
}
if req.LspStatusLocation != nil {
switch *req.LspStatusLocation {
case models.LspStatusLocationToolbar, models.LspStatusLocationStatusBar:
settings.LspStatusLocation = *req.LspStatusLocation
default:
return fmt.Errorf(
"lsp_status_location must be %q or %q",
models.LspStatusLocationToolbar,
models.LspStatusLocationStatusBar,
)
}
}
return nil
}
const maxSavedLayouts = 20
// applySavedLayouts validates and applies the saved_layouts setting.
func applySavedLayouts(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.SavedLayouts == nil {
return nil
}
layouts := *req.SavedLayouts
if len(layouts) > maxSavedLayouts {
return fmt.Errorf("saved_layouts: max %d layouts allowed", maxSavedLayouts)
}
seen := make(map[string]struct{}, len(layouts))
hasDefault := false
for i := range layouts {
if strings.TrimSpace(layouts[i].ID) == "" {
return errors.New("saved_layouts: layout id must not be empty")
}
if strings.TrimSpace(layouts[i].Name) == "" {
return errors.New("saved_layouts: layout name must not be empty")
}
if _, dup := seen[layouts[i].ID]; dup {
return fmt.Errorf("saved_layouts: duplicate layout id %q", layouts[i].ID)
}
seen[layouts[i].ID] = struct{}{}
if layouts[i].IsDefault {
if hasDefault {
return errors.New("saved_layouts: at most one default layout allowed")
}
hasDefault = true
}
}
settings.SavedLayouts = layouts
return nil
}
const maxSidebarViews = 50
// applySidebarViews validates and applies the sidebar_views setting.
func applySidebarViews(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.SidebarViews == nil {
return nil
}
views := *req.SidebarViews
if len(views) > maxSidebarViews {
return fmt.Errorf("sidebar_views: max %d views allowed", maxSidebarViews)
}
seen := make(map[string]struct{}, len(views))
for i := range views {
if strings.TrimSpace(views[i].ID) == "" {
return errors.New("sidebar_views: view id must not be empty")
}
if strings.TrimSpace(views[i].Name) == "" {
return errors.New("sidebar_views: view name must not be empty")
}
if _, dup := seen[views[i].ID]; dup {
return fmt.Errorf("sidebar_views: duplicate view id %q", views[i].ID)
}
seen[views[i].ID] = struct{}{}
}
if len(views) == 0 && req.SidebarActiveViewID == nil {
views = store.DefaultSidebarViews()
settings.SidebarActiveViewID = store.DefaultSidebarViewID
}
settings.SidebarViews = views
return nil
}
// applySidebarViewState validates and applies the active sidebar view id and
// the sidebar draft.
func applySidebarViewState(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.SidebarActiveViewID != nil {
activeViewID := strings.TrimSpace(*req.SidebarActiveViewID)
if activeViewID == "" {
return errors.New("sidebar_active_view_id must not be empty")
}
if !sidebarViewIDExists(settings.SidebarViews, activeViewID) {
return fmt.Errorf("sidebar_active_view_id %q does not match any saved view", activeViewID)
}
settings.SidebarActiveViewID = activeViewID
}
if req.SidebarDraft != nil {
settings.SidebarDraft = *req.SidebarDraft
}
return nil
}
// sidebarViewIDExists reports whether a view with the given id is saved.
func sidebarViewIDExists(views []models.SidebarView, id string) bool {
for _, view := range views {
if view.ID == id {
return true
}
}
return false
}
const maxUserPreferenceBlobBytes = 64 * 1024
// applyUserPreferenceBlobs applies each free-form preference blob (sidebar
// task prefs, Jira/GitHub/GitLab/Azure saved views and presets), validating
// size and shape via applyUserPreferenceBlob.
func applyUserPreferenceBlobs(settings *models.UserSettings, req *UpdateUserSettingsRequest) error {
if req.SidebarTaskPrefs != nil {
settings.SidebarTaskPrefs = *req.SidebarTaskPrefs
}
if err := applyUserPreferenceBlob("jira_saved_views", req.JiraSavedViews, &settings.JiraSavedViews); err != nil {
return err
}
if err := applyUserPreferenceBlob("jira_task_presets", req.JiraTaskPresets, &settings.JiraTaskPresets); err != nil {
return err
}
if err := applyUserPreferenceBlob("github_saved_presets", req.GitHubSavedPresets, &settings.GitHubSavedPresets); err != nil {
return err
}
if err := applyUserPreferenceBlob("github_default_query_presets", req.GitHubDefaultQueryPresets, &settings.GitHubDefaultQueryPresets); err != nil {
return err
}
if err := applyUserPreferenceBlob("gitlab_saved_presets", req.GitLabSavedPresets, &settings.GitLabSavedPresets); err != nil {
return err
}
if err := applyUserPreferenceBlob("azure_devops_browse_preferences", req.AzureDevOpsBrowsePreferences, &settings.AzureDevOpsBrowsePreferences); err != nil {
return err
}
return nil
}
// applyUserPreferenceBlob applies one PATCH-distinguished blob: omitted
// leaves the target untouched, explicit null clears it, and a value is
// validated before being stored.
func applyUserPreferenceBlob(field string, value **json.RawMessage, target *json.RawMessage) error {
if value == nil {
return nil
}
if *value == nil {
*target = nil
return nil
}
if err := validateUserPreferenceBlob(field, **value); err != nil {
return err
}
*target = **value
return nil
}
// validateUserPreferenceBlob enforces the blob size cap and JSON shape
// (object, array, or null).
func validateUserPreferenceBlob(field string, value json.RawMessage) error {
if len(value) > maxUserPreferenceBlobBytes {
return fmt.Errorf("%s: max %d bytes allowed", field, maxUserPreferenceBlobBytes)
}
var decoded interface{}
if err := json.Unmarshal(value, &decoded); err != nil {
return fmt.Errorf("%s: must be valid JSON", field)
}
switch decoded.(type) {
case nil, []interface{}, map[string]interface{}:
return nil
default:
return fmt.Errorf("%s: must be a JSON object, array, or null", field)
}
}
// publishUserSettingsEvent broadcasts the full settings snapshot on the
// UserSettingsUpdated event bus topic so connected clients stay in sync.
func (s *Service) publishUserSettingsEvent(ctx context.Context, settings *models.UserSettings) {
if s.eventBus == nil || settings == nil {
return
}
data := map[string]interface{}{
"user_id": settings.UserID,
"workspace_id": settings.WorkspaceID,
"kanban_view_mode": settings.KanbanViewMode,
"startup_page": models.NormalizeStartupPage(settings.StartupPage),
"workflow_filter_id": settings.WorkflowFilterID,
"repository_ids": settings.RepositoryIDs,
"tasks_list_sort": settings.TasksListSort,
"tasks_list_group": settings.TasksListGroup,
"tasks_list_show_details": settings.TasksListShowDetails,
"initial_setup_complete": settings.InitialSetupComplete,
"preferred_shell": settings.PreferredShell,
"default_editor_id": settings.DefaultEditorID,
"enable_preview_on_click": settings.EnablePreviewOnClick,
"chat_submit_key": settings.ChatSubmitKey,
"review_auto_mark_on_scroll": settings.ReviewAutoMarkOnScroll,
"confirm_task_archive": settings.ConfirmTaskArchive,
"prevent_auto_start_agent_on_open": settings.PreventAutoStartAgentOnOpen,
"unread_divider": settings.UnreadDivider,
"agent_generated_task_titles": settings.AgentGeneratedTaskTitles,
"mcp_task_agent_profile_default": models.NormalizeMCPTaskAgentProfileDefault(settings.MCPTaskAgentProfileDefault),
"show_anchored_prompt_bar": settings.ShowAnchoredPromptBar,
"show_scroll_to_last_prompt": settings.ShowScrollToLastPrompt,
"show_scroll_to_start": settings.ShowScrollToStart,
"show_transcript_auto_scroll_control": settings.ShowTranscriptAutoScrollControl,
"show_todo_list_panel": settings.ShowTodoListPanel,
"show_todo_list_panel_only_when_not_empty": settings.ShowTodoListPanelOnlyWhenNotEmpty,
"show_release_notification": settings.ShowReleaseNotification,
"release_notes_last_seen_version": settings.ReleaseNotesLastSeenVersion,
"lsp_auto_start_languages": settings.LspAutoStartLanguages,
"lsp_auto_install_languages": settings.LspAutoInstallLanguages,
"lsp_server_configs": settings.LspServerConfigs,
"lsp_status_location": models.NormalizeLspStatusLocation(settings.LspStatusLocation),
"saved_layouts": settings.SavedLayouts,
"sidebar_views": settings.SidebarViews,
"sidebar_active_view_id": settings.SidebarActiveViewID,
"sidebar_draft": settings.SidebarDraft,
"thread_views": settings.ThreadViews,
"thread_active_view_id": settings.ThreadActiveViewID,
"thread_view_draft": settings.ThreadViewDraft,
"sidebar_task_prefs": settings.SidebarTaskPrefs,
"sidebar_task_color_automation": settings.SidebarTaskColorAutomation,
"sidebar_task_colors": models.CloneSidebarTaskColors(settings.SidebarTaskColors),
"task_create_last_used": settings.TaskCreateLastUsed,
"jira_saved_views": settings.JiraSavedViews,
"jira_task_presets": settings.JiraTaskPresets,
"github_saved_presets": settings.GitHubSavedPresets,
"github_default_query_presets": settings.GitHubDefaultQueryPresets,
"gitlab_saved_presets": settings.GitLabSavedPresets,
"azure_devops_browse_preferences": settings.AzureDevOpsBrowsePreferences,
"default_utility_agent_id": settings.DefaultUtilityAgentID,
"default_utility_model": settings.DefaultUtilityModel,
"default_utility_agent_profile_id": settings.DefaultUtilityAgentProfileID,
"keyboard_shortcuts": settings.KeyboardShortcuts,
"terminal_link_behavior": settings.TerminalLinkBehavior,
"terminal_font_family": settings.TerminalFontFamily,
"terminal_font_size": settings.TerminalFontSize,
"changes_panel_layout": settings.ChangesPanelLayout,
"last_seen_display": models.NormalizeLastSeenDisplay(settings.LastSeenDisplay),
"system_metrics_display": settings.SystemMetricsDisplay,
"app_status_bar_enabled": settings.AppStatusBarEnabled,
"resolve_session_hostnames": settings.ResolveSessionHostnames,
"app_status_bar_order": settings.AppStatusBarOrder,
"kanban_hidden_step_ids": settings.KanbanHiddenStepIDs,
"workflow_ids_with_auto_hide_empty_steps": settings.WorkflowIDsWithAutoHideEmptySteps,
"revision": settings.Revision,
"updated_at": settings.UpdatedAt.Format(time.RFC3339),
}
if err := s.eventBus.Publish(ctx, events.UserSettingsUpdated, bus.NewEvent(events.UserSettingsUpdated, "user-service", data)); err != nil {
s.logger.Error("failed to publish user settings event", zap.Error(err))
}
}
// validateKeyboardShortcuts checks the shortcut map shape: each entry must be
// an object with a non-empty key and boolean-only modifiers.
func validateKeyboardShortcuts(shortcuts map[string]interface{}) error {
for name, raw := range shortcuts {
shortcut, ok := raw.(map[string]interface{})
if !ok {
return fmt.Errorf("keyboard_shortcuts.%s must be an object", name)
}
key, ok := shortcut["key"].(string)
if !ok || strings.TrimSpace(key) == "" {
return fmt.Errorf("keyboard_shortcuts.%s.key must be a non-empty string", name)
}
if modsRaw, exists := shortcut["modifiers"]; exists {
mods, ok := modsRaw.(map[string]interface{})
if !ok {
return fmt.Errorf("keyboard_shortcuts.%s.modifiers must be an object", name)
}
for mod, v := range mods {
if _, ok := v.(bool); !ok {
return fmt.Errorf("keyboard_shortcuts.%s.modifiers.%s must be a boolean", name, mod)
}
}
}
}
return nil
}
// validateLSPLanguages rejects languages the LSP installer does not support.
func validateLSPLanguages(langs []string) error {
supported := installer.SupportedLanguages()
for _, lang := range langs {
if _, ok := supported[lang]; !ok {
return fmt.Errorf("unsupported language: %s", lang)
}
}
return nil
}
// validateLSPAutoInstallLanguages rejects languages that are unsupported or
// cannot be auto-installed.
func validateLSPAutoInstallLanguages(langs []string) error {
if err := validateLSPLanguages(langs); err != nil {
return err
}
for _, lang := range langs {
if !installer.SupportsAutoInstall(lang) {
return fmt.Errorf("language %s does not support auto-install", lang)
}
}
return nil
}
// ClearDefaultEditorID clears the saved default editor when it matches the
// given editor id (used when an editor is uninstalled), persisting and
// publishing the change.
func (s *Service) ClearDefaultEditorID(ctx context.Context, editorID string) error {
if editorID == "" {
return nil
}
_, err := s.updateUserSettingsCAS(ctx, func(settings *models.UserSettings) (bool, error) {
if settings.DefaultEditorID != editorID {
return false, nil
}
settings.DefaultEditorID = ""
return true, nil
}, nil)
return err
}