diff --git a/docs/assets/qa/project-owner/created-after.png b/docs/assets/qa/project-owner/created-after.png new file mode 100644 index 00000000..530b3371 Binary files /dev/null and b/docs/assets/qa/project-owner/created-after.png differ diff --git a/docs/assets/qa/project-owner/created-before.png b/docs/assets/qa/project-owner/created-before.png new file mode 100644 index 00000000..9037b642 Binary files /dev/null and b/docs/assets/qa/project-owner/created-before.png differ diff --git a/docs/assets/qa/project-owner/welcome-after.png b/docs/assets/qa/project-owner/welcome-after.png new file mode 100644 index 00000000..1f384a5d Binary files /dev/null and b/docs/assets/qa/project-owner/welcome-after.png differ diff --git a/docs/assets/qa/project-owner/welcome-before.png b/docs/assets/qa/project-owner/welcome-before.png new file mode 100644 index 00000000..5e7ad5a8 Binary files /dev/null and b/docs/assets/qa/project-owner/welcome-before.png differ diff --git a/internal/httpapi/auth_password.go b/internal/httpapi/auth_password.go index cd1adb15..5512e243 100644 --- a/internal/httpapi/auth_password.go +++ b/internal/httpapi/auth_password.go @@ -1,6 +1,7 @@ package httpapi import ( + "agentflow/internal/repo" "net/http" "net/url" "sync" @@ -105,6 +106,9 @@ func (h *authHandlers) authPassword(c *gin.Context) { return } user := domainUserToAuth(u) + if h.repo.IsPlatformAdmin(u.LoginName) { + joinWelcomeProject(h.repo, u.ID, repo.WelcomeAdminLogin) + } token, err := h.getAuthClient().SignUser(user) if err != nil { respond(c, err) diff --git a/internal/httpapi/auth_register.go b/internal/httpapi/auth_register.go index d609c856..096e7738 100644 --- a/internal/httpapi/auth_register.go +++ b/internal/httpapi/auth_register.go @@ -1,7 +1,6 @@ package httpapi import ( - "agentflow/internal/domain" "agentflow/internal/repo" "errors" "fmt" @@ -38,22 +37,8 @@ func (h *authHandlers) authSetup(c *gin.Context) { const welcomeProjectID = "welcome" -// joinWelcomeProject makes the seeded demo project usable by new accounts so -// the onboarding path works before they create a project of their own. -func (h *authHandlers) joinWelcomeProject(userID int64) { joinWelcomeProject(h.repo, userID) } - -func joinWelcomeProject(store *repo.Store, userID int64) { - project, ok := store.Project(welcomeProjectID) - if !ok { - return - } - for _, m := range project.Members { - if m.UserID == userID { - return - } - } - project.Members = append(project.Members, domain.ProjectMember{UserID: userID, Role: "member"}) - if err := store.PutProject(project); err != nil { +func joinWelcomeProject(store *repo.Store, userID int64, event repo.WelcomeProjectEvent) { + if err := store.EnrollWelcomeAccount(welcomeProjectID, userID, event); err != nil { log.Printf("join welcome project: %v", err) } } @@ -96,8 +81,12 @@ func (h *authHandlers) authRegister(c *gin.Context) { return } u, err := h.repo.CreateLocalAccount(input.Login, input.Password, first) - if err == nil && !first { - h.joinWelcomeProject(u.ID) + if err == nil { + event := repo.WelcomeMemberSignup + if first { + event = repo.WelcomeFirstAdminSignup + } + joinWelcomeProject(h.repo, u.ID, event) } registerMu.Unlock() if errors.Is(err, repo.ErrLoginTaken) { diff --git a/internal/httpapi/auth_register_test.go b/internal/httpapi/auth_register_test.go index f3da9244..2d48a833 100644 --- a/internal/httpapi/auth_register_test.go +++ b/internal/httpapi/auth_register_test.go @@ -7,9 +7,11 @@ import ( "agentflow/internal/runtime" "bytes" "encoding/json" + "net/http" "net/http/httptest" "strings" "testing" + "time" ) func TestRegisterFirstAccountBecomesAdminAndSignupToggle(t *testing.T) { @@ -91,4 +93,163 @@ func TestRegisterFirstAccountBecomesAdminAndSignupToggle(t *testing.T) { if photo.Code != 200 || photo.Header().Get("Content-Type") != "image/svg+xml" || !strings.Contains(photo.Body.String(), ">M") { t.Fatalf("local avatar: %d %s", photo.Code, photo.Body.String()) } + if welcome.OwnerID != 0 { + t.Fatalf("a later signup must not take over an ownerless welcome project, owner=%d", welcome.OwnerID) + } +} + +func TestFirstAccountOwnsWelcomeAndProjectsItCreates(t *testing.T) { + t.Setenv("AGENTFLOW_AUTH_REQUIRED", "true") + t.Setenv("AGENTFLOW_SCHEDULER_ENABLED", "false") + s, err := repo.OpenTest() + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + if err := s.PutProject(domain.Project{ID: welcomeProjectID, Name: "Welcome"}); err != nil { + t.Fatal(err) + } + h := New(s, engine.New(s, runtime.NewManager(t.TempDir())), nil, "", "") + reg := httptest.NewRequest(http.MethodPost, "http://localhost/api/auth/register", bytes.NewBufferString(`{"login":"owner","password":"a-long-enough-password"}`)) + reg.Header.Set("Content-Type", "application/json") + reg.Header.Set("Origin", "http://localhost") + rw := httptest.NewRecorder() + h.ServeHTTP(rw, reg) + if rw.Code != 200 { + t.Fatalf("register: %d %s", rw.Code, rw.Body.String()) + } + var registered struct { + User struct { + ID int64 `json:"id"` + } `json:"user"` + } + if json.Unmarshal(rw.Body.Bytes(), ®istered) != nil || registered.User.ID == 0 { + t.Fatalf("register body: %s", rw.Body.String()) + } + welcome, _ := s.Project(welcomeProjectID) + if welcome.OwnerID != registered.User.ID { + t.Fatalf("first account must own the seeded welcome project, owner=%d user=%d", welcome.OwnerID, registered.User.ID) + } + if len(welcome.Members) != 1 || welcome.Members[0].Role != "maintainer" { + t.Fatalf("first account membership: %+v", welcome.Members) + } + create := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewBufferString(`{"id":"fresh","key":"FRESH","name":"Fresh"}`)) + create.Header.Set("Content-Type", "application/json") + for _, cookie := range rw.Result().Cookies() { + create.AddCookie(cookie) + } + cw := httptest.NewRecorder() + h.ServeHTTP(cw, create) + if cw.Code != 200 { + t.Fatalf("create project: %d %s", cw.Code, cw.Body.String()) + } + var created domain.Project + if json.Unmarshal(cw.Body.Bytes(), &created) != nil || created.OwnerID != registered.User.ID { + t.Fatalf("admin-created project owner=%d body=%s", created.OwnerID, cw.Body.String()) + } +} + +func TestAdminLoginClaimsOwnerlessWelcome(t *testing.T) { + t.Setenv("AGENTFLOW_AUTH_REQUIRED", "true") + t.Setenv("AGENTFLOW_SCHEDULER_ENABLED", "false") + s, err := repo.OpenTest() + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + h := New(s, engine.New(s, runtime.NewManager(t.TempDir())), nil, "", "") + reg := httptest.NewRequest(http.MethodPost, "http://localhost/api/auth/register", bytes.NewBufferString(`{"login":"owner","password":"a-long-enough-password"}`)) + reg.Header.Set("Content-Type", "application/json") + reg.Header.Set("Origin", "http://localhost") + rw := httptest.NewRecorder() + h.ServeHTTP(rw, reg) + if rw.Code != 200 { + t.Fatalf("register: %d %s", rw.Code, rw.Body.String()) + } + if err := s.PutProject(domain.Project{ID: welcomeProjectID, Name: "Welcome"}); err != nil { + t.Fatal(err) + } + login := httptest.NewRequest(http.MethodPost, "http://localhost/api/auth/password", bytes.NewBufferString(`{"login":"owner","password":"a-long-enough-password"}`)) + login.Header.Set("Content-Type", "application/json") + login.Header.Set("Origin", "http://localhost") + lw := httptest.NewRecorder() + h.ServeHTTP(lw, login) + if lw.Code != 200 { + t.Fatalf("login: %d %s", lw.Code, lw.Body.String()) + } + welcome, _ := s.Project(welcomeProjectID) + owner, _ := s.UserByLoginName("owner") + if welcome.OwnerID != owner.ID || owner.ID == 0 { + t.Fatalf("admin login must claim an ownerless welcome project, owner=%d user=%d", welcome.OwnerID, owner.ID) + } +} + +func TestAdminLoginOnlyClaimsActiveUnownedWelcome(t *testing.T) { + t.Setenv("AGENTFLOW_AUTH_REQUIRED", "true") + t.Setenv("AGENTFLOW_SCHEDULER_ENABLED", "false") + s, err := repo.OpenTest() + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + const password = "a-long-enough-password" + admin, err := s.CreateLocalAccount("welcome-admin", password, true) + if err != nil { + t.Fatal(err) + } + owner, err := s.CreateLocalAccount("welcome-owner", password, false) + if err != nil { + t.Fatal(err) + } + h := New(s, engine.New(s, runtime.NewManager(t.TempDir())), nil, "", "") + login := func() { + t.Helper() + r := httptest.NewRequest(http.MethodPost, "http://localhost/api/auth/password", + bytes.NewBufferString(`{"login":"welcome-admin","password":"a-long-enough-password"}`)) + r.Header.Set("Origin", "http://localhost") + r.Header.Set("Content-Type", "application/json") + rec := httptest.NewRecorder() + h.ServeHTTP(rec, r) + if rec.Code != http.StatusOK { + t.Fatalf("login returned %d", rec.Code) + } + } + if err = s.PutProject(domain.Project{ID: welcomeProjectID, Name: "Configured welcome", Description: "Keep this setting", Members: []domain.ProjectMember{{UserID: admin.ID, Role: "member"}, {UserID: owner.ID, Role: "viewer"}}}); err != nil { + t.Fatal(err) + } + login() + p, _ := s.Project(welcomeProjectID) + roles := map[int64]string{} + for _, m := range p.Members { + roles[m.UserID] = m.Role + } + if p.OwnerID != admin.ID || roles[admin.ID] != "maintainer" || roles[owner.ID] != "viewer" || p.Description != "Keep this setting" { + t.Errorf("claim changed the wrong fields: owner=%d roles=%v", p.OwnerID, roles) + } + p.OwnerID = owner.ID + p.Members = []domain.ProjectMember{{UserID: owner.ID, Role: "maintainer"}} + if err = s.PutProject(p); err != nil { + t.Fatal(err) + } + login() + p, _ = s.Project(welcomeProjectID) + if p.OwnerID != owner.ID || len(p.Members) != 1 { + t.Errorf("login changed membership of an owned project: owner=%d members=%v", p.OwnerID, p.Members) + } + now := time.Now().UTC() + if err = s.SetProjectArchived(welcomeProjectID, &now, owner.ID); err != nil { + t.Fatal(err) + } + signup := httptest.NewRequest(http.MethodPost, "http://localhost/api/auth/register", bytes.NewBufferString(`{"login":"archived-signup","password":"a-long-enough-password"}`)) + signup.Header.Set("Content-Type", "application/json") + signup.Header.Set("Origin", "http://localhost") + response := httptest.NewRecorder() + h.ServeHTTP(response, signup) + if response.Code != http.StatusOK { + t.Fatalf("signup returned %d", response.Code) + } + p, _ = s.Project(welcomeProjectID) + if p.ArchivedAt == nil || len(p.Members) != 1 { + t.Errorf("archived project was changed by signup: members=%v", p.Members) + } } diff --git a/internal/httpapi/platform_settings.go b/internal/httpapi/platform_settings.go index ee98693e..9400bf07 100644 --- a/internal/httpapi/platform_settings.go +++ b/internal/httpapi/platform_settings.go @@ -86,7 +86,7 @@ func (h *usersHandlers) createPlatformAccount(c *gin.Context) { registerMu.Lock() u, err := h.repo.CreateLocalAccount(input.LoginName, input.Password, input.Admin) if err == nil { - joinWelcomeProject(h.repo, u.ID) + joinWelcomeProject(h.repo, u.ID, repo.WelcomeMemberSignup) } registerMu.Unlock() if errors.Is(err, repo.ErrLoginTaken) { diff --git a/internal/httpapi/projects.go b/internal/httpapi/projects.go index b9950e94..e7cd900e 100644 --- a/internal/httpapi/projects.go +++ b/internal/httpapi/projects.go @@ -53,19 +53,17 @@ func (h *projectsHandlers) projects(c *gin.Context) { c.JSON(401, gin.H{"error": "请先登录"}) return } + if !exists && v.OwnerID == 0 { + v.OwnerID = user.ID + } if !h.isPlatformAdmin(r) { if exists && existing.OwnerID != user.ID { c.JSON(403, gin.H{"error": "只有项目 Owner 或平台管理员可以修改项目设置"}) return } - if !exists { - if v.OwnerID == 0 { - v.OwnerID = user.ID - } - if v.OwnerID != user.ID { - c.JSON(403, gin.H{"error": "新项目 Owner 必须为当前用户"}) - return - } + if !exists && v.OwnerID != user.ID { + c.JSON(403, gin.H{"error": "新项目 Owner 必须为当前用户"}) + return } } } diff --git a/internal/repo/projects.go b/internal/repo/projects.go index 9aa3575d..876d2758 100644 --- a/internal/repo/projects.go +++ b/internal/repo/projects.go @@ -1,6 +1,7 @@ package repo import ( + "errors" "sort" "strings" "time" @@ -147,6 +148,66 @@ func (r *ProjectsRepo) SetProjectArchived(id string, at *time.Time, by int64) er }) } +// WelcomeProjectEvent describes how a local account reached the starter project. +type WelcomeProjectEvent uint8 + +const ( + WelcomeMemberSignup WelcomeProjectEvent = iota + WelcomeFirstAdminSignup + WelcomeAdminLogin +) + +// EnrollWelcomeAccount joins new accounts and lets the first active admin +// claim an unowned welcome project. Lock the row before deciding ownership: +// concurrent signups and logins must not replace each other's memberships. +func (r *ProjectsRepo) EnrollWelcomeAccount(id string, userID int64, event WelcomeProjectEvent) error { + if userID <= 0 { + return nil + } + return r.DB.Transaction(func(tx *gorm.DB) error { + var row projectRow + err := r.locking(tx).Select("id", "owner_user_id", "payload").Where("id = ?", id).Take(&row).Error + if errors.Is(err, gorm.ErrRecordNotFound) { + return nil + } + if err != nil { + return err + } + hasOwner := row.OwnerUserID != nil && *row.OwnerUserID > 0 + if hasOwner && event == WelcomeAdminLogin { + return nil + } + var project domain.Project + if err := jsonUnmarshal(row.Payload, &project); err != nil { + return err + } + if project.ArchivedAt != nil { + return nil + } + now := time.Now().UTC() + member := projectMemberRow{ProjectID: id, UserID: userID, Role: "member", Created: timePtr(now)} + onConflict := clause.OnConflict{DoNothing: true} + claim := !hasOwner && (event == WelcomeFirstAdminSignup || event == WelcomeAdminLogin) + if claim { + if err := tx.Model(&projectRow{}).Where("id = ?", id).Updates(map[string]any{ + "owner_user_id": userID, "payload": gorm.Expr("JSON_SET(payload, '$.ownerId', ?)", userID), "updated_at": now, + }).Error; err != nil { + return err + } + if err := backfillProjectAssignees(tx, id, userID); err != nil { + return err + } + member.Role = "maintainer" + onConflict = clause.OnConflict{Columns: []clause.Column{{Name: "project_id"}, {Name: "user_id"}}, DoUpdates: clause.AssignmentColumns([]string{"role"})} + } + created := tx.Clauses(onConflict).Create(&member) + if created.Error != nil || created.RowsAffected == 0 || claim { + return created.Error + } + return tx.Model(&projectRow{}).Where("id = ?", id).Update("updated_at", now).Error + }) +} + func (r *ProjectsRepo) PutProject(v domain.Project) error { now := time.Now().UTC() if old, ok := r.Project(v.ID); ok { @@ -205,24 +266,17 @@ func (r *ProjectsRepo) writeProject(v domain.Project) error { } } if v.OwnerID > 0 { - // Backfill issue responsibility for issues that have no assignee. - var issueRows []issueRow - if err := tx.Where("project_id = ? AND assignee_user_id IS NULL", v.ID).Find(&issueRows).Error; err != nil { - return err - } - for _, row := range issueRows { - var issue domain.Issue - if jsonUnmarshal(row.Payload, &issue) != nil { - continue - } - issue.AssigneeUserID = v.OwnerID - if err := tx.Model(&issueRow{}).Where("id = ?", row.ID).Updates(map[string]any{ - "assignee_user_id": v.OwnerID, "payload": mustJSON(issue), - }).Error; err != nil { - return err - } - } + return backfillProjectAssignees(tx, v.ID, v.OwnerID) } return nil }) } + +func backfillProjectAssignees(tx *gorm.DB, projectID string, ownerID int64) error { + // Patch just the assignee so an unrelated edit to an issue is preserved. + return tx.Model(&issueRow{}).Where("project_id = ? AND assignee_user_id IS NULL AND JSON_VALID(payload)", projectID). + Updates(map[string]any{ + "assignee_user_id": ownerID, + "payload": gorm.Expr("JSON_SET(payload, '$.assigneeUserId', ?)", ownerID), + }).Error +} diff --git a/internal/repo/welcome_project_mysql_test.go b/internal/repo/welcome_project_mysql_test.go new file mode 100644 index 00000000..7c0677c5 --- /dev/null +++ b/internal/repo/welcome_project_mysql_test.go @@ -0,0 +1,81 @@ +package repo + +import ( + "os" + "strconv" + "sync" + "testing" + "time" + + "agentflow/internal/domain" +) + +func TestMySQLConcurrentWelcomeEnrollment(t *testing.T) { + dsn := os.Getenv("AGENTFLOW_TEST_MYSQL_DSN") + if dsn == "" { + t.Skip("requires disposable MySQL") + } + store, err := Open(dsn) + if err != nil { + t.Fatal(err) + } + t.Cleanup(store.Close) + id := "onboard-" + strconv.FormatInt(time.Now().UnixNano(), 36) + t.Cleanup(func() { + store.DB.Where("project_id = ?", id).Delete(&issueRow{}) + store.DB.Where("project_id = ?", id).Delete(&projectMemberRow{}) + store.DB.Where("id = ?", id).Delete(&projectRow{}) + }) + // Both admins already joined as ordinary members on the old version. + p := domain.Project{ID: id, Name: "Existing project", Members: []domain.ProjectMember{{UserID: 100, Role: "member"}, {UserID: 101, Role: "viewer"}}} + if err := store.PutProject(p); err != nil { + t.Fatal(err) + } + for _, i := range []domain.Issue{ + {ID: id + "-unassigned", ProjectID: id, Title: "Needs an owner"}, + {ID: id + "-assigned", ProjectID: id, Title: "Keep assignee", AssigneeUserID: 101}, + } { + if err := store.PutIssue(i); err != nil { + t.Fatal(err) + } + } + start := make(chan struct{}) + var workers sync.WaitGroup + for uid := int64(100); uid < 112; uid++ { + workers.Add(1) + go func(userID int64) { + defer workers.Done() + <-start + event := WelcomeMemberSignup + if userID <= 101 { + event = WelcomeAdminLogin + } + if err := store.EnrollWelcomeAccount(id, userID, event); err != nil { + t.Error(err) + } + }(uid) + } + close(start) + workers.Wait() + p, ok := store.Project(id) + if !ok || (p.OwnerID != 100 && p.OwnerID != 101) || len(p.Members) != 12 { + t.Fatalf("owner=%d members=%v", p.OwnerID, p.Members) + } + for _, m := range p.Members { + want := "member" + if m.UserID == 101 { + want = "viewer" + } + if m.UserID == p.OwnerID { + want = "maintainer" + } + if m.Role != want { + t.Fatalf("member %d: got %q, want %q", m.UserID, m.Role, want) + } + } + unassigned, _ := store.Issue(id + "-unassigned") + assigned, _ := store.Issue(id + "-assigned") + if unassigned.AssigneeUserID != p.OwnerID || assigned.AssigneeUserID != 101 { + t.Fatalf("assignees after claim: %d, %d", unassigned.AssigneeUserID, assigned.AssigneeUserID) + } +}