From 7e207c6fd1b293796355c2bb811091b3a563de78 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Fiere?= Date: Wed, 12 Aug 2026 12:19:12 +0200 Subject: [PATCH] feat: add agent profile duplicate (#2550) --- .../lifecycle/profile_resolver_test.go | 5 + .../agent/settings/controller/profile_crud.go | 209 ++++++++++ .../controller/profile_duplicate_test.go | 369 ++++++++++++++++++ .../settings/controller/reconciler_test.go | 92 ++++- .../internal/agent/settings/dto/dto.go | 10 + .../agent/settings/handlers/handlers.go | 74 +++- .../interim_settings_interlock_test.go | 1 + .../profile_duplicate_handlers_test.go | 329 ++++++++++++++++ .../internal/agent/settings/store/sqlite.go | 126 +++++- .../settings/store/sqlite_duplicate_test.go | 291 ++++++++++++++ .../internal/agent/settings/store/store.go | 30 ++ .../internal/gateway/websocket/access_test.go | 63 +++ .../backend/internal/gateway/websocket/hub.go | 46 ++- .../gateway/websocket/task_notifications.go | 22 +- apps/web/app/actions/agents.ts | 14 + .../agent-profile-duplicate-action.test.tsx | 190 +++++++++ .../agent-profile-duplicate-action.ts | 133 +++++++ .../settings/agent-profile-page-state.test.ts | 132 +++++++ .../settings/agent-profile-page-state.ts | 31 +- .../settings/agent-profile-page.tsx | 41 +- .../agents/agent-profiles-section.test.tsx | 39 +- .../agents/agent-profiles-section.tsx | 79 ++-- .../settings/settings-save-provider.test.tsx | 103 ++++- .../settings/settings-save-provider.tsx | 223 +++++++++-- .../settings/agent-profile-duplicate.spec.ts | 131 +++++++ .../mobile-agent-profile-duplicate.spec.ts | 79 ++++ .../settings/use-profile-duplicate.test.ts | 189 +++++++++ .../domains/settings/use-profile-duplicate.ts | 116 ++++++ apps/web/lib/routing/client-router.test.ts | 104 +++-- apps/web/lib/routing/navigation-guard.ts | 29 +- apps/web/lib/state/slices/settings/types.ts | 47 +++ apps/web/lib/ws/handlers/agents.test.ts | 213 +++++++++- apps/web/lib/ws/handlers/agents.ts | 143 +++++-- apps/web/src/locales/en/agents.json | 7 +- apps/web/src/locales/pseudo/agents.json | 7 +- docs/plans/agent-profile-duplicate/plan.md | 256 ++++++++++++ .../task-01-backend-duplicate-endpoint.md | 81 ++++ .../task-02-frontend-duplicate-ui.md | 72 ++++ .../task-03-duplicate-e2e.md | 56 +++ docs/specs/agents/profile-duplicate.md | 106 +++++ 40 files changed, 4094 insertions(+), 194 deletions(-) create mode 100644 apps/backend/internal/agent/settings/controller/profile_duplicate_test.go create mode 100644 apps/backend/internal/agent/settings/handlers/profile_duplicate_handlers_test.go create mode 100644 apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go create mode 100644 apps/web/components/settings/agent-profile-duplicate-action.test.tsx create mode 100644 apps/web/components/settings/agent-profile-duplicate-action.ts create mode 100644 apps/web/components/settings/agent-profile-page-state.test.ts create mode 100644 apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts create mode 100644 apps/web/e2e/tests/settings/mobile-agent-profile-duplicate.spec.ts create mode 100644 apps/web/hooks/domains/settings/use-profile-duplicate.test.ts create mode 100644 apps/web/hooks/domains/settings/use-profile-duplicate.ts create mode 100644 docs/plans/agent-profile-duplicate/plan.md create mode 100644 docs/plans/agent-profile-duplicate/task-01-backend-duplicate-endpoint.md create mode 100644 docs/plans/agent-profile-duplicate/task-02-frontend-duplicate-ui.md create mode 100644 docs/plans/agent-profile-duplicate/task-03-duplicate-e2e.md create mode 100644 docs/specs/agents/profile-duplicate.md diff --git a/apps/backend/internal/agent/runtime/lifecycle/profile_resolver_test.go b/apps/backend/internal/agent/runtime/lifecycle/profile_resolver_test.go index c27bb9bf1e..a13e328856 100644 --- a/apps/backend/internal/agent/runtime/lifecycle/profile_resolver_test.go +++ b/apps/backend/internal/agent/runtime/lifecycle/profile_resolver_test.go @@ -75,6 +75,11 @@ func (m *MockRepository) CreateAgentProfile(ctx context.Context, profile *models return nil } +// DuplicateAgentProfile implements the settings store interface for the resolver test fakes. +func (m *MockRepository) DuplicateAgentProfile(ctx context.Context, input store.DuplicateAgentProfileInput) error { + return nil +} + func (m *MockRepository) UpdateAgentProfile(ctx context.Context, profile *models.AgentProfile) error { if m.updateAgentProfileFn != nil { return m.updateAgentProfileFn(ctx, profile) diff --git a/apps/backend/internal/agent/settings/controller/profile_crud.go b/apps/backend/internal/agent/settings/controller/profile_crud.go index 946e0d0703..1ee348fa41 100644 --- a/apps/backend/internal/agent/settings/controller/profile_crud.go +++ b/apps/backend/internal/agent/settings/controller/profile_crud.go @@ -2,6 +2,8 @@ package controller import ( "context" + "database/sql" + "errors" "fmt" "regexp" "sort" @@ -14,6 +16,7 @@ import ( "github.com/kandev/kandev/internal/agent/settings/dto" "github.com/kandev/kandev/internal/agent/settings/models" "github.com/kandev/kandev/internal/agent/settings/profileconfig" + "github.com/kandev/kandev/internal/agent/settings/store" "github.com/kandev/kandev/internal/secrets" ) @@ -254,6 +257,212 @@ func (c *Controller) UpdateProfile(ctx context.Context, req UpdateProfileRequest return &result, nil } +type DuplicateProfileRequest struct { + ID string +} + +// DuplicateProfile creates an independent copy of an existing profile. The +// copy keeps every configuration field (model, mode, config options, CLI +// flags, env vars, launcher prefix, auto-approve flags, enabled state, MCP +// config) under a fresh row named " Copy", so a user can start a +// variant from a working profile without re-entering it. Runtime state is +// intentionally not copied: the copy starts idle with no pause reason, +// last-run timestamp, or consecutive-failure count. No in-use checks apply — +// a brand-new row cannot be referenced by sessions, watchers, automations, +// or routing tiers yet. +// +// The copy is committed in one repository transaction (row + MCP config), so +// a failure leaves no partial profile and a disabled source never becomes +// briefly selectable. +// +// The source profile and MCP row are read up front, then the repository +// re-verifies those revisions inside the transaction; a concurrent writer +// between the reads and the insert aborts with a retryable error, so the +// copy always reflects one consistent snapshot of the source. +func (c *Controller) DuplicateProfile(ctx context.Context, req DuplicateProfileRequest) (*dto.AgentProfileDTO, error) { + source, err := c.repo.GetAgentProfile(ctx, req.ID) + if err != nil { + if isProfileNotFoundErr(err) { + return nil, ErrAgentProfileNotFound + } + return nil, err + } + // Office-scoped profiles are owned by the workspace-scoped office API + // surface and hidden from this instance-level settings surface (the UI + // filters them via filterGlobalProfiles). Refuse to duplicate them here so + // the endpoint cannot read or clone another workspace's configuration; + // 404 keeps the existence of office profiles hidden. + if source.WorkspaceID != "" { + return nil, ErrAgentProfileNotFound + } + for attempt := 0; ; attempt++ { + // A source without an MCP row leaves the copy without one: the + // default-config semantics and boot EnsureDefaultMcpConfig cover + // MCP-supporting agents. + var sourceMcp *models.AgentProfileMcpConfig + sourceMcp, err = c.repo.GetAgentProfileMcpConfig(ctx, source.ID) + if err != nil && !errors.Is(err, sql.ErrNoRows) { + return nil, err + } + if errors.Is(err, sql.ErrNoRows) { + sourceMcp = nil + } + clone := duplicateClone(source) + var mcpCopy *models.AgentProfileMcpConfig + if sourceMcp != nil { + mcpCopy = &models.AgentProfileMcpConfig{ + Enabled: sourceMcp.Enabled, + Servers: cloneStringInterfaceMap(sourceMcp.Servers), + Meta: cloneStringInterfaceMap(sourceMcp.Meta), + } + } + err = c.repo.DuplicateAgentProfile(ctx, store.DuplicateAgentProfileInput{ + Source: source, + SourceMcp: sourceMcp, + Profile: clone, + McpConfig: mcpCopy, + }) + if err == nil { + result := toProfileDTO(clone) + return &result, nil + } + // A source deleted between the snapshot read and the transaction is a + // deterministic 404, not a retryable race: the copy has nothing to + // reflect, so surface it immediately instead of re-reading the source + // up to maxDuplicateRetries times. + if errors.Is(err, store.ErrSourceProfileNotFound) { + return nil, ErrAgentProfileNotFound + } + if !isRetryableDuplicateErr(err) || attempt >= maxDuplicateRetries { + return nil, err + } + source, err = c.repo.GetAgentProfile(ctx, req.ID) + if err != nil { + if isProfileNotFoundErr(err) { + return nil, ErrAgentProfileNotFound + } + return nil, err + } + } +} + +// maxDuplicateRetries bounds the number of re-attempts after a concurrent +// source change. One retry covers the common single-writer race; the cap +// prevents a hot loop under sustained concurrent edits. +const maxDuplicateRetries = 2 + +// isRetryableDuplicateErr reports whether a duplicate attempt failed because +// the source changed concurrently (revision mismatch or a WAL snapshot-isolation +// busy error on the write) rather than deterministically. A deleted source is +// intentionally absent: DuplicateProfile maps ErrSourceProfileNotFound to 404 +// before consulting this set. +func isRetryableDuplicateErr(err error) bool { + return errors.Is(err, store.ErrProfileChanged) || + strings.Contains(err.Error(), "database is locked") || + strings.Contains(err.Error(), "database table is locked") +} + +// duplicateClone builds the copy row from the source profile. Runtime state +// is intentionally not copied: the copy starts idle with no pause reason, +// last-run timestamp, or consecutive-failure count. +func duplicateClone(source *models.AgentProfile) *models.AgentProfile { + return &models.AgentProfile{ + AgentID: source.AgentID, + Name: strings.TrimSpace(source.Name) + " Copy", + AgentDisplayName: source.AgentDisplayName, + Model: source.Model, + FallbackModel: strings.TrimSpace(source.FallbackModel), + AutoFallback: source.AutoFallback, + Mode: source.Mode, + ConfigOptions: profileconfig.SanitizeConfigOptions(cloneStringMap(source.ConfigOptions)), + AllowIndexing: source.AllowIndexing, + AutoApprove: source.AutoApprove, + CLIPassthrough: source.CLIPassthrough, + CLIFlags: cloneCLIFlags(source.CLIFlags), + EnvVars: cloneEnvVars(source.EnvVars), + CommandPrefix: source.CommandPrefix, + UserModified: true, + Enabled: source.Enabled, + WorkspaceID: source.WorkspaceID, + Role: source.Role, + Icon: source.Icon, + ReportsTo: source.ReportsTo, + SkillIDs: source.SkillIDs, + DesiredSkills: source.DesiredSkills, + MaxConcurrentSessions: source.MaxConcurrentSessions, + CooldownSec: source.CooldownSec, + SkipIdleRuns: source.SkipIdleRuns, + FailureThreshold: cloneIntPtr(source.FailureThreshold), + ExecutorPreference: source.ExecutorPreference, + BudgetMonthlyCents: source.BudgetMonthlyCents, + Settings: source.Settings, + Permissions: source.Permissions, + DangerouslySkipPermissions: source.DangerouslySkipPermissions, + CustomPrompt: source.CustomPrompt, + } +} + +// isProfileNotFoundErr reports whether err means "no live profile row with +// that ID". The sqlite store surfaces it as sql.ErrNoRows from GetAgentProfile +// and as an "agent profile not found" message from the update/delete paths; +// fakes and future stores may use either shape. +func isProfileNotFoundErr(err error) bool { + return errors.Is(err, sql.ErrNoRows) || strings.Contains(err.Error(), "agent profile not found") +} + +// cloneCLIFlags returns a copy of the profile's CLI flag list so the +// duplicated profile never shares slice memory with the source. +func cloneCLIFlags(in []models.CLIFlag) []models.CLIFlag { + out := make([]models.CLIFlag, len(in)) + copy(out, in) + return out +} + +// cloneEnvVars returns a copy of the profile's env-var list (secret +// references included) so the duplicated profile never shares slice memory +// with the source. +func cloneEnvVars(in []models.ProfileEnvVar) []models.ProfileEnvVar { + out := make([]models.ProfileEnvVar, len(in)) + copy(out, in) + return out +} + +// cloneStringMap returns a shallow copy of a string map, preserving nil so a +// source with no config options stays nil on the copy. +func cloneStringMap(in map[string]string) map[string]string { + if in == nil { + return nil + } + out := make(map[string]string, len(in)) + for k, v := range in { + out[k] = v + } + return out +} + +// cloneStringInterfaceMap returns a shallow copy of a string-keyed interface +// map (used for MCP servers/meta), preserving nil. +func cloneStringInterfaceMap(in map[string]interface{}) map[string]interface{} { + if in == nil { + return nil + } + out := make(map[string]interface{}, len(in)) + for k, v := range in { + out[k] = v + } + return out +} + +// cloneIntPtr returns a copy of an int pointer so the duplicated profile never +// aliases the source's field, preserving nil. +func cloneIntPtr(in *int) *int { + if in == nil { + return nil + } + v := *in + return &v +} + func (c *Controller) validateGlobalSecretRefs(ctx context.Context, envVars []dto.ProfileEnvVarDTO) error { if c.secretStore == nil { return nil diff --git a/apps/backend/internal/agent/settings/controller/profile_duplicate_test.go b/apps/backend/internal/agent/settings/controller/profile_duplicate_test.go new file mode 100644 index 0000000000..96e9cb927c --- /dev/null +++ b/apps/backend/internal/agent/settings/controller/profile_duplicate_test.go @@ -0,0 +1,369 @@ +package controller + +import ( + "context" + "errors" + "testing" + "time" + + "github.com/kandev/kandev/internal/agent/settings/models" + "github.com/kandev/kandev/internal/agent/settings/store" +) + +// sourceProfile returns a fully-populated kanban-flavour profile so every +// copy assertion has a concrete value to compare against. +func sourceProfile() *models.AgentProfile { + failureThreshold := 4 + lastRun := time.Date(2026, 8, 1, 12, 0, 0, 0, time.UTC) + return &models.AgentProfile{ + ID: "source-1", + AgentID: "agent-1", + Name: "Default", + AgentDisplayName: "Claude Code", + Model: "claude-sonnet", + FallbackModel: "claude-haiku", + AutoFallback: true, + Mode: "plan", + ConfigOptions: map[string]string{"effort": "high"}, + AllowIndexing: true, + AutoApprove: true, + CLIPassthrough: true, + CLIFlags: []models.CLIFlag{ + {Description: "Allow all tools", Flag: "--allow-all-tools", Enabled: true}, + {Description: "Custom", Flag: "--my-flag value", Enabled: false}, + }, + EnvVars: []models.ProfileEnvVar{ + {Key: "FOO", Value: "bar"}, + {Key: "TOKEN", SecretID: "sec-1"}, + }, + CommandPrefix: "greywall --", + UserModified: true, + Enabled: true, + // Office enrichment configuration — must be copied. WorkspaceID stays + // empty (kanban): the settings duplicate endpoint rejects office-scoped + // sources, so the copy assertions cover the enrichment fields on a + // kanban-scoped profile. + WorkspaceID: "", + Role: "worker", + Icon: "🤖", + ReportsTo: "profile-other", + SkillIDs: `["s1","s2"]`, + DesiredSkills: `["ds1"]`, + MaxConcurrentSessions: 2, + CooldownSec: 60, + SkipIdleRuns: true, + FailureThreshold: &failureThreshold, + ExecutorPreference: "exec-local", + BudgetMonthlyCents: 12500, + Settings: `{"office_theme":"dark"}`, + Permissions: `{"spawn_subagents":true}`, + // Deprecated legacy columns — still copied for fidelity so an old row's + // values survive duplication. + DangerouslySkipPermissions: true, + CustomPrompt: "legacy prompt", + // Runtime state — must NOT be copied. + Status: "working", + PauseReason: "auto-paused", + LastRunFinishedAt: &lastRun, + ConsecutiveFailures: 3, + } +} + +// duplicateSetup wires a controller to a fake store pre-seeded with the source profile. +func duplicateSetup(source *models.AgentProfile) (*Controller, *fakeStore) { + ctrl := newTestController(nil) + st := newFakeStore() + st.agents[source.AgentID] = &models.Agent{ID: source.AgentID, Name: "test-agent"} + st.profiles[source.AgentID] = []*models.AgentProfile{source} + ctrl.repo = st + return ctrl, st +} + +// TestDuplicateProfile_CopiesFullConfiguration verifies every configuration field (office enrichment and deprecated legacy columns included) survives duplication while runtime state is reset. +func TestDuplicateProfile_CopiesFullConfiguration(t *testing.T) { + source := sourceProfile() + ctrl, st := duplicateSetup(source) + + result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}) + if err != nil { + t.Fatalf("DuplicateProfile: %v", err) + } + + if result.ID == source.ID || result.ID == "" { + t.Fatalf("copy ID = %q, want a fresh non-empty ID", result.ID) + } + if result.Name != "Default Copy" { + t.Errorf("copy name = %q, want %q", result.Name, "Default Copy") + } + if result.AgentID != source.AgentID { + t.Errorf("copy agent_id = %q, want %q", result.AgentID, source.AgentID) + } + if result.AgentDisplayName != source.AgentDisplayName { + t.Errorf("copy display name = %q, want %q", result.AgentDisplayName, source.AgentDisplayName) + } + if result.Model != source.Model || result.FallbackModel != source.FallbackModel || !result.AutoFallback { + t.Errorf("copy model fields = (%q, %q, %v), want (%q, %q, true)", + result.Model, result.FallbackModel, result.AutoFallback, source.Model, source.FallbackModel) + } + if result.Mode != source.Mode { + t.Errorf("copy mode = %q, want %q", result.Mode, source.Mode) + } + if len(result.ConfigOptions) != 1 || result.ConfigOptions["effort"] != "high" { + t.Errorf("copy config options = %+v, want effort=high", result.ConfigOptions) + } + if !result.AllowIndexing || !result.AutoApprove || !result.CLIPassthrough { + t.Errorf("copy boolean config not preserved: allow_indexing=%v auto_approve=%v cli_passthrough=%v", + result.AllowIndexing, result.AutoApprove, result.CLIPassthrough) + } + if !result.UserModified { + t.Error("copy user_modified = false, want true") + } + if !result.Enabled { + t.Error("copy enabled = false, want true (source enabled)") + } + if result.CommandPrefix != "greywall --" { + t.Errorf("copy command prefix = %q, want %q", result.CommandPrefix, "greywall --") + } + if len(result.CLIFlags) != 2 || + result.CLIFlags[0].Flag != "--allow-all-tools" || !result.CLIFlags[0].Enabled || + result.CLIFlags[1].Flag != "--my-flag value" || result.CLIFlags[1].Enabled { + t.Errorf("copy cli flags = %+v, want both source entries with their enabled states", result.CLIFlags) + } + if len(result.EnvVars) != 2 || + result.EnvVars[0].Key != "FOO" || result.EnvVars[0].Value != "bar" || result.EnvVars[0].SecretID != "" || + result.EnvVars[1].Key != "TOKEN" || result.EnvVars[1].SecretID != "sec-1" { + t.Errorf("copy env vars = %+v, want both source entries incl. secret ref", result.EnvVars) + } + + if len(st.created) != 1 { + t.Fatalf("stored copies = %d, want 1", len(st.created)) + } + stored := st.created[0] + if stored.ID != result.ID { + t.Errorf("stored copy ID = %q, response ID = %q", stored.ID, result.ID) + } + // Office enrichment configuration copied; runtime state reset. + if stored.WorkspaceID != "" || stored.Role != "worker" || stored.Icon != "🤖" || + stored.ReportsTo != "profile-other" || stored.SkillIDs != `["s1","s2"]` || + stored.DesiredSkills != `["ds1"]` || stored.MaxConcurrentSessions != 2 || + stored.CooldownSec != 60 || !stored.SkipIdleRuns || + stored.FailureThreshold == nil || *stored.FailureThreshold != 4 || + stored.ExecutorPreference != "exec-local" || stored.BudgetMonthlyCents != 12500 || + stored.Settings != `{"office_theme":"dark"}` || stored.Permissions != `{"spawn_subagents":true}` { + t.Errorf("stored office enrichment not copied: %+v", stored) + } + if !stored.DangerouslySkipPermissions || stored.CustomPrompt != "legacy prompt" { + t.Errorf("deprecated legacy columns not copied: dangerously_skip_permissions=%v custom_prompt=%q", + stored.DangerouslySkipPermissions, stored.CustomPrompt) + } + if stored.Status != "" || stored.PauseReason != "" || stored.LastRunFinishedAt != nil || stored.ConsecutiveFailures != 0 { + t.Errorf("runtime state must not be copied: status=%q pause=%q last_run=%v failures=%d", + stored.Status, stored.PauseReason, stored.LastRunFinishedAt, stored.ConsecutiveFailures) + } + if stored.MigratedFrom != "" { + t.Errorf("legacy field must not be copied: migrated_from=%q", stored.MigratedFrom) + } +} + +// TestDuplicateProfile_CopiesDisabledState verifies a disabled source produces a disabled copy. +func TestDuplicateProfile_CopiesDisabledState(t *testing.T) { + source := sourceProfile() + source.Enabled = false + ctrl, st := duplicateSetup(source) + + result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}) + if err != nil { + t.Fatalf("DuplicateProfile: %v", err) + } + if result.Enabled { + t.Error("copy enabled = true, want false (source disabled)") + } + if len(st.created) != 1 || st.created[0].Enabled { + t.Errorf("stored copy enabled = %v, want false", st.created[0].Enabled) + } + // The disabled state must be part of the single atomic duplicate write: + // no follow-up enabled flip is allowed (a flip would create a window where + // the copy is selectable and would need a second write). + if len(st.updated) != 0 { + t.Errorf("duplicate issued %d follow-up updates, want 0 (atomic write)", len(st.updated)) + } + // The response timestamps must be the ones actually stored (no stale + // insert timestamp after a separate write). + stored := st.created[0] + if !result.CreatedAt.Equal(stored.CreatedAt) || !result.UpdatedAt.Equal(stored.UpdatedAt) { + t.Errorf("response timestamps (%v/%v) differ from stored (%v/%v)", + result.CreatedAt, result.UpdatedAt, stored.CreatedAt, stored.UpdatedAt) + } +} + +// TestDuplicateProfile_StoreFailureLeavesNoCopy verifies a failed transaction leaves no copy behind. +func TestDuplicateProfile_StoreFailureLeavesNoCopy(t *testing.T) { + source := sourceProfile() + ctrl, st := duplicateSetup(source) + wantErr := errors.New("boom") + st.duplicateProfErr = wantErr + + _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}) + if !errors.Is(err, wantErr) { + t.Fatalf("err = %v, want %v", err, wantErr) + } + if len(st.created) != 0 || len(st.mcpConfigs) != 0 { + t.Errorf("partial copy persisted despite store error: created=%d mcp=%d", + len(st.created), len(st.mcpConfigs)) + } +} + +// TestDuplicateProfile_CopiesMcpConfig verifies the MCP config (enabled, servers, meta) is copied under the new profile ID. +func TestDuplicateProfile_CopiesMcpConfig(t *testing.T) { + source := sourceProfile() + ctrl, st := duplicateSetup(source) + st.mcpConfigs[source.ID] = &models.AgentProfileMcpConfig{ + ProfileID: source.ID, + Enabled: true, + Servers: map[string]interface{}{ + "github": map[string]interface{}{"url": "https://api.github.com", "enabled": true}, + }, + Meta: map[string]interface{}{"source": "user"}, + } + + result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}) + if err != nil { + t.Fatalf("DuplicateProfile: %v", err) + } + + copied, ok := st.mcpConfigs[result.ID] + if !ok { + t.Fatalf("no mcp config row for copy %q", result.ID) + } + if !copied.Enabled { + t.Error("copied mcp config enabled = false, want true") + } + servers, ok := copied.Servers["github"].(map[string]interface{}) + if !ok || servers["url"] != "https://api.github.com" || servers["enabled"] != true { + t.Errorf("copied mcp servers = %+v, want github entry preserved", copied.Servers) + } + if copied.Meta["source"] != "user" { + t.Errorf("copied mcp meta = %+v, want source=user", copied.Meta) + } + // The source row must be untouched. + if _, ok := st.mcpConfigs[source.ID]; !ok { + t.Error("source mcp config row disappeared") + } +} + +// TestDuplicateProfile_NoMcpConfigLeavesCopyWithoutRow verifies a source without an MCP row leaves the copy without one. +func TestDuplicateProfile_NoMcpConfigLeavesCopyWithoutRow(t *testing.T) { + source := sourceProfile() + ctrl, st := duplicateSetup(source) + + if _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}); err != nil { + t.Fatalf("DuplicateProfile: %v", err) + } + if len(st.mcpConfigs) != 0 { + t.Errorf("copy created an mcp config row when the source had none: %+v", st.mcpConfigs) + } +} + +// TestDuplicateProfile_NotFound verifies an unknown source ID maps to ErrAgentProfileNotFound. +func TestDuplicateProfile_NotFound(t *testing.T) { + ctrl, _ := duplicateSetup(sourceProfile()) + + _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: "missing"}) + if !errors.Is(err, ErrAgentProfileNotFound) { + t.Fatalf("err = %v, want ErrAgentProfileNotFound", err) + } +} + +// TestDuplicateProfile_RejectsOfficeScopedSource verifies the settings +// duplicate endpoint refuses office-scoped profiles: they are owned by the +// workspace-scoped office surface and hidden from this instance-level API, so +// duplication must fail closed (as 404, not 403, to keep their existence +// hidden) without creating a copy. +func TestDuplicateProfile_RejectsOfficeScopedSource(t *testing.T) { + source := sourceProfile() + source.WorkspaceID = "ws-1" + ctrl, st := duplicateSetup(source) + + _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}) + if !errors.Is(err, ErrAgentProfileNotFound) { + t.Fatalf("err = %v, want ErrAgentProfileNotFound for an office-scoped source", err) + } + if len(st.created) != 0 { + t.Errorf("office-scoped source created %d copies, want 0", len(st.created)) + } +} + +// TestDuplicateProfile_NameSuffixFromEmptySourceName pins the copy name when the source name is empty. +func TestDuplicateProfile_NameSuffixFromEmptySourceName(t *testing.T) { + source := sourceProfile() + source.Name = "" + ctrl, st := duplicateSetup(source) + + result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}) + if err != nil { + t.Fatalf("DuplicateProfile: %v", err) + } + if result.Name != " Copy" { + t.Errorf("copy name = %q, want %q", result.Name, " Copy") + } + _ = st +} + +// TestDuplicateProfile_RetriesOnConcurrentChange verifies the controller +// re-reads the source and retries when the repository aborts the first +// attempt with ErrProfileChanged (a concurrent writer), ending with exactly +// one copy — and that the retried copy reflects the NEW source state (proving +// the fresh GetAgentProfile happened). +func TestDuplicateProfile_RetriesOnConcurrentChange(t *testing.T) { + source := sourceProfile() + ctrl, st := duplicateSetup(source) + st.duplicateChangedOnce = true + + result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}) + if err != nil { + t.Fatalf("DuplicateProfile after retry: %v", err) + } + if result.ID == source.ID || result.ID == "" { + t.Fatalf("copy ID = %q, want a fresh ID", result.ID) + } + if result.Name != "Changed Name Copy" { + t.Errorf("copy name = %q, want %q (copy must be built from the re-read source)", result.Name, "Changed Name Copy") + } + if len(st.created) != 1 { + t.Fatalf("stored copies = %d, want exactly 1 after retry", len(st.created)) + } +} + +// TestDuplicateProfile_ExhaustsRetriesOnPersistentChange verifies the +// controller gives up (and creates nothing) when every attempt aborts with +// ErrProfileChanged. +func TestDuplicateProfile_ExhaustsRetriesOnPersistentChange(t *testing.T) { + source := sourceProfile() + ctrl, st := duplicateSetup(source) + st.duplicateProfErr = store.ErrProfileChanged + + _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}) + if !errors.Is(err, store.ErrProfileChanged) { + t.Fatalf("err = %v, want ErrProfileChanged", err) + } + if len(st.created) != 0 { + t.Errorf("copy created despite persistent source changes: %d rows", len(st.created)) + } +} + +// TestDuplicateProfile_SourceDeletedMidFlightMapsToNotFound verifies a source +// deleted during the duplicate retries surfaces as ErrAgentProfileNotFound +// (HTTP 404) instead of the raw store error (HTTP 500). +func TestDuplicateProfile_SourceDeletedMidFlightMapsToNotFound(t *testing.T) { + source := sourceProfile() + ctrl, st := duplicateSetup(source) + st.duplicateProfErr = store.ErrSourceProfileNotFound + + _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}) + if !errors.Is(err, ErrAgentProfileNotFound) { + t.Fatalf("err = %v, want ErrAgentProfileNotFound", err) + } + if len(st.created) != 0 { + t.Errorf("copy created despite deleted source: %d rows", len(st.created)) + } +} diff --git a/apps/backend/internal/agent/settings/controller/reconciler_test.go b/apps/backend/internal/agent/settings/controller/reconciler_test.go index 62b95e05f6..88021351db 100644 --- a/apps/backend/internal/agent/settings/controller/reconciler_test.go +++ b/apps/backend/internal/agent/settings/controller/reconciler_test.go @@ -17,6 +17,7 @@ import ( "github.com/kandev/kandev/internal/agent/hostutility" "github.com/kandev/kandev/internal/agent/registry" "github.com/kandev/kandev/internal/agent/settings/models" + "github.com/kandev/kandev/internal/agent/settings/store" "github.com/kandev/kandev/internal/agent/usage" "github.com/kandev/kandev/internal/agentctl/acpcompat" "github.com/kandev/kandev/internal/common/logger" @@ -34,26 +35,30 @@ func (f *fakeCapReader) Get(agentType string) (hostutility.AgentCapabilities, bo // fakeStore implements just enough of store.Repository for the reconciler. type fakeStore struct { - agents map[string]*models.Agent // keyed by DB ID - byName map[string]*models.Agent // keyed by Name - profiles map[string][]*models.AgentProfile // keyed by DB agent ID (live) - deleted map[string][]*models.AgentProfile // keyed by DB agent ID (soft-deleted) - created []*models.AgentProfile - updated []*models.AgentProfile - softDeleted []string - nextAgentID int - nextProfID int - getByNameErr error - listAgentsErr error - listProfErr map[string]error + agents map[string]*models.Agent // keyed by DB ID + byName map[string]*models.Agent // keyed by Name + profiles map[string][]*models.AgentProfile // keyed by DB agent ID (live) + deleted map[string][]*models.AgentProfile // keyed by DB agent ID (soft-deleted) + mcpConfigs map[string]*models.AgentProfileMcpConfig // keyed by profile ID + created []*models.AgentProfile + updated []*models.AgentProfile + softDeleted []string + nextAgentID int + nextProfID int + getByNameErr error + listAgentsErr error + listProfErr map[string]error + duplicateProfErr error + duplicateChangedOnce bool } func newFakeStore() *fakeStore { return &fakeStore{ - agents: map[string]*models.Agent{}, - byName: map[string]*models.Agent{}, - profiles: map[string][]*models.AgentProfile{}, - deleted: map[string][]*models.AgentProfile{}, + agents: map[string]*models.Agent{}, + byName: map[string]*models.Agent{}, + profiles: map[string][]*models.AgentProfile{}, + deleted: map[string][]*models.AgentProfile{}, + mcpConfigs: map[string]*models.AgentProfileMcpConfig{}, } } @@ -97,10 +102,17 @@ func (f *fakeStore) ListTUIAgents(context.Context) ([]*models.Agent, error) { return nil, nil } -func (f *fakeStore) GetAgentProfileMcpConfig(context.Context, string) (*models.AgentProfileMcpConfig, error) { +// GetAgentProfileMcpConfig implements the settings store interface for the reconciler test fakes. +func (f *fakeStore) GetAgentProfileMcpConfig(_ context.Context, profileID string) (*models.AgentProfileMcpConfig, error) { + if cfg, ok := f.mcpConfigs[profileID]; ok { + return cfg, nil + } return nil, nil } -func (f *fakeStore) UpsertAgentProfileMcpConfig(context.Context, *models.AgentProfileMcpConfig) error { + +// UpsertAgentProfileMcpConfig implements the settings store interface for the reconciler test fakes. +func (f *fakeStore) UpsertAgentProfileMcpConfig(_ context.Context, config *models.AgentProfileMcpConfig) error { + f.mcpConfigs[config.ProfileID] = config return nil } @@ -112,6 +124,50 @@ func (f *fakeStore) CreateAgentProfile(_ context.Context, p *models.AgentProfile return nil } +// DuplicateAgentProfile implements the settings store interface for the reconciler test fakes. +func (f *fakeStore) DuplicateAgentProfile(_ context.Context, input store.DuplicateAgentProfileInput) error { + if f.duplicateProfErr != nil { + return f.duplicateProfErr + } + if f.duplicateChangedOnce { + f.duplicateChangedOnce = false + // Simulate a concurrent writer: the stored source row changes between + // the controller's first read and its duplicate attempt, so a retry + // must re-read the source and copy the NEW state. + input.Source.Name = "Changed Name" + input.Source.UpdatedAt = input.Source.UpdatedAt.Add(time.Second) + return store.ErrProfileChanged + } + // Version check mirrors the sqlite store: the stored source rows must + // still match the revisions the copy was built from. + if f.profiles[input.Source.AgentID] != nil { + for _, p := range f.profiles[input.Source.AgentID] { + if p.ID == input.Source.ID && !p.UpdatedAt.Equal(input.Source.UpdatedAt) { + return store.ErrProfileChanged + } + } + } + if input.SourceMcp != nil { + mcp, ok := f.mcpConfigs[input.Source.ID] + if !ok || !mcp.UpdatedAt.Equal(input.SourceMcp.UpdatedAt) { + return store.ErrProfileChanged + } + } + p := input.Profile + f.nextProfID++ + p.ID = "profile-" + strconv.Itoa(f.nextProfID) + now := time.Now().UTC() + p.CreatedAt = now + p.UpdatedAt = now + f.profiles[p.AgentID] = append(f.profiles[p.AgentID], p) + f.created = append(f.created, p) + if input.McpConfig != nil { + input.McpConfig.ProfileID = p.ID + f.mcpConfigs[p.ID] = input.McpConfig + } + return nil +} + func (f *fakeStore) UpdateAgentProfile(_ context.Context, p *models.AgentProfile) error { f.updated = append(f.updated, p) return nil diff --git a/apps/backend/internal/agent/settings/dto/dto.go b/apps/backend/internal/agent/settings/dto/dto.go index 85106b1195..79671cd469 100644 --- a/apps/backend/internal/agent/settings/dto/dto.go +++ b/apps/backend/internal/agent/settings/dto/dto.go @@ -46,6 +46,16 @@ type AgentProfileDTO struct { UpdatedAt time.Time `json:"updated_at"` } +// GetWorkspaceID lets struct-shaped profile payloads (e.g. the MCP event-bus +// publisher wrapping *AgentProfileDTO under "profile") be routed by the +// gateway's extractWorkspaceID without a JSON round-trip. +func (p *AgentProfileDTO) GetWorkspaceID() string { + if p == nil { + return "" + } + return p.WorkspaceID +} + // CLIFlagDTO mirrors models.CLIFlag on the wire. Each entry is one user-facing // CLI argument on a profile; at launch time the `flag` string is shell-split // and only entries with `enabled:true` reach the agent subprocess argv. diff --git a/apps/backend/internal/agent/settings/handlers/handlers.go b/apps/backend/internal/agent/settings/handlers/handlers.go index fbc0b7715a..71b70242e3 100644 --- a/apps/backend/internal/agent/settings/handlers/handlers.go +++ b/apps/backend/internal/agent/settings/handlers/handlers.go @@ -75,6 +75,7 @@ func (h *Handlers) registerHTTP(router *gin.Engine) { api.GET("/agent-update/jobs/:id", h.httpGetAgentUpdateJob) api.PATCH("/agent-profiles/:id", h.interlock, h.httpUpdateProfile) api.DELETE("/agent-profiles/:id", h.interlock, h.httpDeleteProfile) + api.POST("/agent-profiles/:id/duplicate", h.interlock, h.httpDuplicateProfile) api.GET("/agent-profiles/:id/mcp-config", h.httpGetProfileMcpConfig) api.POST("/agent-profiles/:id/mcp-config", h.interlock, h.httpUpdateProfileMcpConfig) } @@ -544,12 +545,7 @@ func (h *Handlers) httpCreateProfile(c *gin.Context) { c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create profile"}) return } - if h.hub != nil { - notification, _ := ws.NewNotification(ws.ActionAgentProfileCreated, gin.H{ - "profile": resp, - }) - h.hub.Broadcast(notification) - } + h.broadcastProfileEvent(ws.ActionAgentProfileCreated, resp) c.JSON(http.StatusOK, resp) } @@ -614,15 +610,62 @@ func (h *Handlers) httpUpdateProfile(c *gin.Context) { c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to update profile"}) return } - if h.hub != nil { - notification, _ := ws.NewNotification(ws.ActionAgentProfileUpdated, gin.H{ - "profile": resp, - }) - h.hub.Broadcast(notification) - } + h.broadcastProfileEvent(ws.ActionAgentProfileUpdated, resp) c.JSON(http.StatusOK, resp) } +// httpDuplicateProfile copies a profile's full configuration into a new row +// named " copy" and returns the new profile. No request body: the +// copy name is derived server-side. The existing agent.profile.created +// notification lets every open settings surface pick the copy up live. +func (h *Handlers) httpDuplicateProfile(c *gin.Context) { + profileID := c.Param("id") + if profileID == "" { + c.JSON(http.StatusBadRequest, gin.H{"error": "profile id is required"}) + return + } + resp, err := h.controller.DuplicateProfile(c.Request.Context(), controller.DuplicateProfileRequest{ + ID: profileID, + }) + if err != nil { + if err == controller.ErrAgentProfileNotFound { + c.JSON(http.StatusNotFound, gin.H{"error": "agent profile not found"}) + return + } + h.logger.Error("failed to duplicate profile", zap.Error(err)) + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to duplicate profile"}) + return + } + h.broadcastProfileEvent(ws.ActionAgentProfileCreated, resp) + c.JSON(http.StatusOK, resp) +} + +// broadcastProfileEvent fans a profile create/update/delete event out. +// Kanban profiles (empty WorkspaceID) go to every settings client. +// Office-scoped profiles are routed through the workspace-scoped broadcaster +// so their configuration (env vars, servers, ...) never leaks across +// workspace/user boundaries — the HTTP agent list hides them via +// filterGlobalProfiles, and the WS path must not contradict that. When the +// hub does not support workspace routing (test fakes), the office event is +// dropped fail-closed. +func (h *Handlers) broadcastProfileEvent(action string, profile *dto.AgentProfileDTO) { + if h.hub == nil { + return + } + notification, _ := ws.NewNotification(action, gin.H{ + "profile": profile, + }) + if profile.WorkspaceID != "" { + if workspaceHub, ok := h.hub.(interface { + BroadcastToWorkspaceOrDrop(string, *ws.Message) + }); ok { + workspaceHub.BroadcastToWorkspaceOrDrop(profile.WorkspaceID, notification) + } + return + } + h.hub.Broadcast(notification) +} + func (h *Handlers) httpDeleteProfile(c *gin.Context) { force := c.Query("force") == "true" profile, err := h.controller.DeleteProfile(c.Request.Context(), c.Param("id"), force) @@ -647,12 +690,7 @@ func (h *Handlers) httpDeleteProfile(c *gin.Context) { c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete profile"}) return } - if h.hub != nil { - notification, _ := ws.NewNotification(ws.ActionAgentProfileDeleted, gin.H{ - "profile": profile, - }) - h.hub.Broadcast(notification) - } + h.broadcastProfileEvent(ws.ActionAgentProfileDeleted, profile) c.JSON(http.StatusOK, gin.H{"success": true}) } diff --git a/apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go b/apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go index d7e75cca8c..268ec96df7 100644 --- a/apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go +++ b/apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go @@ -52,6 +52,7 @@ func TestRegisterRoutesProtectsEveryStateChangingAgentSettingsRoute(t *testing.T {method: http.MethodPost, path: "/api/v1/agent-update/agent-1"}, {method: http.MethodPatch, path: "/api/v1/agent-profiles/profile-1"}, {method: http.MethodDelete, path: "/api/v1/agent-profiles/profile-1"}, + {method: http.MethodPost, path: "/api/v1/agent-profiles/profile-1/duplicate"}, {method: http.MethodPost, path: "/api/v1/agent-profiles/profile-1/mcp-config"}, } diff --git a/apps/backend/internal/agent/settings/handlers/profile_duplicate_handlers_test.go b/apps/backend/internal/agent/settings/handlers/profile_duplicate_handlers_test.go new file mode 100644 index 0000000000..cd92831724 --- /dev/null +++ b/apps/backend/internal/agent/settings/handlers/profile_duplicate_handlers_test.go @@ -0,0 +1,329 @@ +package handlers + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "github.com/gin-gonic/gin" + "github.com/kandev/kandev/internal/agent/settings/controller" + "github.com/kandev/kandev/internal/agent/settings/dto" + "github.com/kandev/kandev/internal/agent/settings/models" + "github.com/kandev/kandev/internal/agent/settings/store" + "github.com/kandev/kandev/internal/common/httpmw" + "github.com/kandev/kandev/internal/common/logger" + ws "github.com/kandev/kandev/pkg/websocket" +) + +// duplicateRepo is a minimal store.Repository stub: the duplicate path only +// reads one profile, inserts the copy, flips enabled, and reads/writes the +// MCP config row. Everything else is a no-op. +type duplicateRepo struct { + profiles map[string]*models.AgentProfile + created []*models.AgentProfile +} + +// newDuplicateRepo returns a fake repository preloaded with one kanban profile (p-1) under agent-1. +func newDuplicateRepo() *duplicateRepo { + return &duplicateRepo{profiles: map[string]*models.AgentProfile{}} +} + +// GetAgentProfile implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) GetAgentProfile(_ context.Context, id string) (*models.AgentProfile, error) { + if p, ok := r.profiles[id]; ok { + return p, nil + } + return nil, fmt.Errorf("agent profile not found: %s", id) +} + +// GetAgentProfileIncludingDeleted implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) GetAgentProfileIncludingDeleted(ctx context.Context, id string) (*models.AgentProfile, error) { + return r.GetAgentProfile(ctx, id) +} + +// CreateAgentProfile implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) CreateAgentProfile(_ context.Context, p *models.AgentProfile) error { + if p.ID == "" { + p.ID = "duplicate-" + p.Name + } + r.profiles[p.ID] = p + r.created = append(r.created, p) + return nil +} + +// DuplicateAgentProfile implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) DuplicateAgentProfile(_ context.Context, input store.DuplicateAgentProfileInput) error { + // Version check: the stored source must match the caller's snapshot. + if src, ok := r.profiles[input.Source.ID]; ok && !src.UpdatedAt.Equal(input.Source.UpdatedAt) { + return store.ErrProfileChanged + } + p := input.Profile + if p.ID == "" { + p.ID = "duplicate-" + p.Name + } + now := time.Now().UTC() + p.CreatedAt = now + p.UpdatedAt = now + r.profiles[p.ID] = p + r.created = append(r.created, p) + if input.McpConfig != nil { + input.McpConfig.ProfileID = p.ID + } + return nil +} + +// UpdateAgentProfileEnabled implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) UpdateAgentProfileEnabled(_ context.Context, id string, enabled bool) (time.Time, error) { + p, ok := r.profiles[id] + if !ok { + return time.Time{}, fmt.Errorf("agent profile not found: %s", id) + } + p.Enabled = enabled + p.UpdatedAt = time.Now().UTC() + return p.UpdatedAt, nil +} + +// GetAgentProfileMcpConfig implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) GetAgentProfileMcpConfig(context.Context, string) (*models.AgentProfileMcpConfig, error) { + return nil, nil +} + +// UpsertAgentProfileMcpConfig implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) UpsertAgentProfileMcpConfig(context.Context, *models.AgentProfileMcpConfig) error { + return nil +} + +// CreateAgent implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) CreateAgent(context.Context, *models.Agent) error { return nil } + +// GetAgent implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) GetAgent(context.Context, string) (*models.Agent, error) { + return nil, nil +} + +// GetAgentByName implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) GetAgentByName(context.Context, string) (*models.Agent, error) { + return nil, nil +} + +// UpdateAgent implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) UpdateAgent(context.Context, *models.Agent) error { return nil } + +// DeleteAgent implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) DeleteAgent(context.Context, string) error { return nil } + +// ListAgents implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) ListAgents(context.Context) ([]*models.Agent, error) { + return nil, nil +} + +// ListTUIAgents implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) ListTUIAgents(context.Context) ([]*models.Agent, error) { + return nil, nil +} + +// UpdateAgentProfile implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) UpdateAgentProfile(context.Context, *models.AgentProfile) error { + return nil +} + +// DeleteAgentProfile implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) DeleteAgentProfile(context.Context, string) error { return nil } + +// ListAgentProfiles implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) ListAgentProfiles(context.Context, string) ([]*models.AgentProfile, error) { + return nil, nil +} + +// HasDeletedAgentProfiles implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) HasDeletedAgentProfiles(context.Context, string) (bool, error) { + return false, nil +} + +// Close implements the settings store interface for the duplicate handler tests. +func (r *duplicateRepo) Close() error { return nil } + +var _ store.Repository = (*duplicateRepo)(nil) + +// duplicateHub captures every WS message so tests can assert the broadcast. +type duplicateHub struct { + mu sync.Mutex + msgs []*ws.Message +} + +// Broadcast records a global notification so tests can assert (non-)delivery. +func (h *duplicateHub) Broadcast(msg *ws.Message) { + h.mu.Lock() + defer h.mu.Unlock() + h.msgs = append(h.msgs, msg) +} + +// actions returns the global notifications recorded by Broadcast. +func (h *duplicateHub) actions() []string { + h.mu.Lock() + defer h.mu.Unlock() + out := make([]string, 0, len(h.msgs)) + for _, m := range h.msgs { + out = append(out, m.Action) + } + return out +} + +// workspaceDuplicateHub models the gateway hub: global Broadcast plus the +// workspace-scoped, fail-closed BroadcastToWorkspaceOrDrop. +type workspaceDuplicateHub struct { + mu sync.Mutex + global []*ws.Message + workspaceMsgs map[string][]*ws.Message +} + +// Broadcast records a global notification so tests can assert (non-)delivery. +func (h *workspaceDuplicateHub) Broadcast(msg *ws.Message) { + h.mu.Lock() + defer h.mu.Unlock() + h.global = append(h.global, msg) +} + +// BroadcastToWorkspaceOrDrop records a workspace-scoped notification so tests can assert (non-)delivery. +func (h *workspaceDuplicateHub) BroadcastToWorkspaceOrDrop(workspaceID string, msg *ws.Message) { + h.mu.Lock() + defer h.mu.Unlock() + h.workspaceMsgs[workspaceID] = append(h.workspaceMsgs[workspaceID], msg) +} + +// newDuplicateRouter builds a gin router with the settings handlers wired to the given repo and hub. +func newDuplicateRouter(t *testing.T, repo store.Repository, hub Broadcaster) *gin.Engine { + t.Helper() + gin.SetMode(gin.TestMode) + log, err := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json"}) + if err != nil { + t.Fatalf("NewLogger: %v", err) + } + ctrl := controller.NewController(repo, nil, nil, nil, log) + router := gin.New() + NewHandlers(ctrl, hub, log, "test-interlock").registerHTTP(router) + return router +} + +// TestDuplicateProfileEndpoint_CopiesAndBroadcasts verifies the HTTP endpoint copies a kanban profile and broadcasts agent.profile.created. +func TestDuplicateProfileEndpoint_CopiesAndBroadcasts(t *testing.T) { + repo := newDuplicateRepo() + repo.profiles["source-1"] = &models.AgentProfile{ + ID: "source-1", + AgentID: "agent-1", + Name: "Default", + AgentDisplayName: "Claude Code", + Model: "claude-sonnet", + CLIFlags: []models.CLIFlag{{Description: "Tools", Flag: "--allow-all-tools", Enabled: true}}, + Enabled: true, + } + hub := &duplicateHub{} + router := newDuplicateRouter(t, repo, hub) + + req := httptest.NewRequest(http.MethodPost, "/api/v1/agent-profiles/source-1/duplicate", nil) + req.Header.Set(httpmw.InterimSettingsInterlockHeader, "test-interlock") + rec := httptest.NewRecorder() + router.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200; body: %s", rec.Code, rec.Body.String()) + } + var created dto.AgentProfileDTO + if err := json.Unmarshal(rec.Body.Bytes(), &created); err != nil { + t.Fatalf("decode response: %v", err) + } + if created.ID == "source-1" || created.ID == "" { + t.Errorf("response profile ID = %q, want a fresh ID", created.ID) + } + if created.Name != "Default Copy" { + t.Errorf("response name = %q, want %q", created.Name, "Default Copy") + } + if created.Model != "claude-sonnet" { + t.Errorf("response model = %q, want claude-sonnet", created.Model) + } + if len(created.CLIFlags) != 1 || created.CLIFlags[0].Flag != "--allow-all-tools" { + t.Errorf("response cli flags = %+v, want the source entry", created.CLIFlags) + } + + found := false + for _, action := range hub.actions() { + if action == ws.ActionAgentProfileCreated { + found = true + } + } + if !found { + t.Errorf("no %s broadcast, got %v", ws.ActionAgentProfileCreated, hub.actions()) + } + if len(repo.created) != 1 { + t.Fatalf("stored copies = %d, want 1", len(repo.created)) + } +} + +// TestDuplicateProfileEndpoint_NotFound verifies an unknown source ID surfaces as HTTP 404. +func TestDuplicateProfileEndpoint_NotFound(t *testing.T) { + router := newDuplicateRouter(t, newDuplicateRepo(), nil) + + req := httptest.NewRequest(http.MethodPost, "/api/v1/agent-profiles/missing/duplicate", nil) + req.Header.Set(httpmw.InterimSettingsInterlockHeader, "test-interlock") + rec := httptest.NewRecorder() + router.ServeHTTP(rec, req) + + if rec.Code != http.StatusNotFound { + t.Fatalf("status = %d, want 404; body: %s", rec.Code, rec.Body.String()) + } + if !strings.Contains(rec.Body.String(), "agent profile not found") { + t.Errorf("body = %q, want agent profile not found message", rec.Body.String()) + } +} + +// TestDuplicateProfileEndpoint_RejectsOfficeScopedSource verifies the +// settings duplicate endpoint refuses office-scoped profiles fail-closed: +// the source is owned by the workspace-scoped office surface, so the request +// surfaces as 404 (existence hidden) and no event is broadcast on any channel +// (workspace-aware or global). +func TestDuplicateProfileEndpoint_RejectsOfficeScopedSource(t *testing.T) { + repo := newDuplicateRepo() + repo.profiles["source-office"] = &models.AgentProfile{ + ID: "source-office", + AgentID: "agent-1", + Name: "Office Agent", + WorkspaceID: "ws-1", + Enabled: true, + } + hub := &workspaceDuplicateHub{workspaceMsgs: map[string][]*ws.Message{}} + router := newDuplicateRouter(t, repo, hub) + + req := httptest.NewRequest(http.MethodPost, "/api/v1/agent-profiles/source-office/duplicate", nil) + req.Header.Set(httpmw.InterimSettingsInterlockHeader, "test-interlock") + rec := httptest.NewRecorder() + router.ServeHTTP(rec, req) + + if rec.Code != http.StatusNotFound { + t.Fatalf("status = %d, want 404; body: %s", rec.Code, rec.Body.String()) + } + if len(hub.global) != 0 { + t.Errorf("office duplicate leaked to the global settings broadcast: %d messages", len(hub.global)) + } + if len(hub.workspaceMsgs) != 0 { + t.Errorf("office duplicate broadcast workspace-scoped messages: %v", hub.workspaceMsgs) + } +} + +// TestDuplicateProfileEndpoint_RequiresInterlock verifies the duplicate route is rejected without the interlock token. +func TestDuplicateProfileEndpoint_RequiresInterlock(t *testing.T) { + router := newDuplicateRouter(t, newDuplicateRepo(), nil) + + req := httptest.NewRequest(http.MethodPost, "/api/v1/agent-profiles/source-1/duplicate", nil) + rec := httptest.NewRecorder() + router.ServeHTTP(rec, req) + + if rec.Code != http.StatusForbidden { + t.Fatalf("status = %d, want 403 without interlock token", rec.Code) + } +} diff --git a/apps/backend/internal/agent/settings/store/sqlite.go b/apps/backend/internal/agent/settings/store/sqlite.go index b50f6c4561..cdee34d97c 100644 --- a/apps/backend/internal/agent/settings/store/sqlite.go +++ b/apps/backend/internal/agent/settings/store/sqlite.go @@ -450,6 +450,14 @@ func (r *sqliteRepository) UpsertAgentProfileMcpConfig(ctx context.Context, conf if config.ProfileID == "" { return fmt.Errorf("profile ID is required") } + return r.upsertAgentProfileMcpConfig(ctx, r.db, config) +} + +// upsertAgentProfileMcpConfig inserts or replaces the MCP config row for a +// profile, running against the caller-supplied execer so the duplicate can +// commit it in the same transaction as the profile row. Defaults nil maps and +// fills timestamps on the passed config in place. +func (r *sqliteRepository) upsertAgentProfileMcpConfig(ctx context.Context, execer profileExecer, config *models.AgentProfileMcpConfig) error { if config.Servers == nil { config.Servers = map[string]interface{}{} } @@ -471,7 +479,7 @@ func (r *sqliteRepository) UpsertAgentProfileMcpConfig(ctx context.Context, conf return fmt.Errorf("failed to serialize MCP meta: %w", err) } - _, err = r.db.ExecContext(ctx, r.db.Rebind(` + _, err = execer.ExecContext(ctx, execer.Rebind(` INSERT INTO agent_profile_mcp_configs (profile_id, enabled, servers_json, meta_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(profile_id) DO UPDATE SET @@ -490,6 +498,116 @@ func (r *sqliteRepository) CreateAgentProfile(ctx context.Context, profile *mode now := time.Now().UTC() profile.CreatedAt = now profile.UpdatedAt = now + // New profiles are created enabled — the DB column default is 1 and + // nothing creates a profile pre-disabled. Setting the field here keeps + // callers' in-memory copy consistent with the row. + profile.Enabled = true + return r.insertAgentProfile(ctx, r.db, profile) +} + +// DuplicateAgentProfile creates an independent copy of a profile in a single +// transaction: the row is inserted with the caller-provided Enabled state (a +// duplicate of a disabled profile must not become briefly selectable) and the +// MCP config row is upserted when non-nil. A failure rolls back and leaves no +// partial copy, so retrying after an error cannot create a duplicate row. +// +// The source rows are re-read inside the transaction and must still carry the +// revisions the copy was built from; otherwise ErrProfileChanged is returned +// and nothing is created. Combined with WAL snapshot isolation (a concurrent +// commit after this transaction's first read aborts its write with a busy +// error), the copy always reflects one consistent snapshot of the source. +func (r *sqliteRepository) DuplicateAgentProfile(ctx context.Context, input DuplicateAgentProfileInput) error { + if input.Profile.ID == "" { + input.Profile.ID = uuid.New().String() + } + tx, err := r.db.BeginTxx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + + if err := r.verifySourceSnapshot(ctx, tx, input); err != nil { + return err + } + + now := time.Now().UTC() + input.Profile.CreatedAt = now + input.Profile.UpdatedAt = now + if err := r.insertAgentProfile(ctx, tx, input.Profile); err != nil { + return err + } + if input.McpConfig != nil { + input.McpConfig.ProfileID = input.Profile.ID + if err := r.upsertAgentProfileMcpConfig(ctx, tx, input.McpConfig); err != nil { + return err + } + } + return tx.Commit() +} + +// verifySourceSnapshot checks, inside the duplicate transaction, that the +// source rows still match the revisions the caller built the copy from. A +// mismatch means a concurrent writer changed the source between the caller's +// read and this transaction — duplicating anyway would produce a copy mixing +// two points in time. +func (r *sqliteRepository) verifySourceSnapshot(ctx context.Context, tx *sqlx.Tx, input DuplicateAgentProfileInput) error { + var sourceUpdated time.Time + err := tx.QueryRowContext(ctx, tx.Rebind( + `SELECT updated_at FROM agent_profiles WHERE id = ? AND deleted_at IS NULL`), + input.Source.ID).Scan(&sourceUpdated) + if errors.Is(err, sql.ErrNoRows) { + return ErrSourceProfileNotFound + } + if err != nil { + return err + } + if !sourceUpdated.Equal(input.Source.UpdatedAt) { + return ErrProfileChanged + } + if input.SourceMcp == nil { + // The caller's snapshot had no MCP row: verify one was not created in + // the meantime, otherwise the copy would silently drop it. Missing is + // the unchanged case; an existing row means the snapshot is stale. + var exists int + err = tx.QueryRowContext(ctx, tx.Rebind( + `SELECT 1 FROM agent_profile_mcp_configs WHERE profile_id = ?`), + input.Source.ID).Scan(&exists) + if err == nil { + return ErrProfileChanged + } + if !errors.Is(err, sql.ErrNoRows) { + return err + } + return nil + } + var mcpUpdated time.Time + err = tx.QueryRowContext(ctx, tx.Rebind( + `SELECT updated_at FROM agent_profile_mcp_configs WHERE profile_id = ?`), + input.Source.ID).Scan(&mcpUpdated) + if errors.Is(err, sql.ErrNoRows) { + return ErrProfileChanged + } + if err != nil { + return err + } + if !mcpUpdated.Equal(input.SourceMcp.UpdatedAt) { + return ErrProfileChanged + } + return nil +} + +// profileExecer is the subset of *sqlx.DB / *sqlx.Tx the shared insert and +// upsert helpers need, so one code path serves both single-statement and +// transactional writes. +type profileExecer interface { + ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) + Rebind(query string) string +} + +// insertAgentProfile writes the profile row through the caller-supplied +// execer, sharing one SQL statement between CreateAgentProfile and the +// transactional duplicate path. The profile's Enabled value is written as-is. +func (r *sqliteRepository) insertAgentProfile(ctx context.Context, execer profileExecer, profile *models.AgentProfile) error { cliFlagsJSON, err := cliFlagsToJSON(profile.CLIFlags) if err != nil { return err @@ -502,11 +620,7 @@ func (r *sqliteRepository) CreateAgentProfile(ctx context.Context, profile *mode if err != nil { return err } - // New profiles are created enabled — the DB column default is 1 and - // nothing creates a profile pre-disabled. Setting the field here keeps - // callers' in-memory copy consistent with the row. - profile.Enabled = true - _, err = r.db.ExecContext(ctx, r.db.Rebind(` + _, err = execer.ExecContext(ctx, execer.Rebind(` INSERT INTO agent_profiles ( id, agent_id, name, agent_display_name, model, mode, migrated_from, auto_approve, dangerously_skip_permissions, allow_indexing, cli_passthrough, diff --git a/apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go b/apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go new file mode 100644 index 0000000000..d393f33578 --- /dev/null +++ b/apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go @@ -0,0 +1,291 @@ +package store + +import ( + "context" + "database/sql" + "errors" + "testing" + + "github.com/kandev/kandev/internal/agent/settings/models" +) + +// TestDuplicateAgentProfile_RoundTrip verifies the atomic copy path: the copy +// gets a fresh ID, keeps every configuration field, preserves the source's +// disabled state (the store must NOT force a duplicate enabled like +// CreateAgentProfile does), and copies the MCP config row in the same write. +func TestDuplicateAgentProfile_RoundTrip(t *testing.T) { + repo := newFreshRepo(t) + ctx := context.Background() + + if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent", SupportsMCP: true}); err != nil { + t.Fatalf("seed agent: %v", err) + } + agent, err := repo.GetAgentByName(ctx, "test-agent") + if err != nil { + t.Fatalf("get agent: %v", err) + } + + source := &models.AgentProfile{ + AgentID: agent.ID, + Name: "Default", + AgentDisplayName: "Test Agent", + Model: "model-1", + Mode: "plan", + AutoApprove: true, + CLIPassthrough: true, + CLIFlags: []models.CLIFlag{{Description: "Tools", Flag: "--allow-all-tools", Enabled: true}}, + EnvVars: []models.ProfileEnvVar{{Key: "FOO", Value: "bar"}}, + CommandPrefix: "greywall --", + UserModified: true, + } + if err := repo.CreateAgentProfile(ctx, source); err != nil { + t.Fatalf("create source: %v", err) + } + // CreateAgentProfile forces enabled=true; simulate a user-disabled source. + // The returned timestamp is the DB revision the duplicate input must carry. + disabledAt, err := repo.UpdateAgentProfileEnabled(ctx, source.ID, false) + if err != nil { + t.Fatalf("disable source: %v", err) + } + source.UpdatedAt = disabledAt + sourceMcp := &models.AgentProfileMcpConfig{ + ProfileID: source.ID, + Enabled: true, + Servers: map[string]interface{}{"github": map[string]interface{}{"url": "https://api.github.com"}}, + Meta: map[string]interface{}{"k": "v"}, + } + if err := repo.UpsertAgentProfileMcpConfig(ctx, sourceMcp); err != nil { + t.Fatalf("seed source mcp: %v", err) + } + + clone := &models.AgentProfile{ + AgentID: source.AgentID, + Name: "Default Copy", + AgentDisplayName: source.AgentDisplayName, + Model: source.Model, + Mode: source.Mode, + AutoApprove: source.AutoApprove, + CLIPassthrough: source.CLIPassthrough, + CLIFlags: source.CLIFlags, + EnvVars: source.EnvVars, + CommandPrefix: source.CommandPrefix, + Enabled: false, + UserModified: true, + } + copiedMcp := &models.AgentProfileMcpConfig{ + Enabled: sourceMcp.Enabled, + Servers: sourceMcp.Servers, + Meta: sourceMcp.Meta, + } + if err := repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{ + Source: source, + SourceMcp: sourceMcp, + Profile: clone, + McpConfig: copiedMcp, + }); err != nil { + t.Fatalf("DuplicateAgentProfile: %v", err) + } + + if clone.ID == source.ID || clone.ID == "" { + t.Fatalf("copy ID = %q, want a fresh ID", clone.ID) + } + got, err := repo.GetAgentProfile(ctx, clone.ID) + if err != nil { + t.Fatalf("get copy: %v", err) + } + // The duplicate must NOT be forced enabled like CreateAgentProfile: a + // disabled source produces a disabled copy in the same write. + if got.Enabled { + t.Error("duplicate enabled = true, want false (source disabled)") + } + if got.Name != "Default Copy" || got.Model != "model-1" || got.Mode != "plan" || + !got.AutoApprove || !got.CLIPassthrough || got.CommandPrefix != "greywall --" || + len(got.CLIFlags) != 1 || got.CLIFlags[0].Flag != "--allow-all-tools" || + len(got.EnvVars) != 1 || got.EnvVars[0].Key != "FOO" { + t.Errorf("copy configuration not preserved: %+v", got) + } + if !got.CreatedAt.Equal(got.UpdatedAt) { + t.Errorf("copy timestamps differ: created=%v updated=%v", got.CreatedAt, got.UpdatedAt) + } + + gotMcp, err := repo.GetAgentProfileMcpConfig(ctx, clone.ID) + if err != nil { + t.Fatalf("get copy mcp config: %v", err) + } + if gotMcp == nil || !gotMcp.Enabled { + t.Fatal("copy mcp config missing or disabled") + } + servers, ok := gotMcp.Servers["github"].(map[string]interface{}) + if !ok || servers["url"] != "https://api.github.com" { + t.Errorf("copy mcp servers = %+v, want github entry preserved", gotMcp.Servers) + } + if gotMcp.Meta["k"] != "v" { + t.Errorf("copy mcp meta = %+v, want k=v", gotMcp.Meta) + } + + // The source row must be untouched. + srcAgain, err := repo.GetAgentProfile(ctx, source.ID) + if err != nil || srcAgain == nil || srcAgain.Enabled { + t.Errorf("source row altered by duplicate: err=%v enabled=%v", err, srcAgain.Enabled) + } +} + +// TestDuplicateAgentProfile_NoMcpConfig verifies the copy is created without +// an MCP row when none is passed. +func TestDuplicateAgentProfile_NoMcpConfig(t *testing.T) { + repo := newFreshRepo(t) + ctx := context.Background() + + if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent"}); err != nil { + t.Fatalf("seed agent: %v", err) + } + agent, err := repo.GetAgentByName(ctx, "test-agent") + if err != nil { + t.Fatalf("get agent: %v", err) + } + source := &models.AgentProfile{AgentID: agent.ID, Name: "Default"} + if err := repo.CreateAgentProfile(ctx, source); err != nil { + t.Fatalf("create source: %v", err) + } + + clone := &models.AgentProfile{AgentID: agent.ID, Name: "Default Copy"} + if err := repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{ + Source: source, + Profile: clone, + }); err != nil { + t.Fatalf("DuplicateAgentProfile: %v", err) + } + if _, err := repo.GetAgentProfileMcpConfig(ctx, clone.ID); err == nil { + t.Fatal("expected no MCP row for a copy without config") + } +} + +// TestDuplicateAgentProfile_DetectsConcurrentChange verifies the transaction +// aborts with ErrProfileChanged when the source row moved on since the caller +// built the copy (here: a stale revision), and creates nothing. +func TestDuplicateAgentProfile_DetectsConcurrentChange(t *testing.T) { + repo := newFreshRepo(t) + ctx := context.Background() + + if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent"}); err != nil { + t.Fatalf("seed agent: %v", err) + } + agent, err := repo.GetAgentByName(ctx, "test-agent") + if err != nil { + t.Fatalf("get agent: %v", err) + } + source := &models.AgentProfile{AgentID: agent.ID, Name: "Default"} + if err := repo.CreateAgentProfile(ctx, source); err != nil { + t.Fatalf("create source: %v", err) + } + // A concurrent writer bumps the source after the caller's snapshot. + if _, err := repo.UpdateAgentProfileEnabled(ctx, source.ID, false); err != nil { + t.Fatalf("bump source: %v", err) + } + + clone := &models.AgentProfile{AgentID: agent.ID, Name: "Default Copy"} + err = repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{ + Source: source, // stale: UpdatedAt predates the bump above + Profile: clone, + }) + if !errors.Is(err, ErrProfileChanged) { + t.Fatalf("err = %v, want ErrProfileChanged", err) + } + if _, err := repo.GetAgentProfile(ctx, clone.ID); !errors.Is(err, sql.ErrNoRows) { + t.Fatalf("copy row created despite stale source: err=%v", err) + } +} + +// TestDuplicateAgentProfile_DetectsMcpRowCreatedMidFlight verifies the +// transaction aborts when the caller's snapshot had NO MCP row but one was +// created before the duplicate ran — otherwise the copy would silently drop +// the newly configured servers. +func TestDuplicateAgentProfile_DetectsMcpRowCreatedMidFlight(t *testing.T) { + repo := newFreshRepo(t) + ctx := context.Background() + + if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent"}); err != nil { + t.Fatalf("seed agent: %v", err) + } + agent, err := repo.GetAgentByName(ctx, "test-agent") + if err != nil { + t.Fatalf("get agent: %v", err) + } + source := &models.AgentProfile{AgentID: agent.ID, Name: "Default"} + if err := repo.CreateAgentProfile(ctx, source); err != nil { + t.Fatalf("create source: %v", err) + } + // The caller read "no MCP row", then a concurrent writer created one. + mcp := &models.AgentProfileMcpConfig{ + ProfileID: source.ID, + Enabled: true, + Servers: map[string]interface{}{"github": "x"}, + } + if err := repo.UpsertAgentProfileMcpConfig(ctx, mcp); err != nil { + t.Fatalf("create source mcp: %v", err) + } + + clone := &models.AgentProfile{AgentID: agent.ID, Name: "Default Copy"} + err = repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{ + Source: source, // SourceMcp nil: snapshot predates the MCP row + Profile: clone, + }) + if !errors.Is(err, ErrProfileChanged) { + t.Fatalf("err = %v, want ErrProfileChanged (MCP row created mid-flight)", err) + } + if _, err := repo.GetAgentProfile(ctx, clone.ID); !errors.Is(err, sql.ErrNoRows) { + t.Fatalf("copy row created despite new MCP row: err=%v", err) + } +} + +// TestDuplicateAgentProfile_RollsBackMcpFailure verifies the transaction +// rolls back the inserted profile row when the MCP upsert fails AFTER the +// insert. A regression that commits the profile before the MCP write would +// leave a partial, selectable copy on every failed duplicate. +func TestDuplicateAgentProfile_RollsBackMcpFailure(t *testing.T) { + repo := newFreshRepo(t) + ctx := context.Background() + + if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent"}); err != nil { + t.Fatalf("seed agent: %v", err) + } + agent, err := repo.GetAgentByName(ctx, "test-agent") + if err != nil { + t.Fatalf("get agent: %v", err) + } + source := &models.AgentProfile{AgentID: agent.ID, Name: "Default"} + if err := repo.CreateAgentProfile(ctx, source); err != nil { + t.Fatalf("create source: %v", err) + } + // The source has a valid MCP row so the snapshot verification passes and + // the failure below happens during the insert-time serialization. + sourceMcp := &models.AgentProfileMcpConfig{ + ProfileID: source.ID, + Enabled: true, + Servers: map[string]interface{}{"ok": "v"}, + } + if err := repo.UpsertAgentProfileMcpConfig(ctx, sourceMcp); err != nil { + t.Fatalf("seed source mcp: %v", err) + } + + clone := &models.AgentProfile{AgentID: agent.ID, Name: "Default Copy"} + // A channel is not JSON-serializable: the MCP upsert fails during + // serialization, which happens AFTER the profile row was inserted inside + // the transaction. + badMcp := &models.AgentProfileMcpConfig{ + Enabled: true, + Servers: map[string]interface{}{"bad": make(chan int)}, + } + err = repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{ + Source: source, + SourceMcp: sourceMcp, + Profile: clone, + McpConfig: badMcp, + }) + if err == nil { + t.Fatal("expected MCP serialization error, got nil") + } + if _, err := repo.GetAgentProfile(ctx, clone.ID); !errors.Is(err, sql.ErrNoRows) { + t.Fatalf("copy row survived a failed duplicate (rollback missing): err=%v", err) + } +} diff --git a/apps/backend/internal/agent/settings/store/store.go b/apps/backend/internal/agent/settings/store/store.go index 2114b291f8..4a1f78c5a5 100644 --- a/apps/backend/internal/agent/settings/store/store.go +++ b/apps/backend/internal/agent/settings/store/store.go @@ -2,11 +2,34 @@ package store import ( "context" + "errors" "time" "github.com/kandev/kandev/internal/agent/settings/models" ) +var ( + // ErrProfileChanged is returned by DuplicateAgentProfile when a source + // row changed between the caller's read and the transactional insert, so + // the copy would not reflect a consistent snapshot. Callers retry on a + // fresh read. + ErrProfileChanged = errors.New("source profile changed during duplicate") + // ErrSourceProfileNotFound is returned by DuplicateAgentProfile when the + // source profile row no longer exists (deleted mid-flight). + ErrSourceProfileNotFound = errors.New("source profile not found") +) + +// DuplicateAgentProfileInput carries everything the atomic duplicate needs: +// the copy rows the caller built (Profile, McpConfig) plus the source rows +// they were built from (Source, SourceMcp) so the transaction can verify the +// copy reflects one consistent snapshot. +type DuplicateAgentProfileInput struct { + Source *models.AgentProfile + SourceMcp *models.AgentProfileMcpConfig // nil when the source has no MCP row + Profile *models.AgentProfile + McpConfig *models.AgentProfileMcpConfig // nil when SourceMcp is nil +} + type Repository interface { CreateAgent(ctx context.Context, agent *models.Agent) error GetAgent(ctx context.Context, id string) (*models.Agent, error) @@ -20,6 +43,13 @@ type Repository interface { UpsertAgentProfileMcpConfig(ctx context.Context, config *models.AgentProfileMcpConfig) error CreateAgentProfile(ctx context.Context, profile *models.AgentProfile) error + // DuplicateAgentProfile creates an independent copy of a profile in one + // transaction: the row is inserted with the caller-provided Enabled state + // and the MCP config row is upserted when non-nil. A failure rolls back + // and leaves no partial copy. The source rows are re-read inside the + // transaction and must still match the revisions the copy was built from; + // otherwise ErrProfileChanged is returned and no row is created. + DuplicateAgentProfile(ctx context.Context, input DuplicateAgentProfileInput) error UpdateAgentProfile(ctx context.Context, profile *models.AgentProfile) error UpdateAgentProfileEnabled(ctx context.Context, id string, enabled bool) (time.Time, error) DeleteAgentProfile(ctx context.Context, id string) error diff --git a/apps/backend/internal/gateway/websocket/access_test.go b/apps/backend/internal/gateway/websocket/access_test.go index d277b209c6..cb805eea17 100644 --- a/apps/backend/internal/gateway/websocket/access_test.go +++ b/apps/backend/internal/gateway/websocket/access_test.go @@ -11,6 +11,7 @@ import ( "github.com/gin-gonic/gin" + "github.com/kandev/kandev/internal/agent/settings/dto" "github.com/kandev/kandev/internal/auth/authn" "github.com/kandev/kandev/internal/common/logger" ws "github.com/kandev/kandev/pkg/websocket" @@ -328,6 +329,54 @@ func TestBroadcastToWorkspaceRoutesByOwner(t *testing.T) { waitForMessage(t, clientA) } +// TestBroadcastToWorkspaceOrDropFailsClosed verifies office-scoped broadcasts +// are dropped when the hub cannot route by workspace. +func TestBroadcastToWorkspaceOrDropFailsClosed(t *testing.T) { + hub := newAccessTestHub(t) + hub.setAuthPolicy(AuthPolicy{ + Enforced: func() bool { return true }, + WorkspaceOwner: func(_ context.Context, workspaceID string) (string, error) { + if workspaceID == "ws-a" { + return "user-a", nil + } + return "", errors.New("unknown workspace") + }, + }) + clientA := registerAccessClient(t, hub, "a", authn.Identity{UserID: "user-a", Role: authn.RoleMember}) + clientB := registerAccessClient(t, hub, "b", authn.Identity{UserID: "user-b", Role: authn.RoleMember}) + + notify := func(action string) *ws.Message { + msg, err := ws.NewNotification(action, map[string]interface{}{"workspace_id": "ws-a"}) + if err != nil { + t.Fatal(err) + } + return msg + } + + // Resolvable workspace: only the owner receives it, the foreign user + // never does. + hub.BroadcastToWorkspaceOrDrop("ws-a", notify("agent.profile.updated")) + if got := receivedActions(clientA); len(got) != 1 { + t.Fatalf("owner received %v, want 1 message", got) + } + if got := receivedActions(clientB); len(got) != 0 { + t.Fatalf("foreign user received %v, want none — WS LEAK", got) + } + + // Unresolvable workspace: DROPPED under enforced auth — never the + // global fallback that BroadcastToWorkspace applies. + hub.BroadcastToWorkspaceOrDrop("ws-mystery", notify("agent.profile.updated")) + if got := receivedActions(clientB); len(got) != 0 { + t.Fatalf("unresolvable workspace leaked globally: %v", got) + } + + // Empty workspace ID under enforced auth: DROPPED. + hub.BroadcastToWorkspaceOrDrop("", notify("agent.profile.updated")) + if got := receivedActions(clientB); len(got) != 0 { + t.Fatalf("empty workspace leaked globally: %v", got) + } +} + func waitForMessage(t *testing.T, client *Client) { t.Helper() select { @@ -467,4 +516,18 @@ func TestExtractWorkspaceIDFieldShapes(t *testing.T) { if got := extractWorkspaceID("not-a-map"); got != "" { t.Fatalf("non-map payload: %q", got) } + // Profile events wrap the profile under "profile". The wrapper is a map + // after a JSON round-trip (remote event bus) and a struct on the + // in-process bus; both must resolve the nested workspace ID so office + // profile events never fall back to the global broadcast. + if got := extractWorkspaceID(map[string]interface{}{ + "profile": map[string]interface{}{"workspace_id": "ws-nested-map"}, + }); got != "ws-nested-map" { + t.Fatalf("map-nested profile workspace_id: %q", got) + } + if got := extractWorkspaceID(map[string]interface{}{ + "profile": &dto.AgentProfileDTO{WorkspaceID: "ws-nested-struct"}, + }); got != "ws-nested-struct" { + t.Fatalf("struct-nested profile workspace_id: %q", got) + } } diff --git a/apps/backend/internal/gateway/websocket/hub.go b/apps/backend/internal/gateway/websocket/hub.go index 53d062d700..8288dadbcf 100644 --- a/apps/backend/internal/gateway/websocket/hub.go +++ b/apps/backend/internal/gateway/websocket/hub.go @@ -317,6 +317,39 @@ func (h *Hub) BroadcastToWorkspace(workspaceID string, msg *ws.Message) { h.Broadcast(msg) return } + h.broadcastToOwner(owner, msg) +} + +// BroadcastToWorkspaceOrDrop is the fail-closed sibling of +// BroadcastToWorkspace: when per-user auth is enforced it DROPS the message +// unless the workspace is non-empty AND resolves to a known owner — it never +// falls back to a global broadcast. Every Office notification is +// workspace-scoped, so an office payload whose workspace could not be +// resolved must never cross user boundaries. With auth disabled (single +// user) it degrades to a plain global broadcast, preserving today's +// behavior. +func (h *Hub) BroadcastToWorkspaceOrDrop(workspaceID string, msg *ws.Message) { + if !h.workspaceScopeEnforced() { + h.BroadcastToWorkspace(workspaceID, msg) + return + } + if workspaceID == "" { + return // fail closed: no unattributed office fan-out under auth + } + resolver := h.authPolicy.WorkspaceOwner + if resolver == nil { + return // fail closed: cannot scope without an owner resolver + } + owner, err := resolver(h.DispatchContext(), workspaceID) + if err != nil || owner == "" { + return // fail closed: unresolvable workspace must not go global + } + h.broadcastToOwner(owner, msg) +} + +// broadcastToOwner fans a message out to the clients allowed to see the +// workspace owner. Shared by the workspace-scoped broadcast paths. +func (h *Hub) broadcastToOwner(owner string, msg *ws.Message) { data, err := json.Marshal(msg) if err != nil { h.logger.Error("Failed to marshal workspace broadcast", zap.Error(err)) @@ -333,19 +366,6 @@ func (h *Hub) BroadcastToWorkspace(workspaceID string, msg *ws.Message) { h.sendToClients(data, recipients, msg.Action) } -// BroadcastToWorkspaceOrDrop routes like BroadcastToWorkspace but, when auth is -// enforced and the workspace is unknown, DROPS the message instead of falling -// back to a global broadcast. Every Office notification is workspace-scoped, so -// an office payload whose workspace could not be resolved must never cross user -// boundaries. With auth disabled (single user) it degrades to a plain global -// broadcast, preserving today's behavior. -func (h *Hub) BroadcastToWorkspaceOrDrop(workspaceID string, msg *ws.Message) { - if workspaceID == "" && h.workspaceScopeEnforced() { - return // fail closed: no unattributed office fan-out under auth - } - h.BroadcastToWorkspace(workspaceID, msg) -} - // workspaceScopeEnforced reports whether per-user auth is currently on. func (h *Hub) workspaceScopeEnforced() bool { enforced := h.authPolicy.Enforced diff --git a/apps/backend/internal/gateway/websocket/task_notifications.go b/apps/backend/internal/gateway/websocket/task_notifications.go index 2d67bac2cb..0a6937b41c 100644 --- a/apps/backend/internal/gateway/websocket/task_notifications.go +++ b/apps/backend/internal/gateway/websocket/task_notifications.go @@ -289,6 +289,15 @@ func (b *TaskEventBroadcaster) routeBroadcast( // GitHub PR or GitLab MR update must never cross workspace boundaries. b.hub.BroadcastToWorkspaceOrDrop(workspaceID, msg) return nil + case ws.ActionAgentProfileCreated, ws.ActionAgentProfileUpdated, ws.ActionAgentProfileDeleted: + // Profile payloads wrap the profile DTO under "profile"; office-scoped + // profiles (nested workspace_id) must never cross workspace + // boundaries — route them fail-closed. Kanban profiles (empty + // workspace) are instance-wide and fall through to the global path. + if workspaceID != "" { + b.hub.BroadcastToWorkspaceOrDrop(workspaceID, msg) + return nil + } } // Workspace-carrying events (task/workflow/repository/…) route to the // owner's clients; events without workspace context (executors, @@ -298,12 +307,21 @@ func (b *TaskEventBroadcaster) routeBroadcast( } // extractWorkspaceID pulls a workspace ID from event payloads (map- or -// struct-shaped). Empty means "no workspace context" — the event is treated -// as instance-wide and broadcast to everyone. +// struct-shaped, nested included). Profile events wrap the profile DTO under +// "profile": the wrapper may be a map (JSON round-tripped bus) or a struct +// (in-process bus, e.g. *dto.AgentProfileDTO from the MCP publisher), so the +// nested value is inspected recursively and structs expose their ID via the +// GetWorkspaceID interface. Empty means "no workspace context" — the event is +// treated as instance-wide and broadcast to everyone. func extractWorkspaceID(data interface{}) string { if id := extractStringField(data, "workspace_id"); id != "" { return id } + if profile, ok := data.(map[string]interface{}); ok { + if id := extractWorkspaceID(profile["profile"]); id != "" { + return id + } + } if provider, ok := data.(interface{ GetWorkspaceID() string }); ok { return provider.GetWorkspaceID() } diff --git a/apps/web/app/actions/agents.ts b/apps/web/app/actions/agents.ts index daa351d6d7..b97ada6eab 100644 --- a/apps/web/app/actions/agents.ts +++ b/apps/web/app/actions/agents.ts @@ -144,6 +144,20 @@ export async function updateAgentProfileAction( return normalizeAgentProfile(raw); } +/** + * Duplicate a profile: the backend copies the source's full configuration + * into a new row named " copy" and returns the new profile. The + * existing `agent.profile.created` WS notification also picks the copy up in + * every open settings surface. + */ +export async function duplicateAgentProfileAction(id: string): Promise { + const raw = await agentSettingsRequest( + `${apiBaseUrl}/api/v1/agent-profiles/${id}/duplicate`, + { method: "POST" }, + ); + return normalizeAgentProfile(raw); +} + import type { ActiveSessionInfo, AutomationReference, diff --git a/apps/web/components/settings/agent-profile-duplicate-action.test.tsx b/apps/web/components/settings/agent-profile-duplicate-action.test.tsx new file mode 100644 index 0000000000..a4a024446e --- /dev/null +++ b/apps/web/components/settings/agent-profile-duplicate-action.test.tsx @@ -0,0 +1,190 @@ +import { act, cleanup, fireEvent, render, screen } from "@testing-library/react"; +import { afterEach, describe, expect, it, vi } from "vitest"; +import type { Agent, AgentProfile } from "@/lib/types/http"; +import { useProfileDuplicateAction } from "./agent-profile-duplicate-action"; + +type ToastArgs = { + title?: string; + description?: string; + variant?: "default" | "success" | "error" | "loading"; +}; + +const duplicateAction = vi.fn<(id: string) => Promise>(); +const saveAll = vi.fn<() => Promise<{ canLeave: boolean; failedIds: Set }>>(); +const cancelPendingNavigation = vi.fn<() => void>(); +const routerPush = vi.fn<(href: string) => void>(); +const toast = vi.fn<(args: ToastArgs) => void>(); +const setState = vi.fn<() => void>(); + +const hoisted = vi.hoisted(() => ({ + coordinatorInvalidReason: undefined as string | undefined, +})); + +vi.mock("@/app/actions/agents", () => ({ + duplicateAgentProfileAction: (id: string) => duplicateAction(id), +})); +vi.mock("@/components/state-provider", () => ({ useAppStoreApi: () => ({ setState }) })); +vi.mock("@/components/toast-provider", () => ({ useToast: () => ({ toast }) })); +vi.mock("@/components/settings/settings-save-provider", () => ({ + useSettingsSaveCoordinator: () => ({ + saveAll, + invalidReason: hoisted.coordinatorInvalidReason, + cancelPendingNavigation, + }), +})); +vi.mock("@/lib/routing/client-router", () => ({ useRouter: () => ({ push: routerPush }) })); +vi.mock("@/lib/routing/navigation-guard", () => ({ + runWithNavigationBlockerBypassed: (fn: () => void) => fn(), +})); +vi.mock("@/components/settings/agent-profile-page-state", () => ({ + errorMessage: (error: unknown) => (error instanceof Error ? error.message : String(error)), +})); + +/** Builds an Agent fixture for the duplicate-action harness. */ +function agent(): Agent { + return { id: "a1", name: "mock-agent", profiles: [] } as unknown as Agent; +} + +type DraftOverrides = Partial> & { + id?: string; + agentId?: string; + name?: string; +}; + +/** Builds a profile draft (SettingsSaveContributor) for the duplicate-action harness. */ +function draft(overrides: DraftOverrides = {}): AgentProfile { + return { + id: "p1", + agentId: "a1", + name: "Default", + agentDisplayName: "Mock", + model: "mock-fast", + allowIndexing: false, + autoApprove: false, + cliFlags: [], + cliPassthrough: false, + enabled: true, + createdAt: "", + updatedAt: "", + ...overrides, + } as unknown as AgentProfile; +} + +/** Renders the duplicate action with the settings save provider and navigation guard. */ +function Harness({ profileDraft = draft() }: { profileDraft?: AgentProfile }) { + const { handleDuplicate, duplicating } = useProfileDuplicateAction({ + agent: agent(), + draft: profileDraft, + modelConfigResolutionPending: false, + translate: (key: string) => key, + }); + return ( + + ); +} + +/** Reads the most recently pushed toast from the harness. */ +function lastToast(): ToastArgs { + const call = toast.mock.calls.at(-1); + return call ? call[0] : {}; +} + +afterEach(() => { + cleanup(); + vi.clearAllMocks(); + hoisted.coordinatorInvalidReason = undefined; +}); + +describe("useProfileDuplicateAction", () => { + it("aborts without POSTing when a contributor cannot save", async () => { + saveAll.mockResolvedValue({ canLeave: false, failedIds: new Set() }); + render(); + + await act(async () => { + fireEvent.click(screen.getByRole("button", { name: "duplicate" })); + }); + + expect(duplicateAction).not.toHaveBeenCalled(); + expect(routerPush).not.toHaveBeenCalled(); + }); + + it("toasts the coordinator invalid reason when the profile draft is valid but MCP is not", async () => { + hoisted.coordinatorInvalidReason = "MCP server URL invalid"; + saveAll.mockResolvedValue({ canLeave: false, failedIds: new Set() }); + render(); + + await act(async () => { + fireEvent.click(screen.getByRole("button", { name: "duplicate" })); + }); + + expect(duplicateAction).not.toHaveBeenCalled(); + expect(lastToast().description).toBe("MCP server URL invalid"); + }); + + it("toasts the profile-name validation reason when the draft name is empty", async () => { + saveAll.mockResolvedValue({ canLeave: false, failedIds: new Set() }); + render(); + + await act(async () => { + fireEvent.click(screen.getByRole("button", { name: "duplicate" })); + }); + + expect(duplicateAction).not.toHaveBeenCalled(); + expect(lastToast().description).toBe("agents:profileNameRequired"); + }); + + it("falls back to a generic toast when the save is blocked without a specific reason", async () => { + // canLeave=false with no invalidReason and a valid draft: another save is + // in flight or newer changes appeared. The abort must still be visible. + saveAll.mockResolvedValue({ canLeave: false, failedIds: new Set() }); + render(); + + await act(async () => { + fireEvent.click(screen.getByRole("button", { name: "duplicate" })); + }); + + expect(duplicateAction).not.toHaveBeenCalled(); + expect(lastToast().description).toBe("agents:duplicateSaveBlocked"); + }); + + it("POSTs, merges, toasts, and SPA-navigates when the save succeeds", async () => { + saveAll.mockResolvedValue({ canLeave: true, failedIds: new Set() }); + duplicateAction.mockResolvedValue(draft({ id: "p2", name: "Default Copy" })); + render(); + + await act(async () => { + fireEvent.click(screen.getByRole("button", { name: "duplicate" })); + }); + + expect(duplicateAction).toHaveBeenCalledTimes(1); + expect(duplicateAction).toHaveBeenCalledWith("p1"); + expect(setState).toHaveBeenCalledTimes(1); + expect(cancelPendingNavigation).toHaveBeenCalledTimes(1); + expect(routerPush).toHaveBeenCalledWith("/settings/agents/mock-agent/profiles/p2"); + expect(toast.mock.calls.some(([t]) => t?.title === "agents:duplicateProfileSuccess")).toBe( + true, + ); + }); + + it("ignores a second click while the first duplicate is in flight", async () => { + saveAll.mockResolvedValue({ canLeave: true, failedIds: new Set() }); + let resolveDuplicate: (value: AgentProfile) => void = () => undefined; + duplicateAction.mockImplementation( + () => + new Promise((resolve) => { + resolveDuplicate = resolve; + }), + ); + render(); + + fireEvent.click(screen.getByRole("button", { name: "duplicate" })); + fireEvent.click(screen.getByRole("button", { name: "duplicate" })); + await act(async () => { + resolveDuplicate(draft({ id: "p2", name: "Default Copy" })); + }); + + expect(duplicateAction).toHaveBeenCalledTimes(1); + }); +}); diff --git a/apps/web/components/settings/agent-profile-duplicate-action.ts b/apps/web/components/settings/agent-profile-duplicate-action.ts new file mode 100644 index 0000000000..e1a8d07878 --- /dev/null +++ b/apps/web/components/settings/agent-profile-duplicate-action.ts @@ -0,0 +1,133 @@ +"use client"; + +/** + * Header duplicate action for the agent profile settings page, extracted so + * the page stays presentation-only and the save-gate + in-flight guard are + * unit-testable. Mirrors the agent-profile-page-state.ts split. + */ + +import { useCallback, useRef, useState } from "react"; +import { duplicateAgentProfileAction } from "@/app/actions/agents"; +import { useAppStoreApi } from "@/components/state-provider"; +import { useToast } from "@/components/toast-provider"; +import { useSettingsSaveCoordinator } from "@/components/settings/settings-save-provider"; +import { applyProfileDuplicated } from "@/hooks/domains/settings/use-profile-duplicate"; +import { errorMessage } from "@/components/settings/agent-profile-page-state"; +import { useRouter } from "@/lib/routing/client-router"; +import { runWithNavigationBlockerBypassed } from "@/lib/routing/navigation-guard"; +import type { Agent, AgentProfile } from "@/lib/types/http"; + +/** + * Returns the localized reason a profile draft cannot be saved yet (missing + * name or model resolution still pending), or undefined when it is savable. + */ +export function profileSaveInvalidReason( + profileName: string, + modelConfigResolutionPending: boolean, + translate: (key: string) => string, +): string | undefined { + if (!profileName.trim()) return translate("agents:profileNameRequired"); + if (modelConfigResolutionPending) return translate("agents:resolvingModelOptions"); + return undefined; +} + +type UseProfileDuplicateActionOptions = { + agent: Agent; + draft: AgentProfile; + modelConfigResolutionPending: boolean; + translate: (key: string) => string; +}; + +/** + * Header "Duplicate" flow: save every dirty contributor (profile editor AND + * MCP card) through the shared settings coordinator — aborting with the + * blocking contributor's reason when anything is invalid — then POST the + * duplicate, merge the copy into the store, toast, and SPA-navigate to the + * copy's page. The in-flight guard is a ref (synchronous) so two rapid clicks + * can never issue two copies; the state only drives the button's disabled + * state. + */ +export function useProfileDuplicateAction({ + agent, + draft, + modelConfigResolutionPending, + translate, +}: UseProfileDuplicateActionOptions) { + const storeApi = useAppStoreApi(); + const router = useRouter(); + const { saveAll, invalidReason, cancelPendingNavigation } = useSettingsSaveCoordinator(); + const { toast } = useToast(); + const [duplicating, setDuplicating] = useState(false); + const inFlightRef = useRef(false); + + const handleDuplicate = useCallback(async () => { + if (inFlightRef.current) return; + inFlightRef.current = true; + setDuplicating(true); + try { + // Save EVERY dirty contributor (the profile editor AND the MCP card) + // so the copy starts from what the user sees. saveAll respects each + // contributor's canSave; when anything is invalid or fails to persist, + // it reports canLeave=false and we abort before posting. + const saved = await saveAll(); + if (!saved.canLeave) { + // Surface whichever contributor is blocking the save (MCP error or + // an invalid profile draft); when the coordinator gives no reason + // (another save in flight, or newer changes appeared during the + // awaited save), fall back to a generic message so the abort is + // never silent. + toast({ + title: translate("agents:failedToDuplicateProfile"), + description: + invalidReason ?? + profileSaveInvalidReason(draft.name, modelConfigResolutionPending, translate) ?? + translate("agents:duplicateSaveBlocked"), + variant: "error", + }); + return; + } + const created = await duplicateAgentProfileAction(draft.id); + // Merge the copy into the store so the destination page resolves it + // without waiting on the WS round-trip. + storeApi.setState((state) => applyProfileDuplicated(state, agent, created)); + toast({ + title: translate("agents:duplicateProfileSuccess"), + description: created.name, + variant: "success", + }); + // Supersede any navigation intent the dirty guard blocked (e.g. a + // browser-back while dirty) — this duplicate navigation replaces it. + cancelPendingNavigation(); + // SPA navigation, not location.assign: the toast survives the route + // change and the dirty-settings blocker was already resolved by the + // save above (the bypass is the pattern the executor editors use + // after an awaited save). + runWithNavigationBlockerBypassed(() => + router.push(`/settings/agents/${encodeURIComponent(agent.name)}/profiles/${created.id}`), + ); + } catch (error) { + toast({ + title: translate("agents:failedToDuplicateProfile"), + description: errorMessage(error), + variant: "error", + }); + } finally { + inFlightRef.current = false; + setDuplicating(false); + } + }, [ + agent, + cancelPendingNavigation, + draft.id, + draft.name, + invalidReason, + modelConfigResolutionPending, + router, + saveAll, + storeApi, + toast, + translate, + ]); + + return { handleDuplicate, duplicating }; +} diff --git a/apps/web/components/settings/agent-profile-page-state.test.ts b/apps/web/components/settings/agent-profile-page-state.test.ts new file mode 100644 index 0000000000..0f00596f3c --- /dev/null +++ b/apps/web/components/settings/agent-profile-page-state.test.ts @@ -0,0 +1,132 @@ +import { describe, expect, it, vi } from "vitest"; +import type { Agent } from "@/lib/types/http"; +import type { AgentProfileOption } from "@/lib/state/slices/settings/types"; +import { reconcileAgentProfileOptions } from "./agent-profile-page-state"; + +vi.mock("@/app/actions/agents", () => ({ + deleteAgentProfileAction: vi.fn(), + updateAgentProfileAction: vi.fn(), +})); +vi.mock("@/components/state-provider", () => ({ useAppStore: vi.fn(), useAppStoreApi: vi.fn() })); +vi.mock("@/lib/i18n", () => ({ t: (key: string) => key })); + +/** Builds an Agent fixture with the given profile names. */ +function agent(id: string, ...profileNames: string[]): Agent { + return { + id, + name: id, + profiles: profileNames.map((name) => ({ + id: name, + agentId: id, + name, + agentDisplayName: "Test Agent", + model: "", + allowIndexing: false, + autoApprove: false, + cliFlags: [], + cliPassthrough: false, + enabled: true, + createdAt: "", + updatedAt: "", + })), + } as unknown as Agent; +} + +/** Builds an AgentProfileOption fixture with an optional updatedAt. */ +function option(id: string, updatedAt = ""): AgentProfileOption { + return { + id, + label: id, + agent_id: "a1", + agent_name: "a1", + cli_passthrough: false, + updatedAt, + }; +} + +describe("reconcileAgentProfileOptions", () => { + it("rebuilds options from the next agent list", () => { + const next = reconcileAgentProfileOptions([], [agent("a1", "p1", "p2")]); + expect(next.map((o) => o.id).sort()).toEqual(["p1", "p2"]); + }); + + it("preserves WS-delivered orphan options the rebuild does not represent", () => { + // p-orphan was delivered by WS for an agent absent from the next list. + const next = reconcileAgentProfileOptions([option("p-orphan")], [agent("a1", "p1")]); + const ids = next.map((o) => o.id); + expect(ids).toContain("p-orphan"); + expect(ids).toContain("p1"); + }); + + it("replaces stale options with the rebuilt versions by id", () => { + const next = reconcileAgentProfileOptions([option("p1")], [agent("a1", "p1")]); + expect(next.filter((o) => o.id === "p1")).toHaveLength(1); + expect(next.find((o) => o.id === "p1")?.label).toContain("p1"); + }); + + it("keeps a newer existing option over a stale rebuilt one", () => { + // WS updated the option (enabled=false, newer revision) while the next + // agent list carries a stale profile. The rebuild must not regress it. + const staleProfile = { + id: "a1", + name: "a1", + profiles: [ + { + id: "p1", + agentId: "a1", + name: "p1", + agentDisplayName: "Test Agent", + model: "", + allowIndexing: false, + autoApprove: false, + cliFlags: [], + cliPassthrough: false, + enabled: true, + createdAt: "", + updatedAt: "2026-08-11T21:00:00Z", + }, + ], + } as unknown as Agent; + const newerOption = { ...option("p1", "2026-08-11T22:00:00Z"), enabled: false }; + + const next = reconcileAgentProfileOptions([newerOption], [staleProfile]); + + const options = next.filter((o) => o.id === "p1"); + expect(options).toHaveLength(1); + expect(options[0].enabled).toBe(false); + expect(options[0].updatedAt).toBe("2026-08-11T22:00:00Z"); + }); + + it("keeps a fractional-second newer option over a whole-second rebuilt one", () => { + // Lexically "…22:00:00Z" sorts after "…22:00:00.100Z" despite being + // older, so revision precedence must compare instants, not strings. + const staleProfile = { + id: "a1", + name: "a1", + profiles: [ + { + id: "p1", + agentId: "a1", + name: "p1", + agentDisplayName: "Test Agent", + model: "", + allowIndexing: false, + autoApprove: false, + cliFlags: [], + cliPassthrough: false, + enabled: true, + createdAt: "", + updatedAt: "2026-08-11T22:00:00Z", + }, + ], + } as unknown as Agent; + const fractionalOption = { ...option("p1", "2026-08-11T22:00:00.100Z"), enabled: false }; + + const next = reconcileAgentProfileOptions([fractionalOption], [staleProfile]); + + const options = next.filter((o) => o.id === "p1"); + expect(options).toHaveLength(1); + expect(options[0].enabled).toBe(false); + expect(options[0].updatedAt).toBe("2026-08-11T22:00:00.100Z"); + }); +}); diff --git a/apps/web/components/settings/agent-profile-page-state.ts b/apps/web/components/settings/agent-profile-page-state.ts index d3c323c029..5cc87f605c 100644 --- a/apps/web/components/settings/agent-profile-page-state.ts +++ b/apps/web/components/settings/agent-profile-page-state.ts @@ -12,26 +12,47 @@ import { useMemo, useState } from "react"; import { permissionsToProfilePatch } from "@/lib/agent-permissions"; import { deleteAgentProfileAction, updateAgentProfileAction } from "@/app/actions/agents"; -import { useAppStore } from "@/components/state-provider"; +import { useAppStore, useAppStoreApi } from "@/components/state-provider"; import { isProfileDirty } from "@/components/settings/agent-profile-dirty"; import type { useToast } from "@/components/toast-provider"; import type { AgentProfileDeleteConflict } from "@/components/settings/agent-profile-delete-dialog"; import { t as translate } from "@/lib/i18n"; -import { toAgentProfileOption } from "@/lib/state/slices/settings/types"; +import { + mergeOptionsByNewest, + toAgentProfileOption, + type AgentProfileOption, +} from "@/lib/state/slices/settings/types"; import { ApiError } from "@/lib/api/client"; import type { Agent, AgentProfile, PermissionSetting } from "@/lib/types/http"; export type SaveStatus = "idle" | "loading" | "success" | "error"; +/** + * Reconcile the options slice with the next agent list by ID: options the + * rebuild does not represent (e.g. profiles the WS handler delivered for + * agents temporarily absent from `settingsAgents`) are preserved, and rebuilt + * options replace any stale versions. Same rule as + * `applyProfileDuplicated` in the duplicate hook — a save must never wipe + * orphan options. + */ +export function reconcileAgentProfileOptions( + previousOptions: AgentProfileOption[], + nextAgents: Agent[], +): AgentProfileOption[] { + const rebuiltOptions = nextAgents.flatMap((agentItem) => + agentItem.profiles.map((agentProfile) => toAgentProfileOption(agentItem, agentProfile)), + ); + return mergeOptionsByNewest(previousOptions, rebuiltOptions); +} + export function useSyncAgentsToStore() { const setSettingsAgents = useAppStore((state) => state.setSettingsAgents); const setAgentProfiles = useAppStore((state) => state.setAgentProfiles); + const storeApi = useAppStoreApi(); return (nextAgents: Agent[]) => { setSettingsAgents(nextAgents); setAgentProfiles( - nextAgents.flatMap((agentItem) => - agentItem.profiles.map((agentProfile) => toAgentProfileOption(agentItem, agentProfile)), - ), + reconcileAgentProfileOptions(storeApi.getState().agentProfiles.items, nextAgents), ); }; } diff --git a/apps/web/components/settings/agent-profile-page.tsx b/apps/web/components/settings/agent-profile-page.tsx index 7d86bda65a..4504467943 100644 --- a/apps/web/components/settings/agent-profile-page.tsx +++ b/apps/web/components/settings/agent-profile-page.tsx @@ -4,7 +4,7 @@ import { useCallback, useState } from "react"; import { useTranslation } from "react-i18next"; import Link from "@/components/routing/app-link"; import { useParams } from "@/lib/routing/client-router"; -import { IconTrash } from "@tabler/icons-react"; +import { IconCopy, IconTrash } from "@tabler/icons-react"; import { Badge } from "@kandev/ui/badge"; import { Button } from "@kandev/ui/button"; import { Card, CardContent, CardHeader, CardTitle } from "@kandev/ui/card"; @@ -33,6 +33,10 @@ import { useProfileSave, useSyncAgentsToStore, } from "@/components/settings/agent-profile-page-state"; +import { + profileSaveInvalidReason, + useProfileDuplicateAction, +} from "@/components/settings/agent-profile-duplicate-action"; import { CustomCLIFlagsCard } from "@/components/settings/cli-flags-field"; import { ProfileEnabledHelp } from "@/components/settings/profile-enabled-help"; @@ -73,24 +77,18 @@ type ProfileEditorHeaderProps = { savedProfileName: string; enabled: boolean; onEnabledChange: (enabled: boolean) => void; + onDuplicate: () => void; + duplicating: boolean; }; -function profileSaveInvalidReason( - profileName: string, - modelConfigResolutionPending: boolean, - translate: (key: string) => string, -): string | undefined { - if (!profileName.trim()) return translate("agents:profileNameRequired"); - if (modelConfigResolutionPending) return translate("agents:resolvingModelOptions"); - return undefined; -} - function ProfileEditorHeader({ agentName, agentDisplayName, savedProfileName, enabled, onEnabledChange, + onDuplicate, + duplicating, }: ProfileEditorHeaderProps) { const { t } = useTranslation(); return ( @@ -105,6 +103,18 @@ function ProfileEditorHeader({

+

{t("agents:enabled")}

@@ -403,6 +413,13 @@ function ProfileEditor({ }); const deleteState = useProfileDelete(agent, draft, settingsAgents, syncAgentsToStore, toast); + const { handleDuplicate: handleDuplicateProfile, duplicating } = useProfileDuplicateAction({ + agent, + draft, + modelConfigResolutionPending, + translate: t, + }); + return (
updateDraft({ enabled: next })} + onDuplicate={() => void handleDuplicateProfile()} + duplicating={duplicating} /> diff --git a/apps/web/components/settings/agents/agent-profiles-section.test.tsx b/apps/web/components/settings/agents/agent-profiles-section.test.tsx index 05de88d4c0..c3b07cbfc5 100644 --- a/apps/web/components/settings/agents/agent-profiles-section.test.tsx +++ b/apps/web/components/settings/agents/agent-profiles-section.test.tsx @@ -6,6 +6,7 @@ import type { Agent, AgentProfile } from "@/lib/types/http"; const mocks = vi.hoisted(() => ({ deleteAgentProfileAction: vi.fn(), + duplicateAgentProfileAction: vi.fn(), toast: vi.fn(), routerPush: vi.fn(), })); @@ -41,11 +42,12 @@ const selectors = { vi.mock("@/components/state-provider", () => ({ useAppStore: (selector: (s: unknown) => unknown) => selector({ ...storeState, ...selectors }), - useAppStoreApi: () => ({ getState: () => storeState }), + useAppStoreApi: () => ({ getState: () => storeState, setState: vi.fn() }), })); vi.mock("@/app/actions/agents", () => ({ deleteAgentProfileAction: mocks.deleteAgentProfileAction, + duplicateAgentProfileAction: mocks.duplicateAgentProfileAction, })); vi.mock("@/components/toast-provider", () => ({ @@ -68,8 +70,16 @@ vi.mock("@kandev/ui/dropdown-menu", () => ({ DropdownMenu: ({ children }: { children?: ReactNode }) =>
{children}
, DropdownMenuTrigger: ({ children }: { children?: ReactNode }) => <>{children}, DropdownMenuContent: ({ children }: { children?: ReactNode }) =>
{children}
, - DropdownMenuItem: ({ children, onSelect }: { children?: ReactNode; onSelect?: () => void }) => ( - ), @@ -158,3 +168,26 @@ describe("ProfileRow deletion", () => { expect(storeState.agentProfiles.items).toEqual([]); }); }); + +describe("ProfileRow duplicate", () => { + beforeEach(() => { + storeState = { + settingsAgents: { items: [{ ...AGENT, profiles: [...AGENT.profiles] }] }, + agentProfiles: { items: [] }, + }; + }); + + it("calls the duplicate action with the profile id", async () => { + mocks.duplicateAgentProfileAction.mockResolvedValue({ + id: "p-3", + name: "Alpha Copy", + } as unknown as AgentProfile); + renderRows(); + + const row = screen.getByLabelText("Alpha").closest('[data-testid="agent-profile-row"]'); + if (!row) throw new Error("no row for Alpha"); + fireEvent.click(row.querySelector('[data-testid="duplicate-profile-p-1"]')!); + + await waitFor(() => expect(mocks.duplicateAgentProfileAction).toHaveBeenCalledWith("p-1")); + }); +}); diff --git a/apps/web/components/settings/agents/agent-profiles-section.tsx b/apps/web/components/settings/agents/agent-profiles-section.tsx index 7cad325e5a..e46468d624 100644 --- a/apps/web/components/settings/agents/agent-profiles-section.tsx +++ b/apps/web/components/settings/agents/agent-profiles-section.tsx @@ -2,7 +2,7 @@ import { useState } from "react"; import { useTranslation } from "react-i18next"; -import { IconDotsVertical, IconPlus, IconTrash } from "@tabler/icons-react"; +import { IconCopy, IconDotsVertical, IconPlus, IconTrash } from "@tabler/icons-react"; import { Badge } from "@kandev/ui/badge"; import { Button } from "@kandev/ui/button"; import { Card, CardContent } from "@kandev/ui/card"; @@ -17,6 +17,7 @@ import { useAppStore, useAppStoreApi } from "@/components/state-provider"; import { useToast } from "@/components/toast-provider"; import { AgentProfileDeleteConfirmDialog } from "@/components/settings/agent-profile-delete-dialog"; import { deleteAgentProfileAction } from "@/app/actions/agents"; +import { useProfileDuplicate } from "@/hooks/domains/settings/use-profile-duplicate"; import { useRouter } from "@/lib/routing/client-router"; import { toAgentProfileOption } from "@/lib/state/slices/settings/types"; import type { Agent, AgentProfile } from "@/lib/types/http"; @@ -76,6 +77,56 @@ export function AgentProfilesSubList({ ); } +/** + * The per-profile actions dropdown (duplicate, delete). The trigger exposes a + * touch-sized hitbox (>= 44px) so the row actions are reachable on mobile. + * Duplication uses the shared useProfileDuplicate hook (per-profile in-flight + * guard, revision-aware store merge). + */ +function ProfileRowActions({ + agent, + profile, + onConfirmDelete, +}: { + agent: Agent; + profile: AgentProfile; + onConfirmDelete: () => void; +}) { + const { t } = useTranslation(); + const handleDuplicate = useProfileDuplicate(); + return ( + + + + + + void handleDuplicate(agent, profile)} + > + + {t("agents:duplicate")} + + + + {t("agents:delete")} + + + + ); +} + /** One saved profile as a fully clickable row — shared by the Agents index and the agent page. */ export function ProfileRow({ agent, profile }: { agent: Agent; profile: AgentProfile }) { const { t } = useTranslation(); @@ -150,27 +201,11 @@ export function ProfileRow({ agent, profile }: { agent: Agent; profile: AgentPro )}
- - - - - - setConfirmOpen(true)} - > - - {t("agents:delete")} - - - + setConfirmOpen(true)} + />
Promise | void; +}) { + const [revision, setRevision] = useState(1); + const [savedRevision, setSavedRevision] = useState(1); // starts clean + + useSettingsSaveContributor({ + id, + revision, + isDirty: revision !== savedRevision, + save: async () => { + await onSave(); + setSavedRevision(revision); + }, + discard: () => setRevision(savedRevision), + }); + + return ( + + ); +} + function BooleanDraftContributor({ pending }: { pending: Deferred }) { const [draft, setDraft] = useState(true); const [baseline, setBaseline] = useState(false); @@ -456,13 +486,13 @@ describe("SettingsSaveProvider navigation", () => { ); fireEvent.click(screen.getByRole("link", { name: "Terminal" })); - fireEvent.click(await screen.findByRole("button", { name: "Save and leave" })); + fireEvent.click(await screen.findByRole("button", { name: SAVE_AND_LEAVE_LABEL })); expect(await screen.findByText("Couldn't save")).toBeTruthy(); expect(window.location.pathname).toBe(APPEARANCE_PATH); shouldFail = false; - fireEvent.click(screen.getByRole("button", { name: "Save and leave" })); + fireEvent.click(screen.getByRole("button", { name: SAVE_AND_LEAVE_LABEL })); await waitFor(() => expect(window.location.pathname).toBe(TERMINAL_PATH)); }); @@ -477,7 +507,7 @@ describe("SettingsSaveProvider navigation", () => { ); fireEvent.click(screen.getByRole("link", { name: "Terminal" })); - fireEvent.click(await screen.findByRole("button", { name: "Save and leave" })); + fireEvent.click(await screen.findByRole("button", { name: SAVE_AND_LEAVE_LABEL })); await waitFor(() => expect(window.location.pathname).toBe(TERMINAL_PATH)); }); @@ -507,6 +537,73 @@ describe("SettingsSaveProvider navigation", () => { }); }); +describe("SettingsSaveProvider mid-save edits", () => { + it("stays put when a contributor becomes dirty while the save is in flight", async () => { + window.history.replaceState({}, "", APPEARANCE_PATH); + const pending = deferred(); + + render( + + pending.promise} /> + + Terminal + , + ); + + fireEvent.click(screen.getByRole("button", { name: "Edit appearance" })); + fireEvent.click(screen.getByRole("link", { name: "Terminal" })); + fireEvent.click(await screen.findByRole("button", { name: SAVE_AND_LEAVE_LABEL })); + // The MCP contributor (clean at the save snapshot) becomes dirty while + // the appearance save is pending. Radix aria-hides the page behind the + // modal, so query with hidden:true. + fireEvent.click(screen.getByRole("button", { name: "Edit mcp", hidden: true })); + + await act(async () => pending.resolve()); + + // The newly dirty contributor blocks leaving: the navigation must not + // proceed (saveAll reports canLeave=false). + await waitFor(() => expect(window.location.pathname).toBe(APPEARANCE_PATH)); + expect(screen.getByRole("button", { name: SAVE_AND_LEAVE_LABEL })).toBeTruthy(); + }); + + it("does not treat a re-rendered same-id contributor as newly dirty mid-save", async () => { + window.history.replaceState({}, "", APPEARANCE_PATH); + const pending = deferred(); + const onSave = vi.fn(() => pending.promise); + + function PokingContributor() { + const [, setPoke] = useState(0); + return ( + <> + + + + ); + } + + render( + + + Terminal + , + ); + + fireEvent.click(screen.getByRole("button", { name: "Edit appearance" })); + fireEvent.click(screen.getByRole("link", { name: "Terminal" })); + fireEvent.click(await screen.findByRole("button", { name: SAVE_AND_LEAVE_LABEL })); + // Re-render the contributor while its save is pending: the registry + // replaces the contributor object on every upsert, so an identity-based + // "newly dirty" check would wrongly block leaving. Same id must not count. + fireEvent.click(screen.getByRole("button", { name: "Poke appearance", hidden: true })); + + await act(async () => pending.resolve()); + + await waitFor(() => expect(window.location.pathname).toBe(TERMINAL_PATH)); + }); +}); + describe("SettingsSaveProvider reset coordination", () => { it("settles navigation requested while a standalone reset is pending", async () => { window.history.replaceState({}, "", APPEARANCE_PATH); diff --git a/apps/web/components/settings/settings-save-provider.tsx b/apps/web/components/settings/settings-save-provider.tsx index c6dcc1be64..48345c006c 100644 --- a/apps/web/components/settings/settings-save-provider.tsx +++ b/apps/web/components/settings/settings-save-provider.tsx @@ -63,6 +63,23 @@ type SaveResult = { const SettingsSaveRegistryContext = createContext(null); const SettingsDirtyScopeContext = createContext(null); +export type SettingsSaveCoordinator = { + /** Save every dirty contributor. Respects each contributor's canSave; + * returns canLeave=false when any contributor is invalid or fails. */ + saveAll: () => Promise; + status: SettingsSaveStatus; + errorKind: SettingsSaveErrorKind | null; + hasDirty: boolean; + /** Reason why the first invalid dirty contributor cannot be saved, if any. */ + invalidReason: string | undefined; + /** Cancel a navigation intent blocked by the dirty guard (the caller is + * superseding it with its own navigation). */ + cancelPendingNavigation: () => void; + clearSavedStatus: () => void; +}; + +const SettingsSaveCoordinatorContext = createContext(null); + export function SettingsSaveProvider({ children, placement = "viewport", @@ -75,10 +92,6 @@ export function SettingsSaveProvider({ contributors, refreshRegistry, ); - const pendingNavigationRef = useRef(null); - const discardingRef = useRef(false); - const [pendingNavigation, setPendingNavigation] = useState(null); - const [isDiscarding, setIsDiscarding] = useState(false); const hasDirty = dirtyContributors.length > 0; const invalidReason = dirtyContributors.find(({ contributor }) => contributor.canSave === false) ?.contributor.invalidReason; @@ -90,6 +103,153 @@ export function SettingsSaveProvider({ return () => window.clearTimeout(timeout); }, [clearSavedStatus, status]); + const { + pendingNavigation, + isDiscarding, + handleSave, + discardDirtyContributors, + discardAndLeave, + continueEditing, + } = useSaveNavigationFlow({ saveAll, contributors, markError, refreshRegistry, hasDirty }); + + useSettingsBeforeUnloadGuard(hasDirty); + + return ( + contributor.id).join(",")} + invalidReason={invalidReason} + pendingNavigation={pendingNavigation} + isDiscarding={isDiscarding} + onSave={handleSave} + onReset={discardDirtyContributors} + onDiscardAndLeave={discardAndLeave} + onContinueEditing={continueEditing} + > + {children} + + ); +} + +type SettingsSaveProviderBodyProps = { + registry: Registry; + coordinator: SettingsSaveCoordinator; + placement: SettingsSavePlacement; + displayStatus: SettingsSaveStatus; + errorKind: SettingsSaveErrorKind | null; + dirtyContributorIds: string; + invalidReason: string | undefined; + pendingNavigation: NavigationIntent | null; + isDiscarding: boolean; + onSave: () => Promise; + onReset: () => Promise; + onDiscardAndLeave: () => Promise; + onContinueEditing: () => void; + children: ReactNode; +}; + +/** + * Renders the provider's context stack (registry + coordinator) around the + * page content and the floating save bar/dialog. Extracted to keep + * SettingsSaveProvider under the line limit. + */ +function SettingsSaveProviderBody({ + registry, + coordinator, + placement, + displayStatus, + errorKind, + dirtyContributorIds, + invalidReason, + pendingNavigation, + isDiscarding, + onSave, + onReset, + onDiscardAndLeave, + onContinueEditing, + children, +}: SettingsSaveProviderBodyProps) { + const hasDirty = coordinator.hasDirty; + return ( + + + {children} + {(hasDirty || displayStatus === "saved") && ( + + )} + + + ); +} + +/** + * Imperative handle on the shared settings save coordinator: save every dirty + * contributor (across pages that register multiple contributors, e.g. the + * profile editor and its MCP card) and learn whether the page can be left. + * Requires SettingsSaveProvider. + */ +export function useSettingsSaveCoordinator(): SettingsSaveCoordinator { + const coordinator = useContext(SettingsSaveCoordinatorContext); + if (!coordinator) throw new Error("useSettingsSaveCoordinator requires SettingsSaveProvider"); + return coordinator; +} + +/** + * Owns the save/discard/continue actions and the dirty-navigation blocker: + * registers the blocker while anything is dirty, saves and settles a pending + * navigation intent, or discards the dirty contributors and leaves. + */ +function useSaveNavigationFlow({ + saveAll, + contributors, + markError, + refreshRegistry, + hasDirty, +}: { + saveAll: () => Promise; + contributors: Map; + markError: (kind: SettingsSaveErrorKind) => void; + refreshRegistry: () => void; + hasDirty: boolean; +}) { + const pendingNavigationRef = useRef(null); + const discardingRef = useRef(false); + const [pendingNavigation, setPendingNavigation] = useState(null); + const [isDiscarding, setIsDiscarding] = useState(false); + + useEffect(() => { + if (!hasDirty) return; + return setNavigationBlocker((intent) => { + pendingNavigationRef.current?.cancel(); + pendingNavigationRef.current = intent; + setPendingNavigation(intent); + }); + }, [hasDirty]); + const handleSave = useCallback(async (): Promise => { const result = await saveAll(); if (!result.canLeave) return false; @@ -136,37 +296,14 @@ export function SettingsSaveProvider({ intent?.cancel(); }, []); - useEffect(() => { - if (!hasDirty) return; - return setNavigationBlocker((intent) => { - pendingNavigationRef.current?.cancel(); - pendingNavigationRef.current = intent; - setPendingNavigation(intent); - }); - }, [hasDirty]); - - useSettingsBeforeUnloadGuard(hasDirty); - - return ( - - {children} - {(hasDirty || status === "saved") && ( - contributor.id).join(",")} - invalidReason={invalidReason} - navigationIntent={pendingNavigation} - isDiscarding={isDiscarding} - onSave={handleSave} - onReset={discardDirtyContributors} - onDiscardAndLeave={discardAndLeave} - onContinueEditing={continueEditing} - /> - )} - - ); + return { + pendingNavigation, + isDiscarding, + handleSave, + discardDirtyContributors, + discardAndLeave, + continueEditing, + }; } function useSettingsBeforeUnloadGuard(enabled: boolean) { @@ -299,11 +436,25 @@ function useSaveCoordinator( } savingRef.current = false; + // Revalidate the whole registry before reporting canLeave: a contributor + // that became dirty while the saves were in flight (e.g. the MCP card + // edited during the profile save) is absent from the submitted snapshot + // and would otherwise be skipped while the caller proceeds on stale data. + // Compare by id: the registry replaces the contributor object on every + // upsert, so an identity check would report submitted contributors as + // newly dirty after any re-render and block save-and-leave. + const submittedIds = new Set(submitted.map(({ contributor }) => contributor.id)); + const newlyDirty = getDirtyContributors(contributors).filter( + ({ contributor }) => !submittedIds.has(contributor.id), + ); const completionStatus = saveCompletionStatus(failedIds, hasNewerChanges); setErrorKind(completionStatus === "error" ? "save" : null); setStatus(completionStatus); refreshRegistry(); - return { canLeave: failedIds.size === 0 && !hasNewerChanges, failedIds }; + return { + canLeave: failedIds.size === 0 && !hasNewerChanges && newlyDirty.length === 0, + failedIds, + }; }, [contributors, refreshRegistry]); return { status, errorKind, saveAll, clearSavedStatus, markError }; diff --git a/apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts b/apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts new file mode 100644 index 0000000000..6dda3153fa --- /dev/null +++ b/apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts @@ -0,0 +1,131 @@ +import { test, expect } from "../../fixtures/test-base"; + +/** + * Verifies the agent profile duplicate flow: + * + * - The /settings/agents profile list shows a Duplicate button per row. + * - Clicking it creates a " Copy" profile that appears in the list + * without a page reload, copying the source's model. + * - The copy is an independent profile with its own settings page. + * + * Uses the seeded default profile (like agent-profile-disable.spec.ts) + * rather than creating one: the profile list is hydrated on the server, so a + * freshly POSTed profile race-conditions with SSR. + */ +test.describe("Agent profile duplicate", () => { + test("duplicates the seeded profile from the settings list", async ({ testPage, apiClient }) => { + test.setTimeout(90_000); + + const { agents } = await apiClient.listAgents(); + const agent = agents[0]; + const profile = agent.profiles[0]; + const copyName = `${profile.name} Copy`; + + try { + await testPage.goto("/settings/agents"); + + // The per-row Duplicate action lives in the row's actions dropdown. + const row = testPage.getByTestId("agent-profile-row").filter({ hasText: profile.name }); + await expect(row).toBeVisible({ timeout: 15_000 }); + await row.getByRole("button", { name: "Profile actions" }).click(); + const duplicate = testPage.getByTestId(`duplicate-profile-${profile.id}`); + await expect(duplicate).toBeVisible({ timeout: 15_000 }); + await duplicate.click(); + + // Backend state: the copy is a new row with the source's model. The + // duplicate POST is synchronous, so listAgents reflects it immediately. + let copy: { id: string; model: string } | undefined; + await expect + .poll( + async () => { + const { agents: after } = await apiClient.listAgents(); + const afterAgent = after.find((a) => a.id === agent.id); + copy = afterAgent?.profiles.find((p) => p.name === copyName); + return copy?.id; + }, + { timeout: 15_000 }, + ) + .toBeTruthy(); + expect(copy?.id).not.toBe(profile.id); + expect(copy?.model).toBe(profile.model); + + // The copy row appears in the list without a reload. Its row link is + // the unambiguous handle (the sidebar shows a sibling link with a + // different accessible name). + await expect(testPage.getByRole("link", { name: copyName, exact: true })).toBeVisible({ + timeout: 15_000, + }); + + // The copy has its own settings page showing the copied name. + await testPage.goto(`/settings/agents/${agent.name}/profiles/${copy?.id}`); + await expect( + testPage.getByRole("heading", { + name: new RegExp(copyName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")), + }), + ).toBeVisible({ timeout: 15_000 }); + } finally { + const { agents: cleanupAgents } = await apiClient.listAgents().catch(() => ({ + agents: [] as typeof agents, + })); + const cleanupAgent = cleanupAgents.find((a) => a.id === agent.id); + const copy = cleanupAgent?.profiles.find((p) => p.name === copyName); + if (copy) { + await apiClient.deleteAgentProfile(copy.id, true).catch(() => {}); + } + } + }); + + test("duplicates from the profile page header and navigates to the copy", async ({ + testPage, + apiClient, + }) => { + test.setTimeout(90_000); + + const { agents } = await apiClient.listAgents(); + const agent = agents[0]; + const profile = agent.profiles[0]; + const copyName = `${profile.name} Copy`; + + try { + await testPage.goto(`/settings/agents/${agent.name}/profiles/${profile.id}`); + const headerDuplicate = testPage.getByTestId("duplicate-profile-header"); + await expect(headerDuplicate).toBeVisible({ timeout: 15_000 }); + await headerDuplicate.click(); + + // The copy exists server-side and the SPA navigates to its page (no + // full reload: the URL changes to the copy's profile route). + let copy: { id: string } | undefined; + await expect + .poll( + async () => { + const { agents: after } = await apiClient.listAgents(); + const afterAgent = after.find((a) => a.id === agent.id); + copy = afterAgent?.profiles.find((p) => p.name === copyName); + return copy?.id; + }, + { timeout: 15_000 }, + ) + .toBeTruthy(); + expect(copy?.id).not.toBe(profile.id); + await expect(testPage).toHaveURL(new RegExp(`/profiles/${copy?.id}$`), { + timeout: 15_000, + }); + + // The copy page renders the copy's name in its header. + await expect( + testPage.getByRole("heading", { + name: new RegExp(copyName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")), + }), + ).toBeVisible({ timeout: 15_000 }); + } finally { + const { agents: cleanupAgents } = await apiClient.listAgents().catch(() => ({ + agents: [] as typeof agents, + })); + const cleanupAgent = cleanupAgents.find((a) => a.id === agent.id); + const copy = cleanupAgent?.profiles.find((p) => p.name === copyName); + if (copy) { + await apiClient.deleteAgentProfile(copy.id, true).catch(() => {}); + } + } + }); +}); diff --git a/apps/web/e2e/tests/settings/mobile-agent-profile-duplicate.spec.ts b/apps/web/e2e/tests/settings/mobile-agent-profile-duplicate.spec.ts new file mode 100644 index 0000000000..4ff1083573 --- /dev/null +++ b/apps/web/e2e/tests/settings/mobile-agent-profile-duplicate.spec.ts @@ -0,0 +1,79 @@ +import { test, expect } from "../../fixtures/test-base"; + +/** + * Mobile parity for the agent profile duplicate flow: the row-level + * Duplicate control must be reachable by touch on a phone viewport (the + * 44px hitbox), complete the same copy, and keep the document free of + * horizontal overflow. Uses the seeded default profile like the desktop + * spec: the /settings/agents list is server-hydrated, so a freshly POSTed + * profile would race with SSR. + */ +test.describe("Mobile agent profile duplicate", () => { + test("duplicates the seeded profile from the settings list", async ({ testPage, apiClient }) => { + test.setTimeout(90_000); + + const { agents } = await apiClient.listAgents(); + const agent = agents[0]; + const profile = agent.profiles[0]; + const copyName = `${profile.name} Copy`; + + try { + await testPage.goto("/settings/agents"); + + // No document-level horizontal overflow on the list page. + await expect + .poll( + async () => + testPage.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth), + { timeout: 15_000 }, + ) + .toBe(true); + + const row = testPage.getByTestId("agent-profile-row").filter({ hasText: profile.name }); + await expect(row).toBeVisible({ timeout: 15_000 }); + // The row's actions trigger exposes a touch-sized hitbox (>= 44px). + // Poll for the box: layout can settle a frame after visibility. + const trigger = row.getByRole("button", { name: "Profile actions" }); + await expect + .poll( + async () => { + const box = await trigger.boundingBox(); + if (!box) return null; + return Math.min(box.width, box.height); + }, + { timeout: 10_000 }, + ) + .toBeGreaterThanOrEqual(44); + await trigger.tap(); + const duplicate = testPage.getByTestId(`duplicate-profile-${profile.id}`); + await expect(duplicate).toBeVisible({ timeout: 15_000 }); + await duplicate.tap(); + + // The copy appears as its own row without a reload. + await expect + .poll( + async () => { + const { agents: after } = await apiClient.listAgents(); + const afterAgent = after.find((a) => a.id === agent.id); + const copy = afterAgent?.profiles.find((p) => p.name === copyName); + return copy?.id; + }, + { timeout: 15_000 }, + ) + .toBeTruthy(); + + await expect(testPage.getByRole("link", { name: copyName, exact: true })).toBeVisible({ + timeout: 15_000, + }); + } finally { + const { agents: cleanupAgents } = await apiClient.listAgents().catch(() => ({ + agents: [] as typeof agents, + })); + const cleanupAgent = cleanupAgents.find((a) => a.id === agent.id); + const copy = cleanupAgent?.profiles.find((p) => p.name === copyName); + if (copy) { + await apiClient.deleteAgentProfile(copy.id, true).catch(() => {}); + } + } + }); +}); diff --git a/apps/web/hooks/domains/settings/use-profile-duplicate.test.ts b/apps/web/hooks/domains/settings/use-profile-duplicate.test.ts new file mode 100644 index 0000000000..22032045c2 --- /dev/null +++ b/apps/web/hooks/domains/settings/use-profile-duplicate.test.ts @@ -0,0 +1,189 @@ +import { describe, expect, it, vi } from "vitest"; +import type { Agent, AgentProfile } from "@/lib/types/http"; +import type { AgentProfileOption } from "@/lib/state/slices/settings/types"; +import { applyProfileDuplicated } from "./use-profile-duplicate"; + +vi.mock("@/app/actions/agents", () => ({ duplicateAgentProfileAction: vi.fn() })); +vi.mock("@/components/state-provider", () => ({ useAppStoreApi: vi.fn() })); +vi.mock("@/components/toast-provider", () => ({ useToast: vi.fn() })); + +const COPY_NAME = "Default Copy"; +const OLD_REVISION = "2026-08-11T21:00:00Z"; +const NEW_REVISION = "2026-08-11T22:00:00Z"; + +/** Builds an AgentProfile fixture with an optional updatedAt. */ +function profile(id: string, agentId: string, name = id, updatedAt = ""): AgentProfile { + return { + id, + agentId, + name, + agentDisplayName: "Test Agent", + model: "", + allowIndexing: false, + autoApprove: false, + cliFlags: [], + cliPassthrough: false, + enabled: true, + createdAt: "", + updatedAt, + } as unknown as AgentProfile; +} + +/** Builds an Agent fixture carrying the given profiles. */ +function agent(id: string, ...profiles: AgentProfile[]): Agent { + return { id, name: id, profiles } as unknown as Agent; +} + +/** Builds an AgentProfileOption fixture with an optional updatedAt. */ +function option(id: string, updatedAt = ""): AgentProfileOption { + return { + id, + label: id, + agent_id: "a1", + agent_name: "a1", + cli_passthrough: false, + updatedAt, + }; +} + +/** Builds the settings slice state the duplicate merge operates on. */ +function stateWith(agents: Agent[], options: AgentProfileOption[]) { + return { + settingsAgents: { items: agents, version: 0 }, + agentProfiles: { items: options, version: 0 }, + }; +} + +describe("applyProfileDuplicated", () => { + it("appends the copy to the owning agent and surfaces it as an option", () => { + const source = profile("p1", "a1", "Default"); + const copy = profile("p2", "a1", COPY_NAME); + const initial = stateWith([agent("a1", source)], []); + + const next = applyProfileDuplicated(initial, agent("a1"), copy); + + const profiles = next.settingsAgents.items.find((a) => a.id === "a1")?.profiles ?? []; + expect(profiles.map((p) => p.id)).toEqual(["p1", "p2"]); + // Every profile (source + copy) is rebuilt into the options slice. + expect(next.agentProfiles.items.map((o) => o.id)).toEqual(["p1", "p2"]); + }); + + it("dedupes by id so a WS-delivered copy is not double-inserted", () => { + const source = profile("p1", "a1"); + const copy = profile("p2", "a1", COPY_NAME); + // The WS agent.profile.created handler delivered the copy first. + const initial = stateWith([agent("a1", source)], [option("p2")]); + + const next = applyProfileDuplicated(initial, agent("a1"), copy); + + const profiles = next.settingsAgents.items.find((a) => a.id === "a1")?.profiles ?? []; + expect(profiles.filter((p) => p.id === "p2")).toHaveLength(1); + expect(next.agentProfiles.items.filter((o) => o.id === "p2")).toHaveLength(1); + }); + + it("keeps the copy visible when the owning agent left the store mid-request", () => { + const copy = profile("p2", "a1", COPY_NAME); + const initial = stateWith([], []); + + const next = applyProfileDuplicated(initial, agent("a1"), copy); + + // settingsAgents is unchanged (no agent to attach to), but the copy must + // still surface in the agentProfiles slice instead of being dropped. + expect(next.settingsAgents.items).toEqual([]); + expect(next.agentProfiles.items.map((o) => o.id)).toEqual(["p2"]); + }); + + it("does not erase a WS-delivered copy and refreshes it with agent metadata", () => { + const copy = profile("p2", "a1", COPY_NAME); + // WS delivered the option first (with a stub agent_name) while the + // owning agent is absent; the merge must replace it with the full-agent + // option rather than keep the empty-name stub. + const initial = stateWith([], [option("p2")]); + + const next = applyProfileDuplicated(initial, agent("a1"), copy); + + const options = next.agentProfiles.items.filter((o) => o.id === "p2"); + expect(options).toHaveLength(1); + expect(options[0].agent_name).toBe("a1"); + }); + + it("keeps a newer WS-delivered orphan option over a stale duplicate response", () => { + // Owner absent; WS delivered a NEWER version of the copy than this + // delayed HTTP response. The merge must not regress it to the stale one. + const staleCreated = profile("p2", "a1", COPY_NAME, OLD_REVISION); + const newerOrphan = option("p2", NEW_REVISION); + const initial = stateWith([], [newerOrphan]); + + const next = applyProfileDuplicated(initial, agent("a1"), staleCreated); + + const options = next.agentProfiles.items.filter((o) => o.id === "p2"); + expect(options).toHaveLength(1); + // The preserved option keeps the newer revision (label from the option). + expect(options[0].label).toBe("p2"); + expect(options[0].updatedAt).toBe(NEW_REVISION); + }); + + it("keeps a newer WS-delivered option over a stale rebuilt one when the owner is present", () => { + // The option was updated by WS (enabled=false, newer revision) while the + // settingsAgents profile is stale. The merge must not regress it to the + // rebuilt (older) version — a disabled profile must stay hidden. + const staleProfile = profile("p1", "a1", "Default", OLD_REVISION); + const copy = profile("p2", "a1", COPY_NAME, OLD_REVISION); + const newerCopyOption = { ...option("p2", NEW_REVISION), enabled: false }; + const initial = stateWith([agent("a1", staleProfile)], [newerCopyOption]); + + const next = applyProfileDuplicated(initial, agent("a1"), copy); + + const options = next.agentProfiles.items.filter((o) => o.id === "p2"); + expect(options).toHaveLength(1); + expect(options[0].enabled).toBe(false); + expect(options[0].updatedAt).toBe(NEW_REVISION); + }); + + it("orders revisions by instant, not lexically, for offset timestamps", () => { + // "2026-08-11T23:30:00+02:00" is 21:30 UTC — OLDER than 22:00Z, but + // lexically larger. A string compare would keep the stale duplicate + // response over the newer WS-delivered option. + const staleCreated = profile("p2", "a1", COPY_NAME, "2026-08-11T23:30:00+02:00"); + const newerOrphan = option("p2", "2026-08-11T22:00:00Z"); + const initial = stateWith([], [newerOrphan]); + + const next = applyProfileDuplicated(initial, agent("a1"), staleCreated); + + const options = next.agentProfiles.items.filter((o) => o.id === "p2"); + expect(options).toHaveLength(1); + expect(options[0].updatedAt).toBe("2026-08-11T22:00:00Z"); + }); + + it("keeps a newer WS-delivered version instead of the stale duplicate response", () => { + // Another tab edited the copy after creation: agent.profile.updated + // delivered the newer version before this delayed duplicate response. + const newer = profile("p2", "a1", "Default Copy (edited)", NEW_REVISION); + const staleCreated = profile("p2", "a1", COPY_NAME, OLD_REVISION); + const source = profile("p1", "a1"); + const initial = stateWith([agent("a1", source, newer)], [option("p1"), option("p2")]); + + const next = applyProfileDuplicated(initial, agent("a1"), staleCreated); + + const stored = next.settingsAgents.items.find((a) => a.id === "a1")?.profiles ?? []; + expect(stored.find((p) => p.id === "p2")?.name).toBe("Default Copy (edited)"); + expect(next.agentProfiles.items.find((o) => o.id === "p2")?.label).toContain( + "Default Copy (edited)", + ); + }); + + it("preserves WS-delivered orphan options for agents absent from the store", () => { + // p-orphan was delivered by WS for an agent not present in settingsAgents; + // duplicating a profile of a DIFFERENT agent must not wipe it. + const source = profile("p1", "a2"); + const copy = profile("p2", "a2", COPY_NAME); + const initial = stateWith([agent("a2", source)], [option("p-orphan")]); + + const next = applyProfileDuplicated(initial, agent("a2"), copy); + + const ids = next.agentProfiles.items.map((o) => o.id); + expect(ids).toContain("p-orphan"); + expect(ids).toContain("p2"); + expect(ids.filter((id) => id === "p2")).toHaveLength(1); + }); +}); diff --git a/apps/web/hooks/domains/settings/use-profile-duplicate.ts b/apps/web/hooks/domains/settings/use-profile-duplicate.ts new file mode 100644 index 0000000000..7187cce319 --- /dev/null +++ b/apps/web/hooks/domains/settings/use-profile-duplicate.ts @@ -0,0 +1,116 @@ +"use client"; + +import { useCallback, useRef } from "react"; +import { duplicateAgentProfileAction } from "@/app/actions/agents"; +import { useAppStoreApi } from "@/components/state-provider"; +import { useToast } from "@/components/toast-provider"; +import { t as translate } from "@/lib/i18n"; +import { + compareTimestamps, + mergeOptionsByNewest, + toAgentProfileOption, + type AgentProfileOption, +} from "@/lib/state/slices/settings/types"; +import type { AppState } from "@/lib/state/store"; +import type { Agent, AgentProfile } from "@/lib/types/http"; + +type ProfileState = Pick; + +/** + * Merge one duplicated profile into the latest store state. Dedupes by ID so + * a concurrent `agent.profile.created` WS delivery cannot double-insert the + * copy into either slice. + * + * The options slice is rebuilt from `settingsAgents` by ID on top of the + * existing options: options the rebuild does not represent (e.g. profiles the + * WS handler delivered for agents temporarily absent from `settingsAgents`) + * are preserved, and the new copy always appears exactly once — via the + * rebuild when its owning agent is present, otherwise via a stub so it is + * never dropped. + * + * A stale duplicate HTTP response never clobbers a newer profile: when the + * copy already exists in the store (e.g. another tab edited it and + * `agent.profile.updated` arrived first), the newer `updatedAt` wins. + */ +export function applyProfileDuplicated( + state: ProfileState, + agent: Agent, + created: AgentProfile, +): ProfileState { + const nextAgents = state.settingsAgents.items.map((item: Agent) => + item.id === agent.id + ? (() => { + const existing = item.profiles.find((p) => p.id === created.id); + const latest = + existing && compareTimestamps(existing.updatedAt, created.updatedAt) > 0 + ? existing + : created; + return { + ...item, + profiles: [...item.profiles.filter((p) => p.id !== created.id), latest], + }; + })() + : item, + ); + + const rebuiltOptions = nextAgents.flatMap((item) => + item.profiles.map((profile) => toAgentProfileOption(item, profile)), + ); + const merged = mergeOptionsByNewest(state.agentProfiles.items, rebuiltOptions); + // The copy must appear exactly once with the known agent metadata: append + // it when absent, replace an OLDER existing option (e.g. a WS stub) with + // it, and keep a NEWER WS-delivered option untouched. + const copyOption = toAgentProfileOption({ id: agent.id, name: agent.name }, created); + const existingCopy = merged.find((option) => option.id === created.id); + let agentProfilesItems: AgentProfileOption[]; + if (!existingCopy) { + agentProfilesItems = [...merged, copyOption]; + } else if (compareTimestamps(existingCopy.updatedAt, created.updatedAt) > 0) { + agentProfilesItems = merged; // keep the newer WS-delivered option + } else { + agentProfilesItems = merged.map((option) => (option.id === created.id ? copyOption : option)); + } + + return { + settingsAgents: { ...state.settingsAgents, items: nextAgents }, + agentProfiles: { ...state.agentProfiles, items: agentProfilesItems }, + }; +} + +/** + * Duplicate a profile from the /settings/agents profile list. The returned + * copy is merged into the store atomically so the new row appears without + * waiting on the WebSocket round-trip. + */ +export function useProfileDuplicate() { + const { toast } = useToast(); + const storeApi = useAppStoreApi(); + // Per-profile in-flight guard: the row button stays clickable while the + // request runs, so a double-click must not issue two copies. + const pendingRef = useRef(new Set()); + + return useCallback( + async (agent: Agent, profile: AgentProfile) => { + if (pendingRef.current.has(profile.id)) return; + pendingRef.current.add(profile.id); + try { + const created = await duplicateAgentProfileAction(profile.id); + storeApi.setState((state) => applyProfileDuplicated(state, agent, created)); + toast({ + title: translate("agents:duplicateProfileSuccess"), + description: created.name, + variant: "success", + }); + } catch (error) { + toast({ + title: translate("agents:failedToDuplicateProfile"), + description: error instanceof Error ? error.message : translate("agents:requestFailed"), + variant: "error", + }); + } finally { + pendingRef.current.delete(profile.id); + } + }, + [storeApi, toast], + ); +} diff --git a/apps/web/lib/routing/client-router.test.ts b/apps/web/lib/routing/client-router.test.ts index 46ba6670de..afce375693 100644 --- a/apps/web/lib/routing/client-router.test.ts +++ b/apps/web/lib/routing/client-router.test.ts @@ -3,10 +3,17 @@ import { afterEach, describe, expect, it, vi } from "vitest"; import { clearNavigationBlockerForTests, setNavigationBlocker } from "./navigation-guard"; import { useParams, usePathname, useRouter, useSearchParams } from "./client-router"; +const NAV_POSITION_KEY = "__kandevNavigationPosition"; + function setLocation(path: string) { window.history.replaceState({}, "", path); } +/** Simulates a history popstate at the given location for router tests. */ +function popStateAt(position: number) { + window.dispatchEvent(new PopStateEvent("popstate", { state: { [NAV_POSITION_KEY]: position } })); +} + afterEach(() => { clearNavigationBlockerForTests(); vi.unstubAllGlobals(); @@ -61,33 +68,82 @@ describe("client router adapter", () => { expect(reload).toHaveBeenCalledOnce(); }); - it("guards imperative push and history navigation", () => { - setLocation("/settings/general/appearance"); - const attempts: Array<() => void> = []; - setNavigationBlocker((intent) => attempts.push(intent.proceed)); - const go = vi.spyOn(window.history, "go").mockImplementation(() => undefined); - const back = vi.spyOn(window.history, "back").mockImplementation(() => { - window.dispatchEvent( - new PopStateEvent("popstate", { - state: { __kandevNavigationPosition: 0 }, - }), - ); + describe("navigation guard", () => { + function setupGuardedRouter() { + setLocation("/settings/general/appearance"); + const intents: Array<{ proceed: () => void; cancel: () => void }> = []; + setNavigationBlocker((intent) => intents.push(intent)); + const go = vi.spyOn(window.history, "go").mockImplementation(() => undefined); + const back = vi.spyOn(window.history, "back").mockImplementation(() => popStateAt(0)); + const { result } = renderHook(() => useRouter()); + return { result, intents, go, back }; + } + + it("guards imperative push and history navigation", () => { + const { result, intents, go, back } = setupGuardedRouter(); + + act(() => result.current.push("/tasks")); + expect(window.location.pathname).toBe("/settings/general/appearance"); + act(() => intents.shift()?.proceed()); + expect(window.location.pathname).toBe("/tasks"); + + act(() => result.current.back()); + expect(back).toHaveBeenCalledOnce(); + expect(intents).toHaveLength(1); + act(() => intents.shift()?.proceed()); + window.dispatchEvent(new PopStateEvent("popstate", { state: window.history.state })); + window.dispatchEvent(new PopStateEvent("popstate", { state: null })); + expect(intents).toHaveLength(0); + expect(go).toHaveBeenCalledTimes(2); }); - const { result } = renderHook(() => useRouter()); - act(() => result.current.push("/tasks")); - expect(window.location.pathname).toBe("/settings/general/appearance"); + it("consumes a cancelled blocked pop's restoration popstate when no newer navigation superseded it", () => { + const { result, intents, go } = setupGuardedRouter(); - act(() => attempts.shift()?.()); - expect(window.location.pathname).toBe("/tasks"); + act(() => result.current.push("/tasks")); + act(() => intents.pop()?.proceed()); // allow the push -> currentPosition 1 + act(() => result.current.back()); // blocked pop to position 0; restoration to 1 pending + expect(intents).toHaveLength(1); - act(() => result.current.back()); - expect(back).toHaveBeenCalledOnce(); - expect(attempts).toHaveLength(1); - act(() => attempts.shift()?.()); - window.dispatchEvent(new PopStateEvent("popstate", { state: window.history.state })); - window.dispatchEvent(new PopStateEvent("popstate", { state: null })); - expect(attempts).toHaveLength(0); - expect(go).toHaveBeenCalledTimes(2); + act(() => { + intents[0].cancel(); // cancel without any newer navigation + }); + + // The in-flight restoration popstate for the blocked entry is consumed + // without touching currentPosition (still 1). + act(() => popStateAt(1)); + + // A later real back to position 0 is a fresh guarded pop (delta -1), + // not a silent acceptance. + act(() => popStateAt(0)); + expect(intents).toHaveLength(2); + expect(go).toHaveBeenCalled(); + }); + + it("forgets a cancelled blocked pop once a newer navigation supersedes it", () => { + const { result, intents, go } = setupGuardedRouter(); + + act(() => result.current.push("/tasks")); + act(() => intents.pop()?.proceed()); // allow the push -> currentPosition 1 + act(() => result.current.back()); // blocked pop to position 0 + expect(intents).toHaveLength(1); + + // Duplicate-like flow: cancel, then push a new route. The push + // supersedes the pending traversal, so the browser may never emit its + // popstate; the guard must forget the cancelled restoration instead of + // arming a stale position that could eat a later navigation. + act(() => { + intents[0].cancel(); + result.current.push("/settings/agents/mock-agent/profiles/copy-1"); + intents.pop()?.proceed(); // allow the duplicate push -> currentPosition 2 + }); + + // A popstate to the blocked entry's position arrives late (or is a + // real back): it must be treated as a fresh guarded pop (delta -1 from + // position 2), not consumed as stale. + act(() => popStateAt(1)); + expect(intents).toHaveLength(2); + expect(go).toHaveBeenCalled(); + }); }); }); diff --git a/apps/web/lib/routing/navigation-guard.ts b/apps/web/lib/routing/navigation-guard.ts index 3ed29f68e4..fe0916e469 100644 --- a/apps/web/lib/routing/navigation-guard.ts +++ b/apps/web/lib/routing/navigation-guard.ts @@ -13,6 +13,11 @@ let popstateInstalled = false; let historyMutationsTracked = false; let allowedPop = false; let restoringPop = false; +// Position of a blocked-pop restoration whose traversal is still in flight +// when the intent was cancelled. The delayed popstate for that position must +// be consumed without touching currentPosition, so a newer navigation (e.g. a +// push performed right after cancel) is not clobbered. +let canceledRestorationPosition: number | null = null; type BlockedPop = { delta: number; @@ -96,6 +101,7 @@ export function clearNavigationBlockerForTests(): void { allowedPop = false; restoringPop = false; blockedPop = null; + canceledRestorationPosition = null; } function ensureHistoryTracking(): void { @@ -132,6 +138,14 @@ function handlePopState(event: PopStateEvent): void { return; } + if (targetPosition === canceledRestorationPosition) { + // Popstate for a blocked-pop restoration whose intent was cancelled: a + // newer navigation may have happened since, so consume it without + // updating currentPosition. + canceledRestorationPosition = null; + return; + } + if (allowedPop) { allowedPop = false; currentPosition = targetPosition; @@ -172,6 +186,7 @@ function blockPop(event: PopStateEvent, delta: number, restorePosition: number): }; blockedPop = pending; restoringPop = true; + canceledRestorationPosition = null; // a new block supersedes any stale one window.history.go(-delta); blocker({ @@ -189,11 +204,16 @@ function trackNativeHistoryMutations(): void { const position = readPosition(state) ?? (currentPosition ?? 0) + 1; pushState(withPosition(state, position), title, url); currentPosition = position; + // A new navigation supersedes any blocked-pop traversal still in flight; + // without this the cancelled restoration position could eat a later + // legitimate popstate to the same position. + canceledRestorationPosition = null; }; window.history.replaceState = (state, title, url) => { const position = readPosition(state) ?? currentPosition ?? 0; replaceState(withPosition(state, position), title, url); currentPosition = position; + canceledRestorationPosition = null; }; } @@ -211,7 +231,14 @@ function proceedBlockedPop(pending: BlockedPop): void { function cancelBlockedPop(pending: BlockedPop): void { if (blockedPop !== pending) return; pending.canceled = true; - if (pending.restored) blockedPop = null; + if (!pending.restored) { + // The history.go(-delta) restoration is still in flight. Its popstate + // must not overwrite a newer currentPosition (e.g. a push performed + // right after cancel), so consume that exact position when it arrives. + canceledRestorationPosition = pending.restorePosition; + restoringPop = false; + } + blockedPop = null; } function finishPopRestoration(): void { diff --git a/apps/web/lib/state/slices/settings/types.ts b/apps/web/lib/state/slices/settings/types.ts index 344ca2cedd..ed85662942 100644 --- a/apps/web/lib/state/slices/settings/types.ts +++ b/apps/web/lib/state/slices/settings/types.ts @@ -60,6 +60,9 @@ export type AgentProfileOption = { /** Legacy automatic-fallback opt-in. */ auto_fallback?: boolean; workspace_id?: string; + /** Persisted profile revision (RFC3339 updated_at), used to prefer newer + * WS-delivered options over a stale in-flight response. */ + updatedAt?: string; /** * False hides the profile from task/session creation pickers. Existing * sessions keep their labels and the profile stays editable in settings. @@ -79,10 +82,53 @@ export function isSelectableAgentProfile(profile: Pick(); + for (const option of previous) { + byId.set(option.id, option); + } + for (const option of rebuilt) { + const existing = byId.get(option.id); + if (!existing || compareTimestamps(option.updatedAt, existing.updatedAt) >= 0) { + byId.set(option.id, option); + } + } + return [...byId.values()]; +} + /** Single source of truth for mapping an API Agent+Profile to a store AgentProfileOption. */ export function toAgentProfileOption( agent: Pick, profile: Pick & { + updatedAt?: string; cliPassthrough?: boolean; model?: string; fallbackModel?: string; @@ -100,6 +146,7 @@ export function toAgentProfileOption( fallback_model: profile.fallbackModel ?? undefined, auto_fallback: profile.autoFallback ?? undefined, workspace_id: profile.workspaceId, + updatedAt: profile.updatedAt, enabled: profile.enabled ?? true, capability_status: agent.capability_status, capability_error: agent.capability_error, diff --git a/apps/web/lib/ws/handlers/agents.test.ts b/apps/web/lib/ws/handlers/agents.test.ts index 6b41d20aca..8ea7413010 100644 --- a/apps/web/lib/ws/handlers/agents.test.ts +++ b/apps/web/lib/ws/handlers/agents.test.ts @@ -13,23 +13,62 @@ function makeStore() { ) as unknown as StoreApi; } -function message(action: string, payload: unknown) { +const TIMESTAMP = "2026-07-26T10:00:00Z"; +const NOTIFICATION_TYPE = "notification"; +const PROFILE_CREATED = "agent.profile.created"; +const PROFILE_UPDATED = "agent.profile.updated"; +const PROFILE_DELETED = "agent.profile.deleted"; + +/** Builds a WS notification message fixture with the given action, payload, and timestamp. */ +function message(action: string, payload: unknown, timestamp = TIMESTAMP) { return { id: `message-${action}`, - type: "notification", + type: NOTIFICATION_TYPE, action, - timestamp: "2026-07-26T10:00:00Z", + timestamp, payload, }; } -describe("agent runtime update websocket handlers", () => { +/** Builds a kanban profile payload fixture, overridable per test. */ +function profilePayload(overrides: Record = {}) { + return { + id: "p1", + agent_id: "agent-1", + name: "Default", + model: "mock-fast", + enabled: true, + created_at: TIMESTAMP, + updated_at: TIMESTAMP, + ...overrides, + }; +} + +/** Builds an office-scoped profile payload fixture (workspace_id set). */ +function officeProfilePayload() { + return { + id: "profile-office", + agent_id: "agent-1", + name: "Office Agent", + workspace_id: "ws-1", + enabled: true, + created_at: TIMESTAMP, + updated_at: TIMESTAMP, + }; +} + +/** Registers the agents WS handlers and returns them keyed by action. */ +function handlersFor(store: ReturnType) { + return registerAgentsHandlers(store) as unknown as Record< + string, + (event: ReturnType) => void + >; +} + +describe("agent update job websocket handlers", () => { it("upserts update snapshots and appends each output chunk once", () => { const store = makeStore(); - const handlers = registerAgentsHandlers(store) as unknown as Record< - string, - (event: ReturnType) => void - >; + const handlers = handlersFor(store); const snapshot = { job_id: "update-1", agent_name: "claude-acp", @@ -64,3 +103,161 @@ describe("agent runtime update websocket handlers", () => { ).toMatchObject({ status: "succeeded", output: "downloaded\n" }); }); }); + +describe("agent profile events", () => { + it("ignores office-scoped profile events so they never leak into global settings", () => { + const store = makeStore(); + const handlers = handlersFor(store); + // The backend wraps the profile under { profile: ... } in the event. + const payload = { profile: officeProfilePayload() }; + + handlers[PROFILE_CREATED](message(PROFILE_CREATED, payload)); + handlers[PROFILE_UPDATED](message(PROFILE_UPDATED, payload)); + + const state = store.getState(); + expect(state.agentProfiles.items).toHaveLength(0); + expect(state.settingsAgents.items).toHaveLength(0); + }); + + it("does not let a delayed profile event overwrite newer stored state", () => { + const store = makeStore(); + const handlers = handlersFor(store); + const newer = profilePayload({ model: "new-model", updated_at: "2026-07-26T11:00:00Z" }); + handlers[PROFILE_CREATED](message(PROFILE_CREATED, { profile: newer }, "2026-07-26T11:05:00Z")); + // A delayed older event (e.g. a replayed duplicate response) must not + // regress the newer revision. + const older = profilePayload({ model: "stale-model", updated_at: "2026-07-26T09:00:00Z" }); + handlers[PROFILE_UPDATED](message(PROFILE_UPDATED, { profile: older }, "2026-07-26T11:04:00Z")); + + const stored = store.getState().agentProfiles.items[0]; + expect(stored?.model).toBe("new-model"); + }); + + it("does not resurrect a deleted profile from a delayed create event", () => { + const store = makeStore(); + const handlers = handlersFor(store); + + handlers[PROFILE_CREATED]( + message(PROFILE_CREATED, { profile: profilePayload() }, "2026-07-26T10:00:00Z"), + ); + expect(store.getState().agentProfiles.items).toHaveLength(1); + + handlers[PROFILE_DELETED]( + message(PROFILE_DELETED, { profile: profilePayload() }, "2026-07-26T12:00:00Z"), + ); + expect(store.getState().agentProfiles.items).toHaveLength(0); + + // A create event produced BEFORE the deletion is stale: no resurrection. + handlers[PROFILE_CREATED]( + message(PROFILE_CREATED, { profile: profilePayload() }, "2026-07-26T11:00:00Z"), + ); + expect(store.getState().agentProfiles.items).toHaveLength(0); + + // A genuinely newer create (after the deletion) wins and clears the + // tombstone. + handlers[PROFILE_CREATED]( + message( + "agent.profile.created", + { profile: profilePayload({ updated_at: "2026-07-26T13:00:00Z" }) }, + "2026-07-26T13:00:00Z", + ), + ); + expect(store.getState().agentProfiles.items).toHaveLength(1); + }); + + it("ignores office-scoped delete events", () => { + const store = makeStore(); + const handlers = handlersFor(store); + handlers[PROFILE_DELETED](message(PROFILE_DELETED, { profile: officeProfilePayload() })); + + expect(store.getState().agentProfiles.items).toHaveLength(0); + expect(store.getState().settingsAgents.items).toHaveLength(0); + }); +}); + +describe("agent profile event ordering", () => { + it("ignores a stale delete event when a newer revision already exists", () => { + const store = makeStore(); + const handlers = handlersFor(store); + const current = profilePayload({ + id: "p-stale", + model: "new-model", + updated_at: "2026-07-26T11:00:00Z", + }); + handlers[PROFILE_CREATED]( + message(PROFILE_CREATED, { profile: current }, "2026-07-26T11:05:00Z"), + ); + expect(store.getState().agentProfiles.items).toHaveLength(1); + + // A delayed delete carrying an OLDER snapshot than the stored revision + // must not remove the current profile. + const staleDelete = profilePayload({ + id: "p-stale", + model: "new-model", + updated_at: TIMESTAMP, + }); + handlers[PROFILE_DELETED]( + message(PROFILE_DELETED, { profile: staleDelete }, "2026-07-26T11:02:00Z"), + ); + + const state = store.getState(); + expect(state.agentProfiles.items).toHaveLength(1); + expect(state.agentProfiles.items[0]?.model).toBe("new-model"); + // A genuinely newer delete (after the stored revision) still applies. + handlers[PROFILE_DELETED]( + message(PROFILE_DELETED, { profile: current }, "2026-07-26T12:00:00Z"), + ); + expect(store.getState().agentProfiles.items).toHaveLength(0); + }); + + it("orders revisions by instant, not lexically, for fractional-second timestamps", () => { + const store = makeStore(); + const handlers = handlersFor(store); + // Lexically "…10:00:00Z" sorts AFTER "…10:00:00.100Z", so a naive string + // compare would treat the whole-second revision as newer and regress it. + const fractional = profilePayload({ + id: "p-frac", + model: "fractional-model", + updated_at: "2026-07-26T10:00:00.100Z", + }); + handlers[PROFILE_CREATED]( + message(PROFILE_CREATED, { profile: fractional }, "2026-07-26T10:00:00.100Z"), + ); + + const wholeSecond = profilePayload({ + id: "p-frac", + model: "whole-second-model", + updated_at: TIMESTAMP, + }); + handlers[PROFILE_UPDATED](message(PROFILE_UPDATED, { profile: wholeSecond })); + + expect(store.getState().agentProfiles.items[0]?.model).toBe("fractional-model"); + }); + + it("keeps the tombstone ordered by instant for fractional-second deletes", () => { + const store = makeStore(); + const handlers = handlersFor(store); + handlers[PROFILE_CREATED]( + message(PROFILE_CREATED, { profile: profilePayload({ id: "p-tomb" }) }), + ); + // Delete at a fractional second; the tombstone must beat a whole-second + // create produced before it. + handlers[PROFILE_DELETED]( + message( + PROFILE_DELETED, + { profile: profilePayload({ id: "p-tomb" }) }, + "2026-07-26T10:00:00.100Z", + ), + ); + expect(store.getState().agentProfiles.items).toHaveLength(0); + + handlers[PROFILE_CREATED]( + message( + PROFILE_CREATED, + { profile: profilePayload({ id: "p-tomb" }) }, + "2026-07-26T10:00:00.050Z", + ), + ); + expect(store.getState().agentProfiles.items).toHaveLength(0); + }); +}); diff --git a/apps/web/lib/ws/handlers/agents.ts b/apps/web/lib/ws/handlers/agents.ts index ee3876ed71..20b6d7f442 100644 --- a/apps/web/lib/ws/handlers/agents.ts +++ b/apps/web/lib/ws/handlers/agents.ts @@ -1,7 +1,7 @@ import type { StoreApi } from "zustand"; import type { AppState } from "@/lib/state/store"; import type { WsHandlers } from "@/lib/ws/handlers/types"; -import { toAgentProfileOption } from "@/lib/state/slices/settings/types"; +import { compareTimestamps, toAgentProfileOption } from "@/lib/state/slices/settings/types"; import { normalizeAgentProfile } from "@/lib/api/domains/agent-profile-normalize"; import type { AgentProfile } from "@/lib/types/agent-profile"; @@ -15,8 +15,78 @@ function getAgentId(raw: unknown): string { return typeof value === "string" ? value : ""; } -function handleProfileCreated(state: AppState, profile: unknown): Partial { +/** + * Office-scoped profiles are owned by the office channels, never the kanban + * settings surface (the HTTP agent list hides them via filterGlobalProfiles). + * Defense in depth: ignore their events here so a stray broadcast cannot leak + * them into the global settings store and selectors. + */ +function isOfficeScoped(normalized: { workspaceId?: string }): boolean { + return Boolean(normalized.workspaceId); +} + +/** Finds a profile in the settings agents list by id, across all agents. */ +function findExistingProfile(state: AppState, profileId: string): AgentProfile | undefined { + for (const item of state.settingsAgents.items) { + const found = item.profiles.find((p) => p.id === profileId); + if (found) return found; + } + return undefined; +} + +// Deletion tombstones keyed by profile id -> deletion event timestamp, so a +// delayed create/update event cannot resurrect a profile that was deleted +// after the event was produced. Cleared when a genuinely newer create arrives. +// Tombstones are keyed by UUID and profiles are never recreated under the same +// ID, so the map is bounded by the number of profiles deleted in this session +// (typically single digits to low dozens — no eviction needed). +const deletionTombstones = new Map(); + +/** + * A profile event is stale when the store already holds a newer revision of + * the profile or its option (e.g. a delayed duplicate response or a newer + * WebSocket update arrived first), or when the profile was deleted after the + * event was produced (tombstone). Events must never regress newer state. + * Missing event timestamps (never produced by the backend) are treated as + * not-stale so they cannot trip the guards. + */ +function isStaleProfileEvent( + state: AppState, + normalized: { id: string; updatedAt?: string }, + eventTimestamp: string | undefined, +): boolean { + const tombstone = deletionTombstones.get(normalized.id); + if ( + tombstone !== undefined && + eventTimestamp && + compareTimestamps(tombstone, eventTimestamp) >= 0 + ) { + return true; + } + const existingProfile = findExistingProfile(state, normalized.id); + if (existingProfile && compareTimestamps(existingProfile.updatedAt, normalized.updatedAt) > 0) { + return true; + } + const existingOption = state.agentProfiles.items.find((o) => o.id === normalized.id); + return Boolean( + existingOption && compareTimestamps(existingOption.updatedAt, normalized.updatedAt) > 0, + ); +} + +/** + * Applies an agent.profile.created event, skipping office-scoped or stale + * events (see isStaleProfileEvent) and clearing the deletion tombstone when a + * genuinely newer create arrives. + */ +function handleProfileCreated( + state: AppState, + profile: unknown, + eventTimestamp: string | undefined, +): Partial { const normalized = normalizeAgentProfile(profile); + if (isOfficeScoped(normalized)) return {}; + if (isStaleProfileEvent(state, normalized, eventTimestamp)) return {}; + deletionTombstones.delete(normalized.id); // a genuinely newer create wins const agentId = getAgentId(profile); const agent = state.settingsAgents.items.find((a) => a.id === agentId); const agentStub = { id: agentId, name: agent?.name ?? "" }; @@ -41,8 +111,18 @@ function handleProfileCreated(state: AppState, profile: unknown): Partial { +/** + * Applies an agent.profile.updated event, skipping office-scoped or stale + * events so a delayed update never regresses newer stored state. + */ +function handleProfileUpdated( + state: AppState, + profile: unknown, + eventTimestamp: string | undefined, +): Partial { const normalized = normalizeAgentProfile(profile); + if (isOfficeScoped(normalized)) return {}; + if (isStaleProfileEvent(state, normalized, eventTimestamp)) return {}; const agentId = getAgentId(profile); const agent = state.settingsAgents.items.find((a) => a.id === agentId); const agentStub = { id: agentId, name: agent?.name ?? "" }; @@ -63,6 +143,41 @@ function handleProfileUpdated(state: AppState, profile: unknown): Partial { + const normalized = normalizeAgentProfile(profile); + if (isOfficeScoped(normalized)) return {}; + if (isStaleProfileEvent(state, normalized, eventTimestamp)) return {}; + if (eventTimestamp) deletionTombstones.set(normalized.id, eventTimestamp); + const agentId = getAgentId(profile); + const nextAgents = state.settingsAgents.items.map((item) => + item.id === agentId + ? { + ...item, + profiles: item.profiles.filter((p) => p.id !== normalized.id), + } + : item, + ); + return { + agentProfiles: { + ...state.agentProfiles, + items: state.agentProfiles.items.filter((p) => p.id !== normalized.id), + }, + settingsAgents: { items: nextAgents }, + }; +} + export function registerAgentsHandlers(store: StoreApi): WsHandlers { return { "agent.available.updated": (message) => { @@ -118,35 +233,19 @@ export function registerAgentsHandlers(store: StoreApi): WsHandlers { "agent.profile.created": (message) => { store.setState((state) => ({ ...state, - ...handleProfileCreated(state, message.payload.profile), + ...handleProfileCreated(state, message.payload.profile, message.timestamp), })); }, "agent.profile.updated": (message) => { store.setState((state) => ({ ...state, - ...handleProfileUpdated(state, message.payload.profile), + ...handleProfileUpdated(state, message.payload.profile, message.timestamp), })); }, "agent.profile.deleted": (message) => { - const profile = message.payload.profile as Record; - const profileId = profile.id as string; - const agentId = getAgentId(profile); store.setState((state) => ({ ...state, - agentProfiles: { - ...state.agentProfiles, - items: state.agentProfiles.items.filter((p) => p.id !== profileId), - }, - settingsAgents: { - items: state.settingsAgents.items.map((item) => - item.id === agentId - ? { - ...item, - profiles: item.profiles.filter((p) => p.id !== profileId), - } - : item, - ), - }, + ...handleProfileDeleted(state, message.payload.profile, message.timestamp), })); }, }; diff --git a/apps/web/src/locales/en/agents.json b/apps/web/src/locales/en/agents.json index 5982f65095..fbd4940984 100644 --- a/apps/web/src/locales/en/agents.json +++ b/apps/web/src/locales/en/agents.json @@ -214,5 +214,10 @@ "watcherKindGithubIssue": "GitHub Issues", "watcherKindGithubReview": "GitHub PR Reviews", "watcherKindJira": "Jira", - "watcherKindLinear": "Linear" + "watcherKindLinear": "Linear", + "duplicate": "Duplicate", + "duplicateProfileNamed": "Duplicate {{name}}", + "duplicateProfileSuccess": "Profile duplicated", + "duplicateSaveBlocked": "Settings are still saving. Try again in a moment.", + "failedToDuplicateProfile": "Failed to duplicate profile" } diff --git a/apps/web/src/locales/pseudo/agents.json b/apps/web/src/locales/pseudo/agents.json index 2d66dbc77f..49b530d1ef 100644 --- a/apps/web/src/locales/pseudo/agents.json +++ b/apps/web/src/locales/pseudo/agents.json @@ -214,5 +214,10 @@ "watcherKindGithubIssue": "ĜĩţĤũƀ Ĩśśũēś", "watcherKindGithubReview": "ĜĩţĤũƀ ƤŔ Ŕēvĩēŵś", "watcherKindJira": "Ĵĩŕà", - "watcherKindLinear": "Ĺĩńēàŕ" + "watcherKindLinear": "Ĺĩńēàŕ", + "duplicate": "Ďũƥĺĩćàţē", + "duplicateProfileNamed": "Ďũƥĺĩćàţē {{name}}", + "duplicateProfileSuccess": "Ƥŕōƒĩĺē ďũƥĺĩćàţēď", + "duplicateSaveBlocked": "Śēţţĩńĝś àŕē śţĩĺĺ śàvĩńĝ. Ţŕŷ àĝàĩń ĩń à ḿōḿēńţ.", + "failedToDuplicateProfile": "Ƒàĩĺēď ţō ďũƥĺĩćàţē ƥŕōƒĩĺē" } diff --git a/docs/plans/agent-profile-duplicate/plan.md b/docs/plans/agent-profile-duplicate/plan.md new file mode 100644 index 0000000000..ed462391f6 --- /dev/null +++ b/docs/plans/agent-profile-duplicate/plan.md @@ -0,0 +1,256 @@ +--- +spec: docs/specs/agents/profile-duplicate.md +created: 2026-08-11 +status: complete +--- + +# Implementation Plan: Agent Profile Duplicate + +## Overview + +Add a one-click "duplicate" for agent profiles on the settings agents surface +(`/settings/agents` profile list and the per-profile settings page). A new +interlock-protected endpoint `POST /api/v1/agent-profiles/:id/duplicate` +copies the source profile's full configuration (model, mode, config options, +CLI flags, env vars, launcher prefix, auto-approve flags, enabled state, MCP +config row) into a fresh row named ` Copy`, broadcasts the existing +`agent.profile.created` WS event, and returns the new profile DTO. + +## Backend + +### Controller: `DuplicateProfile` + +Add to `apps/backend/internal/agent/settings/controller/profile_crud.go`: + +- `type DuplicateProfileRequest struct { ID string }`. +- `func (c *Controller) DuplicateProfile(ctx, req) (*dto.AgentProfileDTO, error)`: + 1. `repo.GetAgentProfile(ctx, req.ID)`; map the "agent profile not found" + error to `ErrAgentProfileNotFound` exactly like `DeleteProfile` does + (the sqlite store wraps `sql.ErrNoRows` in a message containing + "agent profile not found"). + 2. Build a fresh `models.AgentProfile` copying every configuration field: + `AgentID`, `AgentDisplayName`, `Model`, `FallbackModel` (trimmed), + `AutoFallback`, `Mode`, `ConfigOptions` (through + `profileconfig.SanitizeConfigOptions` on a copied map), + `AllowIndexing`, `AutoApprove`, `CLIPassthrough`, `CLIFlags` (deep + copy of the slice), `EnvVars` (deep copy of the slice, keeping + `SecretID` refs), `CommandPrefix`, `UserModified: true`, and the office + enrichment configuration fields (`WorkspaceID`, `Role`, `Icon`, + `ReportsTo`, `SkillIDs`, `DesiredSkills`, `MaxConcurrentSessions`, + `CooldownSec`, `SkipIdleRuns`, `FailureThreshold` (copied pointer), + `ExecutorPreference`, `BudgetMonthlyCents`, `Settings`, `Permissions`). + Do NOT copy runtime state: `Status`, `PauseReason`, `LastRunFinishedAt`, + `ConsecutiveFailures`, `DeletedAt`, `MigratedFrom`, `CustomPrompt`, + `DangerouslySkipPermissions`. + 3. Name: `strings.TrimSpace(source.Name) + " Copy"`. The name is persisted + data, not UI copy (same convention as seeded executor/repository names), + so the suffix is a plain string in Go. + 4. Read the source's MCP config row when it has one (`repo + .GetAgentProfileMcpConfig(ctx, source.ID)`; tolerate `sql.ErrNoRows` / + nil); deep-copy `Servers` and `Meta` into a fresh + `models.AgentProfileMcpConfig` (ProfileID filled by the repo). A source + without a row leaves the copy without one — the default-config + semantics and boot `EnsureDefaultMcpConfig` cover MCP-supporting + agents. + 5. `repo.DuplicateAgentProfile(ctx, store.DuplicateAgentProfileInput{...})` + — NEW atomic repository operation (adversarial review round 1): one + transaction inserts the row with the caller-provided `Enabled` state + (NOT forced true like `CreateAgentProfile`, so a disabled source never + becomes briefly selectable) and upserts the MCP config row. A failure + rolls back, leaving no partial copy. Rollback makes each attempt + atomic, but the endpoint is not HTTP-idempotent: a retried request + creates another row (the UI guards against double-clicks). The store + assigns the fresh UUID and a single `CreatedAt`/`UpdatedAt` pair, + which the returned DTO reflects (no stale timestamp after a second + write). + 6. **Consistent snapshot (adversarial review round 5):** inside the + transaction the repository re-reads the source profile and MCP rows and + verifies their `updated_at` still match the revisions the copy was + built from (`ErrProfileChanged` / `ErrSourceProfileNotFound` otherwise); + WAL snapshot isolation aborts the write with a busy error if a + concurrent writer commits between the verification and the insert. The + controller retries (bounded, `maxDuplicateRetries = 2`) on + `ErrProfileChanged` / `ErrSourceProfileNotFound` / busy errors with a + fresh source read, so the copy always reflects one consistent snapshot. + 7. Return `toProfileDTO(clone)`. + +Env-var secret refs are copied verbatim; they were validated when the source +was created/updated, so no re-validation is needed. + +### Handler + route + +In `apps/backend/internal/agent/settings/handlers/handlers.go`: + +- Register `api.POST("/agent-profiles/:id/duplicate", h.interlock, + h.httpDuplicateProfile)` next to the other `/agent-profiles/:id` routes. +- `httpDuplicateProfile`: require `:id`, call + `controller.DuplicateProfile`, map `ErrAgentProfileNotFound` → 404, other + errors → 500; on success broadcast + `ws.ActionAgentProfileCreated` with `{"profile": resp}` (same payload + shape as `httpCreateProfile`) and return the DTO with 200. + +### Tests (backend) + +- Controller, new file + `apps/backend/internal/agent/settings/controller/profile_duplicate_test.go` + (using the existing `newTestController` + `newFakeStore`): + - full-config copy: source with model/fallback/mode/config options/CLI + flags/env vars/command prefix/auto-approve/cli-passthrough duplicates + with equal fields, new ID, `Default Copy` name, `user_modified` true; + - disabled source → disabled copy stored in the single atomic write (no + follow-up enabled flip, timestamps match the stored row); + - MCP config row copied to the new profile ID with equal enabled/servers/meta + (extend the shared `fakeStore` in `reconciler_test.go` with an + `mcpConfigs` map + working `GetAgentProfileMcpConfig` / + `UpsertAgentProfileMcpConfig` + `DuplicateAgentProfile`, additively — + other tests only observe the existing nil behaviour); + - store failure propagates and leaves no partial copy; + - unknown ID → `ErrAgentProfileNotFound`; + - empty source name (`""` → `" Copy"` is acceptable; source names are + non-empty by validation, but pin the suffix behaviour). +- Store, new file `apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go`: + sqlite `DuplicateAgentProfile` round-trip — fresh ID, full configuration + preserved, disabled copy stays disabled (not forced enabled), MCP row + copied, source untouched; no MCP row created when none passed. +- Handler, `apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go`: + add `{method: POST, path: "/api/v1/agent-profiles/profile-1/duplicate"}` + to the route list that must return 403 without the interlock token. +- Handler test (mandatory, adversarial review round 9): an office-scoped + source (`WorkspaceID != ""`) returns 404 with zero broadcasts on any + channel — global or workspace-scoped — and the office profile is rejected + before MCP config is read or written. Also assert 404 mapping and the + `agent.profile.created` broadcast for kanban profiles, following + `agent_update_handlers_test.go`'s controller-stub pattern. + +## Frontend + +### API action + +In `apps/web/app/actions/agents.ts` add: + +```ts +export async function duplicateAgentProfileAction(profileId: string): Promise { + const raw = await agentSettingsRequest( + `${apiBaseUrl}/api/v1/agent-profiles/${profileId}/duplicate`, + { method: "POST" }, + ); + return normalizeAgentProfile(raw); +} +``` + +### List page: per-row Duplicate button + +- `apps/web/app/settings/agents/profile-list-item.tsx`: accept an + `onDuplicate: (profile: AgentProfile) => void` prop; render an icon-only + button (copy icon, e.g. `IconCopy` from `@tabler/icons-react`) outside the + link, next to the enabled switch, with `aria-label` / tooltip via + `t("agents:duplicateProfileNamed", { name: profile.name })` and + `data-testid={`duplicate-profile-${profile.id}`}`. +- `apps/web/app/settings/agents/page.tsx`: thread `onDuplicate` through + `AgentProfilesSection`; add a `handleDuplicateProfile` wired like + `useProfileEnabledToggle` (POST via the action, then merge the returned + profile into `settingsAgents` + `agentProfiles` store slices atomically via + `useAppStoreApi().setState`, appending the new profile to its agent's + `profiles`; toast success/failure via `agents:duplicateProfileSuccess` / + `agents:failedToDuplicateProfile`). The `agent.profile.created` WS handler + already upserts the same profile; the direct merge keeps the UI consistent + even if WS is delayed. The merge (`applyProfileDuplicated` in + `use-profile-duplicate.ts`) dedupes by ID, preserves WS-delivered options + whose owning agent is absent, never lets a stale duplicate response clobber + a newer `agent.profile.updated` version (newer `updatedAt` wins), and + always rebuilds the copy option with the known agent metadata. + +### Profile settings page: header Duplicate button + +- `apps/web/components/settings/agent-profile-page.tsx`: add a Duplicate + button to `ProfileEditorHeader` (copy icon + `t("agents:duplicate")`, + `data-testid="duplicate-profile-header"`, disabled + `aria-busy` while a + duplicate is in flight). The flow lives in the extracted + `useProfileDuplicateAction` hook + (`components/settings/agent-profile-duplicate-action.ts`, unit-tested): + a ref-based in-flight guard (two rapid clicks can never issue two + copies), then save EVERY dirty contributor via the shared settings save + coordinator (`useSettingsSaveCoordinator().saveAll` — the profile editor + AND its MCP card; `saveAll` respects each contributor's `canSave`, and the + abort toasts the blocking contributor's `invalidReason` — MCP error or + profile-name validation), POST the duplicate, merge the copy into the + store, toast `agents:duplicateProfileSuccess`, cancel any pending + navigation intent the dirty guard had blocked, and SPA-navigate via + `runWithNavigationBlockerBypassed(() => router.push(...))` — never + `window.location.assign`, so the success toast survives and the + dirty-settings blocker is already resolved by the save. The row-level + duplicate hook guards against double-clicks (per-profile in-flight set). + The profile save path (`syncAgentsToStore`) reconciles the options slice + by ID (`reconcileAgentProfileOptions`), preserving WS-delivered orphan + options exactly like the duplicate merge. The merge keeps a newer + WS-delivered orphan option (revision carried on the option as `updatedAt`) + over a stale duplicate HTTP response, matching the newer-wins rule used + when the owning agent is present. + +### i18n + +Add to `apps/web/src/locales/en/agents.json`: + +- `"duplicate": "Duplicate"` +- `"duplicateProfile": "Duplicate profile"` +- `"duplicateProfileNamed": "Duplicate {{name}}"` +- `"duplicateProfileSuccess": "Profile duplicated"` +- `"failedToDuplicateProfile": "Failed to duplicate profile"` + +Regenerate the pseudo locale (`pnpm --filter @kandev/web i18n:pseudo`). Real +locales (`zh-cn`, `pt-pt`) fall back to en; key-parity is a warning there, +missing en keys are a hard error. + +### Tests (frontend) + +- `apps/web/app/settings/agents/profile-list-item.test.tsx`: extend with a + case asserting the Duplicate button renders and calls `onDuplicate` with + the profile (mirroring the existing toggle tests). +- `apps/web/lib/api/domains/agent-profile-normalize.test.ts` or the actions + layer: only if an existing action-test pattern exists; otherwise the + component test plus E2E covers the contract. + +## E2E + +New `apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts` modeled on +`agent-profile-delete.spec.ts`: + +- Create a source profile via `apiClient.createAgentProfile(agent.id, + "Dup Me", { model: agent.profiles[0].model, cli_flags: [...], command_prefix: ... })`. +- `testPage.goto("/settings/agents")`, wait for the profile list, click the + duplicate button on the "Dup Me" row (`duplicate-profile-`). +- Expect a "Dup Me Copy" row to appear without reload. +- Navigate to the copy's profile page and assert the copied model/cli flag + values render. +- `finally`: delete both profiles via `apiClient.deleteAgentProfile(..., true)`. + +## Implementation Waves + +Execution is sequential in the primary conversation; no subagents are +authorized. + +Wave 1: + +- [x] [Task 01: Backend duplicate endpoint](task-01-backend-duplicate-endpoint.md) + +Wave 2: + +- [x] [Task 02: Frontend duplicate UI](task-02-frontend-duplicate-ui.md) + +Wave 3: + +- [x] [Task 03: E2E duplicate flow](task-03-duplicate-e2e.md) + +## Risks + +- `DuplicateAgentProfile` inserts the copy with the caller-provided enabled + state inside one transaction, unlike `CreateAgentProfile` which forces + `Enabled=true` for other callers — a store regression that forces the + duplicate enabled is pinned by `sqlite_duplicate_test.go` (disabled copy + stays disabled) and by the controller test asserting no follow-up write. +- `GetAgentProfileMcpConfig` returns different "absent" shapes across the + sqlite store (`sql.ErrNoRows`) and the shared fake store (`nil, nil`); + the controller must tolerate both. +- The list-page direct store merge and the WS `agent.profile.created` + broadcast can both insert the copy; the WS handler upserts by ID so this + is safe (verify while implementing). diff --git a/docs/plans/agent-profile-duplicate/task-01-backend-duplicate-endpoint.md b/docs/plans/agent-profile-duplicate/task-01-backend-duplicate-endpoint.md new file mode 100644 index 0000000000..3df3b80332 --- /dev/null +++ b/docs/plans/agent-profile-duplicate/task-01-backend-duplicate-endpoint.md @@ -0,0 +1,81 @@ +--- +id: "01-backend-duplicate-endpoint" +title: "Add the backend profile duplicate endpoint" +status: done +wave: 1 +depends_on: [] +plan: "plan.md" +spec: "../../specs/agents/profile-duplicate.md" +--- + +# Task 01: Backend profile duplicate endpoint + +## Acceptance + +- `POST /api/v1/agent-profiles/:id/duplicate` (interlock-protected) creates a + new profile named ` Copy` with a distinct ID and + `user_modified: true`, copying model, fallback model, auto-fallback, mode, + config options, allow-indexing, auto-approve, CLI passthrough, CLI flags, + env vars (secret refs included), command prefix, enabled state, and the + source's MCP config row (enabled + servers + meta) when one exists. +- Runtime state is not copied: the copy is idle, no pause reason, no last-run + timestamp, zero consecutive failures. +- A disabled source produces a disabled copy; an enabled source produces an + enabled copy. +- The copy is committed atomically (row + MCP config in one repository + transaction, inserted with the source's enabled state): a failure leaves no + partial profile and a disabled source never becomes briefly selectable. +- Unknown or soft-deleted source ID → `ErrAgentProfileNotFound` → HTTP 404, + and nothing is created. +- An office-scoped source (non-empty `workspace_id`) → `ErrAgentProfileNotFound` + → HTTP 404 (existence hidden), rejected before MCP config is read or any + row is written, with zero broadcasts on any channel (global or + workspace-scoped). +- Success returns the new `AgentProfileDTO` and broadcasts the + `agent.profile.created` WS notification with `{"profile": }`. +- The route is added to the interlock 403 route list. + +## Verification + +- RED/GREEN controller: + `cd apps/backend && go test -run 'TestDuplicateProfile' ./internal/agent/settings/controller` +- Interlock list: + `cd apps/backend && go test -run 'TestRegisterRoutesProtectsEveryStateChangingAgentSettingsRoute' ./internal/agent/settings/handlers` +- Full package after refactor: + `cd apps/backend && go test ./internal/agent/settings/...` + +## Files likely touched + +- `apps/backend/internal/agent/settings/controller/profile_crud.go` +- `apps/backend/internal/agent/settings/controller/profile_duplicate_test.go` (new) +- `apps/backend/internal/agent/settings/controller/reconciler_test.go` (extend shared `fakeStore` with MCP config methods + `DuplicateAgentProfile`, additively) +- `apps/backend/internal/agent/settings/store/store.go` (add `DuplicateAgentProfile` to the repository interface) +- `apps/backend/internal/agent/settings/store/sqlite.go` (atomic `DuplicateAgentProfile` in one transaction; shared insert/upsert helpers) +- `apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go` (new) +- `apps/backend/internal/agent/settings/handlers/handlers.go` +- `apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go` +- Optional: `apps/backend/internal/agent/settings/handlers/profile_duplicate_handlers_test.go` + +## Dependencies + +None. + +## Parallelism + +Sequential by default; file-disjoint from Tasks 02–03 and may run in parallel +only with explicit user authorization. + +## Inputs + +- Spec duplicate scenarios +- `profile_crud.go` existing `DeleteProfile` not-found mapping and + `CreateProfile` field list; `store.Repository` interface; sqlite + `CreateAgentProfile` / `GetAgentProfileMcpConfig` / + `UpsertAgentProfileMcpConfig`; `ws.ActionAgentProfileCreated` broadcast + pattern from `httpCreateProfile`. + +## Output contract + +Report RED and GREEN results, the response/error contract, changed files, the +enabled-state and MCP-copy behavior, and update this task plus `plan.md` +status. diff --git a/docs/plans/agent-profile-duplicate/task-02-frontend-duplicate-ui.md b/docs/plans/agent-profile-duplicate/task-02-frontend-duplicate-ui.md new file mode 100644 index 0000000000..71de7c13f7 --- /dev/null +++ b/docs/plans/agent-profile-duplicate/task-02-frontend-duplicate-ui.md @@ -0,0 +1,72 @@ +--- +id: "02-frontend-duplicate-ui" +title: "Add the frontend duplicate UI" +status: done +wave: 2 +depends_on: ["01-backend-duplicate-endpoint"] +plan: "plan.md" +spec: "../../specs/agents/profile-duplicate.md" +--- + +# Task 02: Frontend duplicate UI + +## Acceptance + +- `duplicateAgentProfileAction(profileId)` POSTs to + `/api/v1/agent-profiles/:id/duplicate` and returns the normalized + `AgentProfile`. +- Each profile row on `/settings/agents` shows a Duplicate icon button + (outside the row link, beside the enabled switch) with an accessible label + `Duplicate `, `data-testid="duplicate-profile-"`, and a touch + target of at least 44×44px. Clicking it creates the copy and adds the new + row to the store immediately (toast on success/failure). No navigation. +- The profile settings page header (`/settings/agents//profiles/`) + shows a Duplicate button (`data-testid="duplicate-profile-header"`, + `min-h-11` touch target). On success it toasts and navigates to the copy's + settings page. +- All new user-facing copy goes through `t()`; the persisted copy name stays + server-side (` Copy`) and is not localized. +- New en keys exist in `agents.json`; the pseudo locale is regenerated; + `i18n:check` and `i18n:ratchet` pass for changed lines. + +## Verification + +- Component test: + `cd apps/web && pnpm vitest run app/settings/agents/profile-list-item.test.tsx` +- i18n: + `cd apps/web && pnpm run i18n:pseudo && pnpm run i18n:check` +- Typecheck + lint of changed files: + `cd apps/web && pnpm run typecheck` + `cd apps && pnpm --filter @kandev/web lint` (or the repo's configured lint command) + +## Files likely touched + +- `apps/web/app/actions/agents.ts` +- `apps/web/app/settings/agents/profile-list-item.tsx` +- `apps/web/app/settings/agents/profile-list-item.test.tsx` +- `apps/web/app/settings/agents/page.tsx` +- `apps/web/components/settings/agent-profile-page.tsx` +- `apps/web/src/locales/en/agents.json` +- `apps/web/src/locales/pseudo/agents.json` (regenerated) + +## Dependencies + +Task 01 (endpoint must exist for the action to hit). + +## Parallelism + +Sequential by default; may run in parallel with Task 03 only with explicit +user authorization. + +## Inputs + +- Spec duplicate scenarios and API surface +- `useProfileEnabledToggle` / `applyEnabledProfileUpdate` store-merge + pattern; `agent-profile-page-state.ts` delete/navigate flow; `normalizeAgentProfile`; + `ws/handlers/agents.ts` `handleProfileCreated` upsert-by-ID behaviour + (verify no double-row when the direct merge and WS both insert). + +## Output contract + +Report RED and GREEN results, store-merge approach, toast keys, changed +files, and update this task plus `plan.md` status. diff --git a/docs/plans/agent-profile-duplicate/task-03-duplicate-e2e.md b/docs/plans/agent-profile-duplicate/task-03-duplicate-e2e.md new file mode 100644 index 0000000000..62ba05b846 --- /dev/null +++ b/docs/plans/agent-profile-duplicate/task-03-duplicate-e2e.md @@ -0,0 +1,56 @@ +--- +id: "03-duplicate-e2e" +title: "Add the E2E duplicate flow" +status: done +wave: 3 +depends_on: ["01-backend-duplicate-endpoint", "02-frontend-duplicate-ui"] +plan: "plan.md" +spec: "../../specs/agents/profile-duplicate.md" +--- + +# Task 03: E2E duplicate flow + +## Acceptance + +- An E2E spec (`agent-profile-duplicate.spec.ts`) proves the user-facing + flow: create a profile with distinctive settings via `apiClient`, open + `/settings/agents`, click its Duplicate button, and see a + ` Copy` row appear without a page reload. +- The copy's profile page shows the copied settings (model / CLI flag / + command prefix) matching the source. +- The spec cleans up both profiles in `finally`. + +## Verification + +- `cd apps/web && pnpm e2e:raw --grep "agent profile duplicate"` (or the + repo's E2E runner for `tests/settings/agent-profile-duplicate.spec.ts`). +- Mobile parity: the new row button must be reachable at mobile widths; reuse + the desktop spec unless a mobile-only interaction appears (the icon button + sits outside the row link exactly like the existing switch, which already + has mobile coverage patterns). + +## Files likely touched + +- `apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts` (new) +- `apps/web/e2e/tests/settings/mobile-agent-profile-duplicate.spec.ts` (new — mobile parity: Pixel 5 tap on the 44px row control, copy row appears, no horizontal overflow) + +## Dependencies + +Tasks 01 and 02 (endpoint and UI must exist). + +## Parallelism + +Sequential by default; may run in parallel with Task 02 only with explicit +user authorization. + +## Inputs + +- Spec duplicate scenarios +- `agent-profile-delete.spec.ts` structure (apiClient setup, testPage.goto, + row assertions); `apiClient.createAgentProfile` / `deleteAgentProfile` + helpers; `cleanupTestProfiles` convention. + +## Output contract + +Report the passing E2E run (or the exact failure to investigate), cleanup +behaviour, changed files, and update this task plus `plan.md` status. diff --git a/docs/specs/agents/profile-duplicate.md b/docs/specs/agents/profile-duplicate.md new file mode 100644 index 0000000000..17866efd40 --- /dev/null +++ b/docs/specs/agents/profile-duplicate.md @@ -0,0 +1,106 @@ +--- +status: draft +created: 2026-08-11 +owner: kandev +--- + +# Duplicate an Agent Profile + +## Why + +Profiles are the per-agent configuration unit (model, mode, config options, +CLI flags, env vars, launcher prefix, auto-approve). Creating a variant of an +existing profile means re-entering every field by hand today: there is no way +to start from a working configuration. Users need a one-click "duplicate" that +copies a profile's full configuration under a new name, so they can tweak the +copy (a different model, an extra CLI flag, a sandbox launcher) without +touching the source. + +## What + +- Every profile row on the settings agents page + (`/settings/agents`, the "Manage existing profiles by agent" list) gets a + **Duplicate** action. +- The profile settings page + (`/settings/agents//profiles/`) gets the same **Duplicate** + action in its header. +- Duplicating creates a new profile that is a faithful copy of the source's + configuration: name-derived new name, model, fallback model, auto-fallback, + mode, config options, allow-indexing, auto-approve, CLI passthrough, CLI + flags, env vars, command prefix, enabled state, and MCP config (enabled + flag + servers + meta) when the source has one. +- The copy is an independent row: it gets a new ID, `user_modified` is set, + and editing or deleting it never affects the source. No session, task, + watcher, automation, or routing reference points at the copy. +- The copy is committed atomically: the row is inserted with the source's + enabled state and the MCP config row is upserted in one repository + transaction, so a duplicated profile inherits the source's selection state + and a disabled source never becomes briefly selectable. A failure rolls + back and leaves no partial copy. +- Runtime state is never copied: the copy starts idle with no pause reason, + no last-run timestamp, and a zero consecutive-failure count. Office + enrichment configuration (workspace, role, budget, permissions, skills, + executor preference, …) is copied when present, matching the faithful-copy + intent; the settings surface only lists global (non-office) profiles, so in + practice those fields are empty on the rows this feature shows. +- The generated name is persisted user data, not UI copy: it is + ` Copy` (e.g. `Default` → `Default Copy`), matching the + repo convention that stored names do not depend on the locale they were + created in (same rule as seeded executor and repository names). + +## API surface + +`POST /api/v1/agent-profiles/:id/duplicate` (interim-settings-interlock +protected, like every other profile mutation): + +- Request body: none. The copy name is derived server-side as + ` Copy`. +- Response `200`: the new `AgentProfileDTO` (same shape as + `POST /agents/:id/profiles`). +- `404` when the source profile does not exist or is soft-deleted. +- Broadcasts the existing `agent.profile.created` WebSocket notification so + every open settings surface picks the copy up live. + +The endpoint is not idempotent in the HTTP sense: each call creates one new +row (there is no idempotency key), so a retried POST after a network timeout +may create a second copy. Callers must treat duplicates as one-shot +operations; the UI guards against double-clicks. The copy performs no +reference checks because a brand-new row cannot be referenced by anything +yet. + +## Scenarios + +- **GIVEN** a profile named `Default` with model, CLI flags, env vars, and a + command prefix, **WHEN** the user clicks Duplicate on its row in + `/settings/agents`, **THEN** a new profile row `Default Copy` appears + immediately with every configuration field equal to the source, a distinct + ID, and `user_modified` true. +- **GIVEN** an MCP-capable agent profile with an MCP config (enabled with + servers), **WHEN** it is duplicated, **THEN** the copy has the same MCP + enabled state, servers, and meta under the new profile ID. +- **GIVEN** a disabled profile, **WHEN** it is duplicated, **THEN** the copy + is also disabled. +- **GIVEN** a profile with an active session, **WHEN** it is duplicated, + **THEN** the duplicate succeeds (unlike delete, no in-use checks apply) and + the session keeps using the source. +- **GIVEN** the profile settings page of a profile, **WHEN** the user clicks + Duplicate in the header, **THEN** a toast confirms the copy and the user is + taken to the copy's settings page to edit it. +- **GIVEN** an unknown profile ID, **WHEN** the duplicate endpoint is called, + **THEN** it returns `404` and creates nothing. + +## Out of scope + +- Duplicating office workspace agents through the office UI (`/office/agents`): + office has its own agent creation flows and permission model. This feature + targets the `/settings/agents` profile flavor. The settings duplicate + endpoint is fail-closed against office-scoped sources: a profile with a + non-empty `workspace_id` returns `404` (existence hidden) before any MCP + read or write, so the instance-level settings surface can never read or + clone another workspace's configuration. Office duplication, when added, + belongs on the workspace-scoped office API surface. +- Renaming after duplicate: the copy is a normal profile the user renames via + the existing profile editor. +- Bulk/queue duplication, templates, or copy-paste between agents. +- Choosing the copy name in the duplicate dialog: name is derived, then edited + on the copy's settings page.