Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat: recovery cmd (#21182)
ecmadao69ad91fd80ed
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yamlindex 2f9d8ce261..73f1fcd2f4 100644--- a/backend/api/mcp/gen/openapi.yaml+++ b/backend/api/mcp/gen/openapi.yaml@@ -16979,7 +16979,7 @@ components:disallowPasswordSignin:type: booleantitle: disallow_password_signin- description: Whether password-based signin is disabled (except for workspace admins).+ description: Whether password sign-in is disabled for all end users.passwordRestriction:title: password_restrictiondescription: Password complexity and restriction requirements.@@ -21335,7 +21335,7 @@ components:disallowPasswordSignin:type: booleantitle: disallow_password_signin- description: Whether to disallow password signin. (Except workspace admins)+ description: Whether password sign-in is disabled for all end users.enableMetricCollection:type: booleantitle: enable_metric_collectiondiff --git a/backend/api/v1/auth_service.go b/backend/api/v1/auth_service.goindex da0a13885e..7e8f4db8b9 100644--- a/backend/api/v1/auth_service.go+++ b/backend/api/v1/auth_service.go@@ -1036,11 +1036,6 @@ func (s *AuthService) validateLoginPermissions(ctx context.Context, user *store.return connect.NewError(connect.CodeUnauthenticated, errors.Errorf("user has been deactivated by administrators"))}- isAdmin, err := isUserWorkspaceAdmin(ctx, s.store, user, workspaceID)- if err != nil {- return connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to check user roles"))- }-// Login restrictions only apply to end users.if user.Type != storepb.PrincipalType_END_USER {return nil@@ -1063,10 +1058,8 @@ func (s *AuthService) validateLoginPermissions(ctx context.Context, user *store.return err}if request.GetIdpName() == "" {- if request.Password != "" {- if restriction.DisallowPasswordSignin && !isAdmin {- return connect.NewError(connect.CodePermissionDenied, errors.Errorf("password signin is disallowed"))- }+ if request.Password != "" && restriction.DisallowPasswordSignin {+ return connect.NewError(connect.CodePermissionDenied, errors.Errorf("password signin is disallowed"))}if request.EmailCode != nil && *request.EmailCode != "" {if !restriction.AllowEmailCodeSignin {diff --git a/backend/api/v1/auth_service_test.go b/backend/api/v1/auth_service_test.goindex 45dabfe2fe..80d007fa1a 100644--- a/backend/api/v1/auth_service_test.go+++ b/backend/api/v1/auth_service_test.go@@ -160,31 +160,19 @@ func TestLoginEnforcesWorkspaceDomains(t *testing.T) {require.NoError(t, err)t.Run("workspace admin", func(t *testing.T) {- for _, test := range []struct {- name string- request *v1pb.LoginRequest- }{- {- name: "password login enforces domains",- request: &v1pb.LoginRequest{Email: blockedAdmin.Email, Password: "password"},- },- {- name: "SSO login enforces domains",- request: &v1pb.LoginRequest{Email: blockedAdmin.Email, IdpName: "idps/test"},- },- } {- t.Run(test.name, func(t *testing.T) {- err := service.validateLoginPermissions(ctx, blockedAdmin, workspaceID, test.request)- require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))- require.ErrorContains(t, err, "does not belong to allowed domains")- })- }+ err := service.validateLoginPermissions(ctx, blockedAdmin, workspaceID, &v1pb.LoginRequest{+ Email: blockedAdmin.Email,+ IdpName: "idps/test",+ })+ require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))+ require.ErrorContains(t, err, "does not belong to allowed domains")- err := service.validateLoginPermissions(ctx, allowedAdmin, workspaceID, &v1pb.LoginRequest{+ err = service.validateLoginPermissions(ctx, allowedAdmin, workspaceID, &v1pb.LoginRequest{Email: allowedAdmin.Email,Password: "password",})- require.NoError(t, err, "workspace admins remain exempt from disallow_password_signin")+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(err))+ require.ErrorContains(t, err, "password signin is disallowed")})t.Run("send code", func(t *testing.T) {diff --git a/backend/api/v1/user_service.go b/backend/api/v1/user_service.goindex 2c7c2d00a4..493df99ea1 100644--- a/backend/api/v1/user_service.go+++ b/backend/api/v1/user_service.go@@ -295,20 +295,8 @@ func (s *UserService) validatePassword(ctx context.Context, workspaceID, passwor}func validatePasswordWithRestriction(password string, passwordRestriction *storepb.WorkspaceProfileSetting_PasswordRestriction) error {- if len(password) < int(passwordRestriction.GetMinLength()) {- return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("password length should no less than %v characters", passwordRestriction.GetMinLength()))- }- if passwordRestriction.GetRequireNumber() && !regexp.MustCompile("[0-9]+").MatchString(password) {- return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("password must contains at least 1 number"))- }- if passwordRestriction.GetRequireLetter() && !regexp.MustCompile("[a-zA-Z]+").MatchString(password) {- return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("password must contains at least 1 lower case letter"))- }- if passwordRestriction.GetRequireUppercaseLetter() && !regexp.MustCompile("[A-Z]+").MatchString(password) {- return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("password must contains at least 1 upper case letter"))- }- if passwordRestriction.GetRequireSpecialCharacter() && !regexp.MustCompile(`[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]+`).MatchString(password) {- return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("password must contains at least 1 special character"))+ if err := common.ValidatePassword(password, passwordRestriction); err != nil {+ return connect.NewError(connect.CodeInvalidArgument, err)}return nil}diff --git a/backend/bin/server/cmd/profile.go b/backend/bin/server/cmd/profile.goindex aa065c2c8a..ea3b65a17d 100644--- a/backend/bin/server/cmd/profile.go+++ b/backend/bin/server/cmd/profile.go@@ -33,6 +33,13 @@ func getBaseProfile(dataDir string) *config.Profile {return config}+func resolveProfile() (*config.Profile, error) {+ if err := checkDataDir(); err != nil {+ return nil, err+ }+ return activeProfile(flags.dataDir), nil+}+func isDocker() bool {if _, err := os.Stat("/etc/bb.env"); err == nil {return truediff --git a/backend/bin/server/cmd/recovery.go b/backend/bin/server/cmd/recovery.gonew file mode 100644index 0000000000..482f383cf3--- /dev/null+++ b/backend/bin/server/cmd/recovery.go@@ -0,0 +1,535 @@+package cmd++import (+ "bufio"+ "bytes"+ "context"+ "fmt"+ "io"+ "os"+ "os/signal"+ "path/filepath"+ "strconv"+ "strings"+ "syscall"++ "github.com/pkg/errors"+ "github.com/spf13/cobra"+ "golang.org/x/term"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/component/recovery"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/resources/postgres"+ "github.com/bytebase/bytebase/backend/store"+)++type recoveryRunner interface {+ GetWorkspaceID(context.Context) (string, error)+ EnablePasswordSignin(context.Context, string) (*recovery.EnablePasswordSigninResult, error)+ GetPasswordRestriction(context.Context, string) (*storepb.WorkspaceProfileSetting_PasswordRestriction, error)+ ResetUserPassword(context.Context, recovery.ResetUserPasswordRequest) (*recovery.ResetUserPasswordResult, error)+ IsUserInWorkspace(context.Context, string, string) (bool, error)+ ListRoles(context.Context, string) ([]*recovery.Role, error)+ AddUserToWorkspace(context.Context, recovery.AddUserToWorkspaceRequest) (*recovery.AddUserToWorkspaceResult, error)+}++type recoveryBackend struct {+ runner recoveryRunner+ close func() error+}++type recoveryCommandDependencies struct {+ open func(context.Context) (*recoveryBackend, error)+ isTerminal func(io.Reader, io.Writer) bool+ readPassword func(io.Reader) ([]byte, error)+}++func init() {+ rootCmd.AddCommand(newRecoveryCommand(recoveryCommandDependencies{+ open: openRecoveryBackend,+ isTerminal: isRecoveryTerminal,+ readPassword: readRecoveryPassword,+ }))+}++func newRecoveryCommand(dependencies recoveryCommandDependencies) *cobra.Command {+ command := &cobra.Command{+ Use: "recovery",+ Short: "Recover password sign-in for a self-hosted deployment",+ Args: cobra.NoArgs,+ SilenceUsage: true,+ RunE: func(command *cobra.Command, _ []string) (retErr error) {+ input := command.InOrStdin()+ output := command.OutOrStdout()+ if !dependencies.isTerminal(input, output) {+ return errors.New("recovery requires terminal input and output")+ }+ fmt.Fprintln(output, "Stop all Bytebase servers that use this metadata database before continuing.")+ fmt.Fprintln(output, "Restart all Bytebase servers after recovery so they reload updated settings and IAM policies.")++ ctx, stop := signal.NotifyContext(command.Context(), os.Interrupt, syscall.SIGTERM)+ defer stop()+ backend, err := dependencies.open(ctx)+ if err != nil {+ return errors.Wrap(err, "failed to open recovery metadata store")+ }+ defer func() {+ if err := backend.close(); err != nil && retErr == nil {+ retErr = errors.Wrap(err, "failed to close recovery metadata store")+ }+ }()++ workspaceID, err := backend.runner.GetWorkspaceID(ctx)+ if err != nil {+ return errors.Wrap(err, "failed to find the recovery workspace")+ }+ if workspaceID == "" {+ return errors.New("no active workspace was found in the metadata database")+ }+ return runRecoverySession(ctx, workspaceID, input, output, backend.runner, dependencies.readPassword)+ },+ }+ return command+}++func openRecoveryBackend(ctx context.Context) (*recoveryBackend, error) {+ profile, err := resolveProfile()+ if err != nil {+ return nil, err+ }+ if !profile.UseEmbedDB() {+ stores, err := store.New(ctx, profile.PgURL, false)+ if err != nil {+ return nil, errors.Wrap(err, "failed to connect to external metadata database")+ }+ return newRecoveryBackend(stores, nil), nil+ }++ pgURL := fmt.Sprintf("host=%s port=%d user=bb database=bb", common.GetPostgresSocketDir(), profile.DatastorePort)+ if stores, err := store.New(ctx, pgURL, false); err == nil {+ return newRecoveryBackend(stores, nil), nil+ }++ pgDataDir := filepath.Join(profile.DataDir, "pgdata")+ if _, err := os.Stat(filepath.Join(pgDataDir, "PG_VERSION")); err != nil {+ if os.IsNotExist(err) {+ return nil, errors.Errorf("embedded metadata database is not initialized at %q", pgDataDir)+ }+ return nil, errors.Wrap(err, "failed to inspect embedded metadata database")+ }+ stopEmbeddedPostgres, err := postgres.StartMetadataInstance(ctx, pgDataDir, profile.DatastorePort, profile.Mode)+ if err != nil {+ return nil, errors.Wrap(err, "failed to start embedded metadata database")+ }+ stores, err := store.New(ctx, pgURL, false)+ if err != nil {+ stopEmbeddedPostgres()+ return nil, errors.Wrap(err, "failed to connect to embedded metadata database")+ }+ return newRecoveryBackend(stores, stopEmbeddedPostgres), nil+}++func newRecoveryBackend(stores *store.Store, stopEmbeddedPostgres func()) *recoveryBackend {+ return &recoveryBackend{+ runner: recovery.NewService(stores),+ close: func() error {+ err := stores.Close()+ if stopEmbeddedPostgres != nil {+ stopEmbeddedPostgres()+ }+ return err+ },+ }+}++func runRecoverySession(+ ctx context.Context,+ workspaceID string,+ input io.Reader,+ output io.Writer,+ runner recoveryRunner,+ readPassword func(io.Reader) ([]byte, error),+) error {+ reader := bufio.NewReader(input)+ for {+ if ctx.Err() != nil {+ return recoverySessionResult(ctx.Err())+ }+ fmt.Fprintln(output, "\nSelect a recovery action:")+ fmt.Fprintln(output, "1. Enable password sign-in")+ fmt.Fprintln(output, "2. Reset user password")+ selection, err := readRecoveryLine(ctx, reader, output, "q. Exit\n> ")+ if err != nil {+ if ctx.Err() != nil {+ return recoverySessionResult(ctx.Err())+ }+ if errors.Is(err, io.EOF) {+ return recoverySessionResult(err)+ }+ return errors.Wrap(err, "failed to read recovery action")+ }++ var actionErr error+ switch strings.ToLower(selection) {+ case "1":+ actionErr = runEnablePasswordSignin(ctx, workspaceID, reader, output, runner)+ case "2":+ actionErr = runResetUserPassword(ctx, workspaceID, input, reader, output, runner, readPassword)+ case "q", "quit", "exit":+ return nil+ default:+ fmt.Fprintln(output, "Invalid selection. Choose 1, 2, or q.")+ continue+ }+ if actionErr != nil {+ if ctx.Err() != nil {+ return recoverySessionResult(ctx.Err())+ }+ if errors.Is(actionErr, io.EOF) {+ return recoverySessionResult(actionErr)+ }+ return actionErr+ }+ }+}++func runEnablePasswordSignin(+ ctx context.Context,+ workspaceID string,+ reader *bufio.Reader,+ output io.Writer,+ runner recoveryRunner,+) error {+ confirmation, err := readRecoveryLine(+ ctx,+ reader,+ output,+ "Enable password sign-in? [y/N] ",+ )+ if err != nil {+ return err+ }+ if !strings.EqualFold(confirmation, "y") && !strings.EqualFold(confirmation, "yes") {+ fmt.Fprintln(output, "Enable password sign-in cancelled.")+ return nil+ }++ fmt.Fprintln(output, "Enabling password sign-in...")+ _, err = runner.EnablePasswordSignin(ctx, workspaceID)+ if err != nil {+ fmt.Fprintf(output, "Failed to enable password sign-in: %v\n", err)+ return nil+ }+ fmt.Fprintln(output, "Password sign-in is enabled.")+ fmt.Fprintln(output, "Restart all Bytebase servers after exiting recovery.")+ fmt.Fprintln(output, "After restarting, sign in at /auth with an existing user account.")+ fmt.Fprintln(output, "After repairing SSO, re-enable Disallow password sign-in.")+ return nil+}++func runResetUserPassword(+ ctx context.Context,+ workspaceID string,+ input io.Reader,+ reader *bufio.Reader,+ output io.Writer,+ runner recoveryRunner,+ readPassword func(io.Reader) ([]byte, error),+) error {+ email, err := readRecoveryLine(ctx, reader, output, "User email (blank to cancel): ")+ if err != nil {+ return err+ }+ if email == "" {+ fmt.Fprintln(output, "Reset user password cancelled.")+ return nil+ }+ restriction, err := runner.GetPasswordRestriction(ctx, workspaceID)+ if err != nil {+ fmt.Fprintf(output, "Failed to get workspace password restriction: %v\n", err)+ return nil+ }+ printPasswordRestriction(output, restriction)++ for {+ fmt.Fprint(output, "New password: ")+ password, err := readPassword(input)+ fmt.Fprintln(output)+ if err != nil {+ clearBytes(password)+ return errors.Wrap(err, "failed to read password")+ }+ if err := common.ValidatePassword(string(password), restriction); err != nil {+ clearBytes(password)+ fmt.Fprintf(output, "Password does not satisfy the workspace restriction: %v. Try again.\n", err)+ continue+ }+ fmt.Fprint(output, "Confirm new password: ")+ confirmation, err := readPassword(input)+ fmt.Fprintln(output)+ if err != nil {+ clearBytes(password)+ clearBytes(confirmation)+ return errors.Wrap(err, "failed to confirm password")+ }+ if !bytes.Equal(password, confirmation) {+ clearBytes(password)+ clearBytes(confirmation)+ fmt.Fprintln(output, "Passwords do not match. Try again.")+ continue+ }++ clearBytes(confirmation)+ actionErr := resetUserPassword(ctx, workspaceID, email, password, reader, output, runner)+ clearBytes(password)+ return actionErr+ }+}++func resetUserPassword(+ ctx context.Context,+ workspaceID string,+ email string,+ password []byte,+ reader *bufio.Reader,+ output io.Writer,+ runner recoveryRunner,+) error {+ fmt.Fprintln(output, "Resetting user password...")+ result, resetErr := runner.ResetUserPassword(ctx, recovery.ResetUserPasswordRequest{+ WorkspaceID: workspaceID,+ Email: email,+ Password: password,+ })+ clearBytes(password)+ if result == nil {+ fmt.Fprintf(output, "Failed to reset user password: %v\n", resetErr)+ return nil+ }+ printPasswordResetSuccess(output, result.Email)+ if resetErr != nil {+ fmt.Fprintf(output, "Warning: %v\n", resetErr)+ }++ member, err := runner.IsUserInWorkspace(ctx, workspaceID, result.Email)+ if err != nil {+ fmt.Fprintf(output, "Failed to check workspace membership: %v\n", err)+ return nil+ }+ if member {+ return nil+ }++ fmt.Fprintf(output, "User %s is not a member of this Bytebase workspace.\n", result.Email)+ confirmation, err := readRecoveryLine(ctx, reader, output, "Add this user to the workspace? [y/N] ")+ if err != nil {+ return err+ }+ if !isRecoveryConfirmed(confirmation) {+ fmt.Fprintln(output, "Add user to workspace cancelled.")+ return nil+ }++ roles, err := runner.ListRoles(ctx, workspaceID)+ if err != nil {+ fmt.Fprintf(output, "Failed to list workspace roles: %v\n", err)+ return nil+ }+ role, cancelled, err := selectRecoveryRole(ctx, reader, output, roles)+ if err != nil {+ return err+ }+ if cancelled {+ fmt.Fprintln(output, "Add user to workspace cancelled.")+ return nil+ }++ confirmation, err = readRecoveryLine(+ ctx,+ reader,+ output,+ fmt.Sprintf(+ "Add %s as %s (%s)? [y/N] ",+ result.Email,+ role.Title,+ role.Name,+ ),+ )+ if err != nil {+ return err+ }+ if !isRecoveryConfirmed(confirmation) {+ fmt.Fprintln(output, "Add user to workspace cancelled.")+ return nil+ }++ fmt.Fprintln(output, "Adding user to workspace...")+ addResult, addErr := runner.AddUserToWorkspace(ctx, recovery.AddUserToWorkspaceRequest{+ WorkspaceID: workspaceID,+ Email: result.Email,+ Role: role.Name,+ })+ if addErr != nil {+ if addResult != nil && addResult.Changed {+ fmt.Fprintf(+ output,+ "User %s was added as %s (%s), but recovery did not complete: %v\n",+ result.Email,+ role.Title,+ role.Name,+ addErr,+ )+ } else {+ fmt.Fprintf(output, "Failed to add user to workspace: %v\n", addErr)+ }+ return nil+ }++ fmt.Fprintf(+ output,+ "User %s was added as %s (%s).\n",+ result.Email,+ role.Title,+ role.Name,+ )+ fmt.Fprintln(output, "Restart all Bytebase servers after exiting recovery so they reload the updated IAM policy.")+ return nil+}++func printPasswordRestriction(output io.Writer, restriction *storepb.WorkspaceProfileSetting_PasswordRestriction) {+ fmt.Fprintln(output, "Password requirements:")+ hasRequirement := false+ if restriction.GetMinLength() > 0 {+ fmt.Fprintf(output, "- Minimum length: %d characters\n", restriction.GetMinLength())+ hasRequirement = true+ }+ if restriction.GetRequireNumber() {+ fmt.Fprintln(output, "- At least one number")+ hasRequirement = true+ }+ if restriction.GetRequireLetter() {+ fmt.Fprintln(output, "- At least one letter")+ hasRequirement = true+ }+ if restriction.GetRequireUppercaseLetter() {+ fmt.Fprintln(output, "- At least one uppercase letter")+ hasRequirement = true+ }+ if restriction.GetRequireSpecialCharacter() {+ fmt.Fprintln(output, "- At least one special character")+ hasRequirement = true+ }+ if !hasRequirement {+ fmt.Fprintln(output, "- None")+ }+}++func selectRecoveryRole(ctx context.Context, reader *bufio.Reader, output io.Writer, roles []*recovery.Role) (*recovery.Role, bool, error) {+ if len(roles) == 0 {+ fmt.Fprintln(output, "No roles are available in this workspace.")+ return nil, true, nil+ }+ fmt.Fprintln(output, "Select a role:")+ for i, role := range roles {+ fmt.Fprintf(output, "%d. %s (%s)\n", i+1, role.Title, role.Name)+ }+ for {+ selection, err := readRecoveryLine(ctx, reader, output, "q. Cancel\n> ")+ if err != nil {+ return nil, false, err+ }+ if strings.EqualFold(selection, "q") || strings.EqualFold(selection, "quit") || strings.EqualFold(selection, "exit") {+ return nil, true, nil+ }+ index, err := strconv.Atoi(selection)+ if err == nil && index >= 1 && index <= len(roles) {+ return roles[index-1], false, nil+ }+ fmt.Fprintf(output, "Invalid role selection. Choose 1-%d or q.\n", len(roles))+ }+}++func printPasswordResetSuccess(output io.Writer, email string) {+ fmt.Fprintf(output, "Password updated for user %s.\n", email)+}++func isRecoveryConfirmed(value string) bool {+ return strings.EqualFold(value, "y") || strings.EqualFold(value, "yes")+}++type recoveryLineResult struct {+ line string+ err error+}++func readRecoveryLine(ctx context.Context, reader *bufio.Reader, output io.Writer, prompt string) (string, error) {+ fmt.Fprint(output, prompt)+ if err := ctx.Err(); err != nil {+ return "", err+ }+ result := make(chan recoveryLineResult, 1)+ go func() {+ line, err := reader.ReadString('\n')+ result <- recoveryLineResult{line: line, err: err}+ }()+ select {+ case <-ctx.Done():+ return "", ctx.Err()+ case result := <-result:+ if result.err != nil && (!errors.Is(result.err, io.EOF) || len(result.line) == 0) {+ return "", result.err+ }+ return strings.TrimSpace(result.line), nil+ }+}++func recoverySessionResult(err error) error {+ if errors.Is(err, io.EOF) || errors.Is(err, context.Canceled) {+ return nil+ }+ return err+}++func isRecoveryTerminal(input io.Reader, output io.Writer) bool {+ inputFile, inputOK := input.(*os.File)+ outputFile, outputOK := output.(*os.File)+ return inputOK && outputOK && term.IsTerminal(int(inputFile.Fd())) && term.IsTerminal(int(outputFile.Fd()))+}++func readRecoveryPassword(input io.Reader) (password []byte, retErr error) {+ inputFile, ok := input.(*os.File)+ if !ok {+ return nil, errors.New("password input is not a terminal")+ }+ fd := int(inputFile.Fd())+ state, err := term.MakeRaw(fd)+ if err != nil {+ return nil, errors.Wrap(err, "failed to enter raw terminal mode")+ }+ defer func() {+ if err := term.Restore(fd, state); err != nil && retErr == nil {+ retErr = errors.Wrap(err, "failed to restore terminal state")+ }+ }()++ terminal := struct {+ io.Reader+ io.Writer+ }{+ Reader: inputFile,+ Writer: io.Discard,+ }+ return readRecoveryPasswordInput(terminal)+}++func readRecoveryPasswordInput(input io.ReadWriter) ([]byte, error) {+ password, err := term.NewTerminal(input, "").ReadPassword("")+ return []byte(password), err+}++func clearBytes(value []byte) {+ for i := range value {+ value[i] = 0+ }+}diff --git a/backend/bin/server/cmd/recovery_test.go b/backend/bin/server/cmd/recovery_test.gonew file mode 100644index 0000000000..34a2fbb03e--- /dev/null+++ b/backend/bin/server/cmd/recovery_test.go@@ -0,0 +1,633 @@+package cmd++import (+ "bytes"+ "context"+ "io"+ "os"+ "path/filepath"+ "strings"+ "testing"+ "time"++ "github.com/pkg/errors"+ "github.com/spf13/cobra"+ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/component/recovery"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+)++func TestResolveProfileUsesServerDataConfiguration(t *testing.T) {+ originalFlags := flags+ originalArgs := os.Args+ t.Cleanup(func() {+ flags = originalFlags+ os.Args = originalArgs+ })++ binDir := t.TempDir()+ dataDir := filepath.Join(binDir, "metadata")+ require.NoError(t, os.Mkdir(dataDir, 0o700))+ os.Args = []string{filepath.Join(binDir, "bytebase")}+ flags.dataDir = "metadata"+ flags.port = 9090+ flags.ha = true+ t.Setenv("PG_URL", "postgres://bytebase.example/metadata")++ profile, err := resolveProfile()++ require.NoError(t, err)+ require.Equal(t, dataDir, profile.DataDir)+ require.Equal(t, dataDir, flags.dataDir)+ require.Equal(t, 9090, profile.Port)+ require.Equal(t, 9092, profile.DatastorePort)+ require.True(t, profile.HA)+ require.Equal(t, "postgres://bytebase.example/metadata", profile.PgURL)+}++func TestReadRecoveryPasswordInputInterrupt(t *testing.T) {+ terminal := struct {+ io.Reader+ io.Writer+ }{+ Reader: bytes.NewReader([]byte{3}),+ Writer: io.Discard,+ }++ password, err := readRecoveryPasswordInput(terminal)++ require.ErrorIs(t, err, io.EOF)+ require.Empty(t, password)+}++type blockingRecoveryReader struct {+ started chan struct{}+ release chan struct{}+}++func (r *blockingRecoveryReader) Read([]byte) (int, error) {+ close(r.started)+ <-r.release+ return 0, io.EOF+}++type fakeRecoveryRunner struct {+ workspaceID string+ workspaceErr error+ noWorkspace bool+ enableWorkspaces []string+ resetRequests []recovery.ResetUserPasswordRequest+ listWorkspaces []string+ addRequests []recovery.AddUserToWorkspaceRequest+ roles []*recovery.Role+ enableErr error+ resetResult *recovery.ResetUserPasswordResult+ resetErr error+ resetErrs []error+ listErr error+ addErr error+ passwordRestriction *storepb.WorkspaceProfileSetting_PasswordRestriction+ passwordRestrictionErr error+ restrictionWorkspaces []string+ notInWorkspace bool+ membershipErr error+ membershipChecks []string+}++func (f *fakeRecoveryRunner) GetWorkspaceID(context.Context) (string, error) {+ if f.workspaceErr != nil {+ return "", f.workspaceErr+ }+ if f.noWorkspace {+ return "", nil+ }+ if f.workspaceID == "" {+ return "acme", nil+ }+ return f.workspaceID, nil+}++func (f *fakeRecoveryRunner) EnablePasswordSignin(_ context.Context, workspaceID string) (*recovery.EnablePasswordSigninResult, error) {+ f.enableWorkspaces = append(f.enableWorkspaces, workspaceID)+ if f.enableErr != nil {+ return nil, f.enableErr+ }+ return &recovery.EnablePasswordSigninResult{WorkspaceID: workspaceID}, nil+}++func (f *fakeRecoveryRunner) GetPasswordRestriction(_ context.Context, workspaceID string) (*storepb.WorkspaceProfileSetting_PasswordRestriction, error) {+ f.restrictionWorkspaces = append(f.restrictionWorkspaces, workspaceID)+ if f.passwordRestrictionErr != nil {+ return nil, f.passwordRestrictionErr+ }+ if f.passwordRestriction == nil {+ return &storepb.WorkspaceProfileSetting_PasswordRestriction{MinLength: 8}, nil+ }+ return f.passwordRestriction, nil+}++func (f *fakeRecoveryRunner) IsUserInWorkspace(_ context.Context, workspaceID, email string) (bool, error) {+ f.membershipChecks = append(f.membershipChecks, workspaceID+":"+email)+ if f.membershipErr != nil {+ return false, f.membershipErr+ }+ return !f.notInWorkspace, nil+}++func (f *fakeRecoveryRunner) ResetUserPassword(_ context.Context, request recovery.ResetUserPasswordRequest) (*recovery.ResetUserPasswordResult, error) {+ f.resetRequests = append(f.resetRequests, recovery.ResetUserPasswordRequest{+ WorkspaceID: request.WorkspaceID,+ Email: request.Email,+ Password: bytes.Clone(request.Password),+ })+ requestIndex := len(f.resetRequests) - 1+ if requestIndex < len(f.resetErrs) && f.resetErrs[requestIndex] != nil {+ return nil, f.resetErrs[requestIndex]+ }+ if f.resetErr != nil {+ return f.resetResult, f.resetErr+ }+ if f.resetResult != nil {+ return f.resetResult, nil+ }+ return &recovery.ResetUserPasswordResult{WorkspaceID: request.WorkspaceID, Email: request.Email}, nil+}++func (f *fakeRecoveryRunner) ListRoles(_ context.Context, workspaceID string) ([]*recovery.Role, error) {+ f.listWorkspaces = append(f.listWorkspaces, workspaceID)+ if f.listErr != nil {+ return nil, f.listErr+ }+ return f.roles, nil+}++func (f *fakeRecoveryRunner) AddUserToWorkspace(_ context.Context, request recovery.AddUserToWorkspaceRequest) (*recovery.AddUserToWorkspaceResult, error) {+ f.addRequests = append(f.addRequests, request)+ if f.addErr != nil {+ return nil, f.addErr+ }+ return &recovery.AddUserToWorkspaceResult{+ WorkspaceID: request.WorkspaceID,+ Email: request.Email,+ Role: request.Role,+ Changed: true,+ }, nil+}++func TestRecoveryCommandContract(t *testing.T) {+ t.Run("help exposes no workspace or action inputs", func(t *testing.T) {+ command, output, _, _ := newTestRecoveryCommand(t, &fakeRecoveryRunner{}, "", nil)+ command.SetArgs([]string{"--help"})++ require.NoError(t, command.Execute())+ require.NotContains(t, output.String(), "--workspace")+ require.NotContains(t, output.String(), "--email")+ require.NotContains(t, output.String(), "--password")+ require.NotContains(t, output.String(), "--yes")+ require.Empty(t, command.Commands())+ })++ t.Run("rejects a non-terminal before opening metadata", func(t *testing.T) {+ openCount := 0+ command := newRecoveryCommand(recoveryCommandDependencies{+ open: func(context.Context) (*recoveryBackend, error) {+ openCount+++ return nil, nil+ },+ isTerminal: func(io.Reader, io.Writer) bool { return false },+ })+ command.SetArgs(nil)+ command.SilenceUsage = true+ command.SilenceErrors = true++ err := command.Execute()++ require.ErrorContains(t, err, "terminal input and output")+ require.Zero(t, openCount)+ })++ t.Run("opens and closes metadata once for the session", func(t *testing.T) {+ command, output, openCount, closeCount := newTestRecoveryCommand(t, &fakeRecoveryRunner{}, "", nil)++ require.NoError(t, command.Execute())+ require.Equal(t, 1, *openCount)+ require.Equal(t, 1, *closeCount)+ require.Contains(t, output.String(), "Stop all Bytebase servers that use this metadata database before continuing.")+ require.Contains(t, output.String(), "Restart all Bytebase servers after recovery")+ })++ t.Run("rejects metadata with multiple workspaces", func(t *testing.T) {+ runner := &fakeRecoveryRunner{workspaceErr: errors.New("multiple workspaces were found")}+ command, _, openCount, closeCount := newTestRecoveryCommand(t, runner, "q\n", nil)++ err := command.Execute()++ require.ErrorContains(t, err, "multiple workspaces")+ require.Equal(t, 1, *openCount)+ require.Equal(t, 1, *closeCount)+ })++ t.Run("rejects metadata without an active workspace", func(t *testing.T) {+ runner := &fakeRecoveryRunner{noWorkspace: true}+ command, _, openCount, closeCount := newTestRecoveryCommand(t, runner, "q\n", nil)++ err := command.Execute()++ require.ErrorContains(t, err, "no active workspace")+ require.Equal(t, 1, *openCount)+ require.Equal(t, 1, *closeCount)+ })++ t.Run("invalid selection returns to the menu", func(t *testing.T) {+ command, output, _, _ := newTestRecoveryCommand(t, &fakeRecoveryRunner{}, "invalid\nq\n", nil)++ require.NoError(t, command.Execute())+ require.Contains(t, output.String(), "Invalid selection")+ require.Equal(t, 2, strings.Count(output.String(), "Select a recovery action:"))+ })++ t.Run("cancelled enable does not call the service", func(t *testing.T) {+ runner := &fakeRecoveryRunner{}+ command, _, _, _ := newTestRecoveryCommand(t, runner, "1\nn\nq\n", nil)++ require.NoError(t, command.Execute())+ require.Empty(t, runner.enableWorkspaces)+ })++ t.Run("enable reports progress and returns to the menu", func(t *testing.T) {+ runner := &fakeRecoveryRunner{workspaceID: "resolved-workspace"}+ command, output, _, _ := newTestRecoveryCommand(t, runner, "1\ny\nq\n", nil)++ require.NoError(t, command.Execute())+ require.Equal(t, []string{"resolved-workspace"}, runner.enableWorkspaces)+ require.Contains(t, output.String(), "Enabling password sign-in...")+ require.Contains(t, output.String(), "Password sign-in is enabled.")+ require.NotContains(t, output.String(), "resolved-workspace")+ require.Contains(t, output.String(), "Restart all Bytebase servers after exiting recovery.")+ require.Contains(t, output.String(), "After restarting, sign in at /auth with an existing user account.")+ require.NotContains(t, output.String(), "existing administrator account")+ require.Less(t, strings.Index(output.String(), "Restart all Bytebase servers"), strings.Index(output.String(), "After restarting, sign in at /auth"))+ require.Equal(t, 2, strings.Count(output.String(), "Select a recovery action:"))+ })++ t.Run("enable failure is actionable and returns to the menu", func(t *testing.T) {+ runner := &fakeRecoveryRunner{enableErr: errors.New("no usable workspace administrator")}+ command, output, _, _ := newTestRecoveryCommand(t, runner, "1\ny\nq\n", nil)++ require.NoError(t, command.Execute())+ require.Contains(t, output.String(), "no usable workspace administrator")+ require.Equal(t, 2, strings.Count(output.String(), "Select a recovery action:"))+ })++ t.Run("blank reset email returns to the menu", func(t *testing.T) {+ runner := &fakeRecoveryRunner{}+ command, _, _, _ := newTestRecoveryCommand(t, runner, "2\n\nq\n", nil)++ require.NoError(t, command.Execute())+ require.Empty(t, runner.resetRequests)+ require.Empty(t, runner.restrictionWorkspaces)+ })++ t.Run("password mismatch re-prompts without calling the service", func(t *testing.T) {+ runner := &fakeRecoveryRunner{}+ passwords := [][]byte{[]byte("FirstPassword1!"), []byte("DifferentPassword1!")}+ readCount := 0+ stop := errors.New("stop after mismatch")+ command, output, _, _ := newTestRecoveryCommand(t, runner, "2\[email protected]\n", func(io.Reader) ([]byte, error) {+ if readCount == len(passwords) {+ return nil, stop+ }+ password := passwords[readCount]+ readCount+++ return password, nil+ })++ err := command.Execute()++ require.ErrorIs(t, err, stop)+ require.Empty(t, runner.resetRequests)+ require.Equal(t, 2, readCount)+ require.Contains(t, output.String(), "Passwords do not match")+ })++ for _, tc := range []struct {+ name string+ readPassword func(io.Reader) ([]byte, error)+ wantReadCount int+ }{+ {+ name: "interrupt at new password exits the session",+ readPassword: func(io.Reader) ([]byte, error) {+ return nil, io.EOF+ },+ wantReadCount: 1,+ },+ {+ name: "interrupt at confirmation exits the session",+ readPassword: func() func(io.Reader) ([]byte, error) {+ readCount := 0+ return func(io.Reader) ([]byte, error) {+ readCount+++ if readCount == 1 {+ return []byte("NewPassword1!"), nil+ }+ return nil, io.EOF+ }+ }(),+ wantReadCount: 2,+ },+ } {+ t.Run(tc.name, func(t *testing.T) {+ readCount := 0+ runner := &fakeRecoveryRunner{}+ command, _, _, closeCount := newTestRecoveryCommand(t, runner, "2\[email protected]\n", func(input io.Reader) ([]byte, error) {+ readCount+++ return tc.readPassword(input)+ })++ require.NoError(t, command.Execute())+ require.Empty(t, runner.resetRequests)+ require.Equal(t, tc.wantReadCount, readCount)+ require.Equal(t, 1, *closeCount)+ })+ }++ t.Run("prints the restriction and re-prompts after password validation fails", func(t *testing.T) {+ runner := &fakeRecoveryRunner{passwordRestriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{+ MinLength: 12,+ RequireNumber: true,+ RequireLetter: true,+ RequireUppercaseLetter: true,+ RequireSpecialCharacter: true,+ }}+ passwords := [][]byte{+ []byte("too-short"),+ []byte("NewPassword1!"), []byte("NewPassword1!"),+ }+ readCount := 0+ command, output, _, _ := newTestRecoveryCommand(t, runner, "2\[email protected]\nq\n", func(io.Reader) ([]byte, error) {+ if readCount == len(passwords) {+ return nil, errors.New("unexpected extra password prompt")+ }+ password := passwords[readCount]+ readCount+++ return password, nil+ })++ require.NoError(t, command.Execute())+ require.Len(t, runner.resetRequests, 1)+ require.Equal(t, []byte("NewPassword1!"), runner.resetRequests[0].Password)+ require.Contains(t, output.String(), "Password requirements:")+ require.Contains(t, output.String(), "Minimum length: 12 characters")+ require.Contains(t, output.String(), "At least one number")+ require.Contains(t, output.String(), "At least one letter")+ require.Contains(t, output.String(), "At least one uppercase letter")+ require.Contains(t, output.String(), "At least one special character")+ require.Contains(t, output.String(), "password length should no less than 12 characters")+ require.Less(t, strings.Index(output.String(), "User email"), strings.Index(output.String(), "Password requirements:"))+ require.Less(t, strings.Index(output.String(), "password length should no less than 12 characters"), strings.Index(output.String(), "Confirm new password:"))+ require.Equal(t, 1, strings.Count(output.String(), "Confirm new password:"))+ require.Equal(t, []string{"acme"}, runner.restrictionWorkspaces)+ require.Equal(t, 3, readCount)+ })++ t.Run("reset passes the email and password without exposing the secret", func(t *testing.T) {+ runner := &fakeRecoveryRunner{}+ firstPassword := []byte("NewPassword1!")+ secondPassword := []byte("NewPassword1!")+ passwords := [][]byte{firstPassword, secondPassword}+ readCount := 0+ command, output, _, _ := newTestRecoveryCommand(t, runner, "2\[email protected]\nq\n", func(io.Reader) ([]byte, error) {+ password := passwords[readCount]+ readCount+++ return password, nil+ })++ require.NoError(t, command.Execute())+ require.Len(t, runner.resetRequests, 1)+ require.Equal(t, "acme", runner.resetRequests[0].WorkspaceID)+ require.Equal(t, "[email protected]", runner.resetRequests[0].Email)+ require.Equal(t, []byte("NewPassword1!"), runner.resetRequests[0].Password)+ require.Equal(t, make([]byte, len(firstPassword)), firstPassword)+ require.Equal(t, make([]byte, len(secondPassword)), secondPassword)+ require.Contains(t, output.String(), "Resetting user password...")+ require.Contains(t, output.String(), "Password updated for user [email protected].")+ require.NotContains(t, output.String(), "NewPassword1!")+ })++ t.Run("missing member can decline the IAM grant", func(t *testing.T) {+ runner := &fakeRecoveryRunner{notInWorkspace: true}+ firstPassword := []byte("NewPassword1!")+ secondPassword := []byte("NewPassword1!")+ passwords := [][]byte{firstPassword, secondPassword}+ readCount := 0+ command, output, _, _ := newTestRecoveryCommand(t, runner, "2\[email protected]\nn\nq\n", func(io.Reader) ([]byte, error) {+ password := passwords[readCount]+ readCount+++ return password, nil+ })++ require.NoError(t, command.Execute())+ require.Len(t, runner.resetRequests, 1)+ require.Equal(t, []string{"acme:[email protected]"}, runner.membershipChecks)+ require.Empty(t, runner.listWorkspaces)+ require.Empty(t, runner.addRequests)+ require.Contains(t, output.String(), "User [email protected] is not a member of this Bytebase workspace.")+ require.Contains(t, output.String(), "Add this user to the workspace? [y/N]")+ require.Contains(t, output.String(), "Password updated for user [email protected].")+ require.Equal(t, make([]byte, len(firstPassword)), firstPassword)+ require.Equal(t, make([]byte, len(secondPassword)), secondPassword)+ })++ t.Run("missing member selects a role after the reset", func(t *testing.T) {+ runner := &fakeRecoveryRunner{+ notInWorkspace: true,+ roles: []*recovery.Role{+ {Name: "roles/workspaceAdmin", Title: "Workspace admin"},+ {Name: "roles/workspaceMember", Title: "Workspace member"},+ },+ }+ firstPassword := []byte("NewPassword1!")+ secondPassword := []byte("NewPassword1!")+ passwords := [][]byte{firstPassword, secondPassword}+ readCount := 0+ command, output, _, _ := newTestRecoveryCommand(t, runner, "2\[email protected]\ny\n9\n1\ny\nq\n", func(io.Reader) ([]byte, error) {+ password := passwords[readCount]+ readCount+++ return password, nil+ })++ require.NoError(t, command.Execute())+ require.Equal(t, []string{"acme"}, runner.listWorkspaces)+ require.Equal(t, []recovery.AddUserToWorkspaceRequest{{+ WorkspaceID: "acme",+ Email: "[email protected]",+ Role: "roles/workspaceAdmin",+ }}, runner.addRequests)+ require.Len(t, runner.resetRequests, 1)+ require.Equal(t, []byte("NewPassword1!"), runner.resetRequests[0].Password)+ require.Contains(t, output.String(), "1. Workspace admin (roles/workspaceAdmin)")+ require.Contains(t, output.String(), "Invalid role selection")+ require.Contains(t, output.String(), "Add [email protected] as Workspace admin (roles/workspaceAdmin)? [y/N]")+ require.Contains(t, output.String(), "Adding user to workspace...")+ require.Contains(t, output.String(), "Restart all Bytebase servers after exiting recovery so they reload the updated IAM policy.")+ require.Contains(t, output.String(), "Password updated for user [email protected].")+ require.NotContains(t, output.String(), "NewPassword1!")+ require.Equal(t, make([]byte, len(firstPassword)), firstPassword)+ require.Equal(t, make([]byte, len(secondPassword)), secondPassword)+ })++ t.Run("grant failure does not retry the reset", func(t *testing.T) {+ runner := &fakeRecoveryRunner{+ notInWorkspace: true,+ roles: []*recovery.Role{{Name: "roles/workspaceMember", Title: "Workspace member"}},+ addErr: errors.New("IAM write failed"),+ }+ passwords := [][]byte{[]byte("NewPassword1!"), []byte("NewPassword1!")}+ readCount := 0+ command, output, _, _ := newTestRecoveryCommand(t, runner, "2\[email protected]\ny\n1\ny\nq\n", func(io.Reader) ([]byte, error) {+ password := passwords[readCount]+ readCount+++ return password, nil+ })++ require.NoError(t, command.Execute())+ require.Len(t, runner.addRequests, 1)+ require.Len(t, runner.resetRequests, 1)+ require.Contains(t, output.String(), "Failed to add user to workspace: IAM write failed")+ })++ t.Run("audit failure preserves the reset and continues membership recovery", func(t *testing.T) {+ runner := &fakeRecoveryRunner{+ resetResult: &recovery.ResetUserPasswordResult{+ WorkspaceID: "acme",+ Email: "[email protected]",+ Changed: true,+ },+ resetErr: errors.New("user password reset completed, but failed to create the recovery audit log: audit write failed"),+ notInWorkspace: true,+ roles: []*recovery.Role{{Name: "roles/workspaceMember", Title: "Workspace member"}},+ }+ passwords := [][]byte{[]byte("NewPassword1!"), []byte("NewPassword1!")}+ readCount := 0+ command, output, _, _ := newTestRecoveryCommand(t, runner, "2\[email protected]\ny\n1\ny\nq\n", func(io.Reader) ([]byte, error) {+ password := passwords[readCount]+ readCount+++ return password, nil+ })++ require.NoError(t, command.Execute())+ require.Equal(t, []string{"acme:[email protected]"}, runner.membershipChecks)+ require.Len(t, runner.addRequests, 1)+ require.Contains(t, output.String(), "Password updated for user [email protected].")+ require.Contains(t, output.String(), "Warning: user password reset completed, but failed to create the recovery audit log: audit write failed")+ })++ t.Run("membership check failure reports the persisted password reset", func(t *testing.T) {+ runner := &fakeRecoveryRunner{+ membershipErr: errors.New("membership read failed"),+ }+ passwords := [][]byte{[]byte("NewPassword1!"), []byte("NewPassword1!")}+ readCount := 0+ command, output, _, _ := newTestRecoveryCommand(t, runner, "2\[email protected]\nq\n", func(io.Reader) ([]byte, error) {+ password := passwords[readCount]+ readCount+++ return password, nil+ })++ require.NoError(t, command.Execute())+ require.Len(t, runner.resetRequests, 1)+ require.Empty(t, runner.addRequests)+ require.Contains(t, output.String(), "Password updated for user [email protected].")+ require.Contains(t, output.String(), "Failed to check workspace membership: membership read failed")+ })++ t.Run("multiple actions reuse the session", func(t *testing.T) {+ runner := &fakeRecoveryRunner{}+ passwords := [][]byte{[]byte("NewPassword1!"), []byte("NewPassword1!")}+ readCount := 0+ command, _, openCount, closeCount := newTestRecoveryCommand(t, runner, "1\ny\n2\[email protected]\nq\n", func(io.Reader) ([]byte, error) {+ password := passwords[readCount]+ readCount+++ return password, nil+ })++ require.NoError(t, command.Execute())+ require.Len(t, runner.enableWorkspaces, 1)+ require.Len(t, runner.resetRequests, 1)+ require.Equal(t, 1, *openCount)+ require.Equal(t, 1, *closeCount)+ })++ t.Run("cancelled context exits cleanly", func(t *testing.T) {+ command, _, _, closeCount := newTestRecoveryCommand(t, &fakeRecoveryRunner{}, "", nil)+ ctx, cancel := context.WithCancel(context.Background())+ cancel()++ require.NoError(t, command.ExecuteContext(ctx))+ require.Equal(t, 1, *closeCount)+ })++ t.Run("cancelled context interrupts the menu read", func(t *testing.T) {+ command, _, _, closeCount := newTestRecoveryCommand(t, &fakeRecoveryRunner{}, "", nil)+ input := &blockingRecoveryReader{started: make(chan struct{}), release: make(chan struct{})}+ command.SetIn(input)+ ctx, cancel := context.WithCancel(context.Background())+ done := make(chan error, 1)+ go func() {+ done <- command.ExecuteContext(ctx)+ }()++ <-input.started+ cancel()+ select {+ case err := <-done:+ close(input.release)+ require.NoError(t, err)+ require.Equal(t, 1, *closeCount)+ case <-time.After(time.Second):+ close(input.release)+ <-done+ t.Fatal("recovery did not exit while the menu read was blocked")+ }+ })+}++func newTestRecoveryCommand(+ t *testing.T,+ runner recoveryRunner,+ input string,+ readPassword func(io.Reader) ([]byte, error),+) (*cobra.Command, *bytes.Buffer, *int, *int) {+ t.Helper()+ openCount := 0+ closeCount := 0+ if readPassword == nil {+ readPassword = func(io.Reader) ([]byte, error) {+ return nil, errors.New("unexpected password prompt")+ }+ }+ command := newRecoveryCommand(recoveryCommandDependencies{+ open: func(context.Context) (*recoveryBackend, error) {+ openCount+++ return &recoveryBackend{+ runner: runner,+ close: func() error {+ closeCount+++ return nil+ },+ }, nil+ },+ isTerminal: func(io.Reader, io.Writer) bool { return true },+ readPassword: readPassword,+ })+ output := &bytes.Buffer{}+ command.SetIn(strings.NewReader(input))+ command.SetOut(output)+ command.SetErr(output)+ command.SetArgs(nil)+ command.SilenceUsage = true+ command.SilenceErrors = true+ return command, output, &openCount, &closeCount+}diff --git a/backend/bin/server/cmd/root.go b/backend/bin/server/cmd/root.goindex 07730834d1..cfa051c6bc 100644--- a/backend/bin/server/cmd/root.go+++ b/backend/bin/server/cmd/root.go@@ -162,13 +162,12 @@ func start() {}}- if err := checkDataDir(); err != nil {+ profile, err := resolveProfile()+ if err != nil {slog.Error(err.Error())return}- profile := activeProfile(flags.dataDir)-fmt.Printf("Starting Bytebase %s(%s)...\n", profile.Version, profile.GitCommit)// The ideal bootstrap order is:diff --git a/backend/common/password.go b/backend/common/password.gonew file mode 100644index 0000000000..f76a7c25ec--- /dev/null+++ b/backend/common/password.go@@ -0,0 +1,30 @@+//nolint:revive+package common++import (+ "regexp"++ "github.com/pkg/errors"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+)++// ValidatePassword validates a password against the workspace password restrictions.+func ValidatePassword(password string, restriction *storepb.WorkspaceProfileSetting_PasswordRestriction) error {+ if len(password) < int(restriction.GetMinLength()) {+ return errors.Errorf("password length should no less than %v characters", restriction.GetMinLength())+ }+ if restriction.GetRequireNumber() && !regexp.MustCompile("[0-9]+").MatchString(password) {+ return errors.Errorf("password must contains at least 1 number")+ }+ if restriction.GetRequireLetter() && !regexp.MustCompile("[a-zA-Z]+").MatchString(password) {+ return errors.Errorf("password must contains at least 1 lower case letter")+ }+ if restriction.GetRequireUppercaseLetter() && !regexp.MustCompile("[A-Z]+").MatchString(password) {+ return errors.Errorf("password must contains at least 1 upper case letter")+ }+ if restriction.GetRequireSpecialCharacter() && !regexp.MustCompile(`[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]+`).MatchString(password) {+ return errors.Errorf("password must contains at least 1 special character")+ }+ return nil+}diff --git a/backend/common/password_test.go b/backend/common/password_test.gonew file mode 100644index 0000000000..bce457836f--- /dev/null+++ b/backend/common/password_test.go@@ -0,0 +1,83 @@+//nolint:revive+package common_test++import (+ "testing"++ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+)++func TestValidatePassword(t *testing.T) {+ tests := []struct {+ name string+ password string+ restriction *storepb.WorkspaceProfileSetting_PasswordRestriction+ wantErr string+ }{+ {+ name: "minimum length",+ password: "Short1!",+ restriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{+ MinLength: 8,+ },+ wantErr: "password length should no less than 8 characters",+ },+ {+ name: "number required",+ password: "NoNumber!",+ restriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{+ RequireNumber: true,+ },+ wantErr: "password must contains at least 1 number",+ },+ {+ name: "letter required",+ password: "12345678!",+ restriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{+ RequireLetter: true,+ },+ wantErr: "password must contains at least 1 lower case letter",+ },+ {+ name: "uppercase letter required",+ password: "lowercase1!",+ restriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{+ RequireUppercaseLetter: true,+ },+ wantErr: "password must contains at least 1 upper case letter",+ },+ {+ name: "special character required",+ password: "Password1",+ restriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{+ RequireSpecialCharacter: true,+ },+ wantErr: "password must contains at least 1 special character",+ },+ {+ name: "all restrictions satisfied",+ password: "Password1!",+ restriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{+ MinLength: 10,+ RequireNumber: true,+ RequireLetter: true,+ RequireUppercaseLetter: true,+ RequireSpecialCharacter: true,+ },+ },+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ err := common.ValidatePassword(test.password, test.restriction)+ if test.wantErr == "" {+ require.NoError(t, err)+ return+ }+ require.EqualError(t, err, test.wantErr)+ })+ }+}diff --git a/backend/component/recovery/service.go b/backend/component/recovery/service.gonew file mode 100644index 0000000000..8b47277094--- /dev/null+++ b/backend/component/recovery/service.go@@ -0,0 +1,430 @@+// Package recovery implements self-hosted workspace recovery operations.+package recovery++import (+ "context"+ "encoding/json"+ "slices"+ "strings"++ "github.com/pkg/errors"+ "golang.org/x/crypto/bcrypt"+ statuspb "google.golang.org/genproto/googleapis/rpc/status"+ "google.golang.org/protobuf/proto"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+ "github.com/bytebase/bytebase/backend/utils"+)++const (+ enablePasswordSigninAuditMethod = "/bytebase.cli.Recovery/EnablePasswordSignin"+ resetUserPasswordAuditMethod = "/bytebase.cli.Recovery/ResetUserPassword"+ addUserToWorkspaceAuditMethod = "/bytebase.cli.Recovery/AddUserToWorkspace"+)++// Service performs self-hosted recovery operations against the metadata store.+type Service struct {+ store *store.Store+}++// EnablePasswordSigninResult describes an existing-administrator recovery.+type EnablePasswordSigninResult struct {+ WorkspaceID string+ UsableAdminCount int+}++// ResetUserPasswordRequest describes a user password reset.+type ResetUserPasswordRequest struct {+ WorkspaceID string+ Email string+ Password []byte+}++// ResetUserPasswordResult describes a user password reset.+type ResetUserPasswordResult struct {+ WorkspaceID string+ Email string+ Changed bool+}++// Role describes a role available for workspace recovery.+type Role struct {+ Name string+ Title string+}++// AddUserToWorkspaceRequest describes an IAM membership recovery.+type AddUserToWorkspaceRequest struct {+ WorkspaceID string+ Email string+ Role string+}++// AddUserToWorkspaceResult describes an IAM membership recovery.+type AddUserToWorkspaceResult struct {+ WorkspaceID string+ Email string+ Role string+ Changed bool+}++// NewService creates a recovery service.+func NewService(stores *store.Store) *Service {+ return &Service{store: stores}+}++// GetWorkspaceID returns the only active workspace resource ID.+func (s *Service) GetWorkspaceID(ctx context.Context) (string, error) {+ count, err := s.store.CountWorkspaces(ctx)+ if err != nil {+ return "", errors.Wrap(err, "failed to count workspaces")+ }+ if count != 1 {+ return "", errors.Errorf("found %d workspaces; recovery requires exactly one workspace", count)+ }+ return s.store.GetWorkspaceID(ctx)+}++// EnablePasswordSignin enables password sign-in when the workspace already has+// an effective, active end-user administrator with a password credential.+func (s *Service) EnablePasswordSignin(ctx context.Context, workspaceID string) (*EnablePasswordSigninResult, error) {+ if err := s.requireWorkspace(ctx, workspaceID); err != nil {+ return nil, err+ }++ policy, err := s.store.GetWorkspaceIamPolicy(ctx, workspaceID)+ if err != nil {+ return nil, errors.Wrap(err, "failed to get workspace IAM policy")+ }+ effectiveAdmins := utils.GetUsersByRoleInIAMPolicy(+ ctx,+ s.store,+ workspaceID,+ store.WorkspaceAdminRole,+ true,+ policy.Policy,+ )+ usableAdminCount := 0+ for _, effectiveAdmin := range effectiveAdmins {+ if effectiveAdmin.Type != storepb.PrincipalType_END_USER {+ continue+ }+ admin, err := s.store.GetUserByEmail(ctx, effectiveAdmin.Email)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to load effective administrator %q", effectiveAdmin.Email)+ }+ if admin != nil && !admin.MemberDeleted && admin.PasswordHash != "" {+ usableAdminCount+++ }+ }+ if usableAdminCount == 0 {+ return nil, errors.New("no usable workspace administrator has an active end-user identity with a password credential")+ }+ auditRequest, err := json.Marshal(struct {+ Workspace string `json:"workspace"`+ }{+ Workspace: common.FormatWorkspace(workspaceID),+ })+ if err != nil {+ return nil, errors.Wrap(err, "failed to marshal recovery audit request")+ }++ if _, err := s.store.UpdateSettingAtomic(+ ctx,+ workspaceID,+ storepb.SettingName_WORKSPACE_PROFILE,+ func(current proto.Message) (proto.Message, error) {+ profile, ok := current.(*storepb.WorkspaceProfileSetting)+ if !ok {+ return nil, errors.New("workspace profile setting has an unexpected type")+ }+ profile.DisallowPasswordSignin = false+ return profile, nil+ },+ nil,+ ); err != nil {+ return nil, errors.Wrap(err, "failed to enable password sign-in")+ }++ result := &EnablePasswordSigninResult{+ WorkspaceID: workspaceID,+ UsableAdminCount: usableAdminCount,+ }+ if err := s.createAuditLog(ctx, workspaceID, enablePasswordSigninAuditMethod, string(auditRequest)); err != nil {+ return result, errors.Wrap(err, "password sign-in was enabled, but failed to create the recovery audit log")+ }+ return result, nil+}++// GetPasswordRestriction returns the workspace password restriction.+func (s *Service) GetPasswordRestriction(ctx context.Context, workspaceID string) (*storepb.WorkspaceProfileSetting_PasswordRestriction, error) {+ if err := s.requireWorkspace(ctx, workspaceID); err != nil {+ return nil, err+ }+ profile, err := s.store.GetWorkspaceProfileSetting(ctx, workspaceID)+ if err != nil {+ return nil, errors.Wrap(err, "failed to get workspace profile setting")+ }+ return profile.PasswordRestriction, nil+}++// IsUserInWorkspace reports whether the user has effective workspace membership.+func (s *Service) IsUserInWorkspace(ctx context.Context, workspaceID, email string) (bool, error) {+ if err := s.requireWorkspace(ctx, workspaceID); err != nil {+ return false, err+ }+ email = strings.ToLower(email)+ if err := common.ValidateEmail(email); err != nil {+ return false, errors.Wrap(err, "invalid user email")+ }+ workspace, err := s.store.FindWorkspace(ctx, &store.FindWorkspaceMessage{+ WorkspaceID: &workspaceID,+ Email: email,+ IncludeAllUser: true,+ })+ if err != nil {+ return false, errors.Wrap(err, "failed to verify workspace membership")+ }+ return workspace != nil, nil+}++// ListRoles lists roles available for workspace membership recovery.+func (s *Service) ListRoles(ctx context.Context, workspaceID string) ([]*Role, error) {+ if err := s.requireWorkspace(ctx, workspaceID); err != nil {+ return nil, err+ }++ roleMessages, err := s.store.ListRoles(ctx, &store.FindRoleMessage{Workspace: workspaceID})+ if err != nil {+ return nil, errors.Wrap(err, "failed to list workspace roles")+ }+ roles := make([]*Role, 0, len(roleMessages))+ for _, role := range roleMessages {+ roles = append(roles, &Role{Name: common.FormatRole(role.ResourceID), Title: role.Name})+ }+ priority := map[string]int{+ common.FormatRole(store.WorkspaceAdminRole): 0,+ common.FormatRole(store.WorkspaceDBARole): 1,+ common.FormatRole(store.WorkspaceMemberRole): 2,+ }+ slices.SortFunc(roles, func(left, right *Role) int {+ leftPriority, leftPreferred := priority[left.Name]+ rightPriority, rightPreferred := priority[right.Name]+ if leftPreferred != rightPreferred {+ if leftPreferred {+ return -1+ }+ return 1+ }+ if leftPreferred && leftPriority != rightPriority {+ return leftPriority - rightPriority+ }+ leftTitle := strings.ToLower(left.Title)+ rightTitle := strings.ToLower(right.Title)+ if leftTitle != rightTitle {+ return strings.Compare(leftTitle, rightTitle)+ }+ return strings.Compare(left.Name, right.Name)+ })+ return roles, nil+}++// AddUserToWorkspace assigns one direct role to an existing, active end user.+func (s *Service) AddUserToWorkspace(ctx context.Context, request AddUserToWorkspaceRequest) (*AddUserToWorkspaceResult, error) {+ if err := s.requireWorkspace(ctx, request.WorkspaceID); err != nil {+ return nil, err+ }++ email := strings.ToLower(request.Email)+ if err := common.ValidateEmail(email); err != nil {+ return nil, errors.Wrap(err, "invalid user email")+ }+ profile, err := s.store.GetWorkspaceProfileSetting(ctx, request.WorkspaceID)+ if err != nil {+ return nil, errors.Wrap(err, "failed to get workspace profile setting")+ }+ if profile.EnforceIdentityDomain && !emailBelongsToDomains(email, profile.Domains) {+ return nil, errors.Errorf("email %q does not belong to the workspace's allowed domains", email)+ }+ if _, err := s.getActiveEndUser(ctx, email); err != nil {+ return nil, err+ }++ roleID, err := common.GetRoleID(request.Role)+ if err != nil {+ return nil, errors.Wrap(err, "invalid role")+ }+ role, err := s.store.GetRole(ctx, &store.FindRoleMessage{Workspace: request.WorkspaceID, ResourceID: &roleID})+ if err != nil {+ return nil, errors.Wrap(err, "failed to find role")+ }+ if role == nil {+ return nil, errors.Errorf("role %q does not exist", request.Role)+ }++ policy, err := s.store.GetWorkspaceIamPolicy(ctx, request.WorkspaceID)+ if err != nil {+ return nil, errors.Wrap(err, "failed to get workspace IAM policy")+ }+ member := common.FormatUserEmail(email)+ directRoles := make([]string, 0)+ selected := false+ for _, binding := range policy.Policy.Bindings {+ if slices.Contains(binding.Members, member) {+ directRoles = append(directRoles, binding.Role)+ selected = selected || binding.Role == request.Role+ }+ }++ result := &AddUserToWorkspaceResult{+ WorkspaceID: request.WorkspaceID,+ Email: email,+ Role: request.Role,+ }+ if !selected {+ directRoles = append(directRoles, request.Role)+ if _, err := s.store.PatchWorkspaceIamPolicy(ctx, &store.PatchIamPolicyMessage{+ Workspace: request.WorkspaceID,+ Member: member,+ Roles: directRoles,+ }); err != nil {+ return nil, errors.Wrap(err, "failed to add user to workspace IAM policy")+ }+ result.Changed = true+ }++ auditRequest, err := json.Marshal(struct {+ Workspace string `json:"workspace"`+ Email string `json:"email"`+ Role string `json:"role"`+ }{+ Workspace: common.FormatWorkspace(request.WorkspaceID),+ Email: email,+ Role: request.Role,+ })+ if err != nil {+ return result, errors.Wrap(err, "failed to marshal recovery audit request")+ }+ if err := s.createAuditLog(ctx, request.WorkspaceID, addUserToWorkspaceAuditMethod, string(auditRequest)); err != nil {+ if result.Changed {+ return result, errors.Wrap(err, "user was added to the workspace, but failed to create the recovery audit log")+ }+ return result, errors.Wrap(err, "failed to create the recovery audit log")+ }+ return result, nil+}++// ResetUserPassword replaces the password of an existing, active end user+// without changing any other access state.+func (s *Service) ResetUserPassword(ctx context.Context, request ResetUserPasswordRequest) (*ResetUserPasswordResult, error) {+ if err := s.requireWorkspace(ctx, request.WorkspaceID); err != nil {+ return nil, err+ }++ email := strings.ToLower(request.Email)+ if err := common.ValidateEmail(email); err != nil {+ return nil, errors.Wrap(err, "invalid user email")+ }++ profile, err := s.store.GetWorkspaceProfileSetting(ctx, request.WorkspaceID)+ if err != nil {+ return nil, errors.Wrap(err, "failed to get workspace profile setting")+ }+ if profile.EnforceIdentityDomain && !emailBelongsToDomains(email, profile.Domains) {+ return nil, errors.Errorf("email %q does not belong to the workspace's allowed domains", email)+ }+ if err := common.ValidatePassword(string(request.Password), profile.PasswordRestriction); err != nil {+ return nil, errors.Wrap(err, "password does not satisfy the workspace restriction")+ }++ user, err := s.getActiveEndUser(ctx, email)+ if err != nil {+ return nil, err+ }++ auditRequest, err := json.Marshal(struct {+ Workspace string `json:"workspace"`+ Email string `json:"email"`+ }{+ Workspace: common.FormatWorkspace(request.WorkspaceID),+ Email: email,+ })+ if err != nil {+ return nil, errors.Wrap(err, "failed to marshal recovery audit request")+ }++ result := &ResetUserPasswordResult{WorkspaceID: request.WorkspaceID, Email: email}+ if bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), request.Password) != nil {+ passwordHash, err := bcrypt.GenerateFromPassword(request.Password, bcrypt.DefaultCost)+ if err != nil {+ return nil, errors.Wrap(err, "failed to hash user password")+ }+ if _, err := s.store.UpdateUser(ctx, user, &store.UpdateUserMessage{PasswordHash: new(string(passwordHash))}); err != nil {+ return nil, errors.Wrap(err, "failed to reset user password")+ }+ result.Changed = true+ }++ if err := s.createAuditLog(ctx, request.WorkspaceID, resetUserPasswordAuditMethod, string(auditRequest)); err != nil {+ return result, errors.Wrap(err, "user password reset completed, but failed to create the recovery audit log")+ }+ return result, nil+}++func (s *Service) getActiveEndUser(ctx context.Context, email string) (*store.UserMessage, error) {+ account, err := s.store.GetAccountByEmail(ctx, email)+ if err != nil {+ return nil, errors.Wrap(err, "failed to find user identity")+ }+ if account == nil {+ return nil, errors.Errorf("user %q does not exist", email)+ }+ if account.Type != storepb.PrincipalType_END_USER || account.MemberDeleted {+ return nil, errors.Errorf("user %q is not an active end user", email)+ }+ user, err := s.store.GetUserByEmail(ctx, email)+ if err != nil {+ return nil, errors.Wrap(err, "failed to load user identity")+ }+ if user == nil || user.MemberDeleted {+ return nil, errors.Errorf("user %q is not an active end user", email)+ }+ return user, nil+}++func (s *Service) requireWorkspace(ctx context.Context, workspaceID string) error {+ workspace, err := s.store.GetWorkspaceByID(ctx, workspaceID)+ if err != nil {+ return errors.Wrap(err, "failed to find workspace")+ }+ if workspace == nil {+ return errors.Errorf("workspace %q was not found", workspaceID)+ }+ return nil+}++func emailBelongsToDomains(email string, domains []string) bool {+ if len(domains) == 0 {+ return true+ }+ for _, domain := range domains {+ if strings.HasSuffix(email, "@"+strings.ToLower(domain)) {+ return true+ }+ }+ return false+}++func (s *Service) createAuditLog(ctx context.Context, workspaceID, method, request string) error {+ workspace := common.FormatWorkspace(workspaceID)+ return s.store.CreateAuditLog(context.WithoutCancel(ctx), workspaceID, &storepb.AuditLog{+ Parent: workspace,+ Method: method,+ Resource: workspace,+ Severity: storepb.AuditLog_WARNING,+ Request: request,+ Status: &statuspb.Status{},+ })+}diff --git a/backend/component/recovery/service_test.go b/backend/component/recovery/service_test.gonew file mode 100644index 0000000000..58f98f12e3--- /dev/null+++ b/backend/component/recovery/service_test.go@@ -0,0 +1,714 @@+package recovery_test++import (+ "context"+ "fmt"+ "slices"+ "strings"+ "testing"+ "time"++ "github.com/stretchr/testify/require"+ "golang.org/x/crypto/bcrypt"+ "google.golang.org/protobuf/encoding/protojson"+ "google.golang.org/protobuf/proto"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/testcontainer"+ "github.com/bytebase/bytebase/backend/component/recovery"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/migrator"+ "github.com/bytebase/bytebase/backend/store"+)++func TestGetWorkspaceID(t *testing.T) {+ ctx := context.Background()+ stores := setupRecoveryStore(ctx, t)+ service := recovery.NewService(stores)++ workspaceID, err := service.GetWorkspaceID(ctx)+ require.ErrorContains(t, err, "recovery requires exactly one workspace")+ require.Empty(t, workspaceID)++ createRecoveryWorkspace(ctx, t, stores, "recovery-single-workspace", "[email protected]", recoveryProfile())+ workspaceID, err = service.GetWorkspaceID(ctx)+ require.NoError(t, err)+ require.Equal(t, "recovery-single-workspace", workspaceID)++ require.NoError(t, stores.DeleteWorkspace(ctx, "recovery-single-workspace"))+ workspaceID, err = service.GetWorkspaceID(ctx)+ require.NoError(t, err)+ require.Empty(t, workspaceID)++ createRecoveryWorkspace(ctx, t, stores, "recovery-second-workspace", "[email protected]", recoveryProfile())+ workspaceID, err = service.GetWorkspaceID(ctx)+ require.ErrorContains(t, err, "found 2 workspaces")+ require.Empty(t, workspaceID)+}++func TestEnablePasswordSignin(t *testing.T) {+ ctx := context.Background()+ stores := setupRecoveryStore(ctx, t)+ service := recovery.NewService(stores)++ t.Run("effective admin enables password signin and records audit", func(t *testing.T) {+ const (+ workspaceID = "recovery-enable-success"+ adminEmail = "[email protected]"+ )+ createRecoveryWorkspace(ctx, t, stores, workspaceID, adminEmail, recoveryProfile())+ createRecoveryUser(ctx, t, stores, adminEmail, "KnownPassword1!", false, nil, nil)++ result, err := service.EnablePasswordSignin(ctx, workspaceID)+ require.NoError(t, err)+ require.Equal(t, &recovery.EnablePasswordSigninResult{+ WorkspaceID: workspaceID,+ UsableAdminCount: 1,+ }, result)++ profile, err := stores.GetWorkspaceProfileSetting(ctx, workspaceID)+ require.NoError(t, err)+ require.False(t, profile.DisallowPasswordSignin)+ require.True(t, profile.DisallowSignup)+ require.Equal(t, "https://recovery.example.com", profile.ExternalUrl)+ require.EqualValues(t, 12, profile.PasswordRestriction.MinLength)++ result, err = service.EnablePasswordSignin(ctx, workspaceID)+ require.NoError(t, err)+ require.Equal(t, 1, result.UsableAdminCount)++ logs, err := stores.SearchAuditLogs(ctx, &store.AuditLogFind{Workspace: workspaceID})+ require.NoError(t, err)+ require.Len(t, logs, 2)+ log := logs[0].Payload+ require.Equal(t, "/bytebase.cli.Recovery/EnablePasswordSignin", log.Method)+ require.Equal(t, common.FormatWorkspace(workspaceID), log.Parent)+ require.Equal(t, common.FormatWorkspace(workspaceID), log.Resource)+ require.Empty(t, log.User)+ require.Equal(t, storepb.AuditLog_WARNING, log.Severity)+ require.Contains(t, log.Request, workspaceID)+ require.NotContains(t, strings.ToLower(log.Request), "password")+ })++ t.Run("group admin is effective", func(t *testing.T) {+ const (+ workspaceID = "recovery-enable-group"+ adminEmail = "[email protected]"+ )+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", recoveryProfile())+ createRecoveryUser(ctx, t, stores, adminEmail, "KnownPassword1!", false, nil, nil)+ group, err := stores.CreateGroup(ctx, &store.GroupMessage{+ Workspace: workspaceID,+ Email: "[email protected]",+ Title: "Recovery admins",+ Payload: &storepb.GroupPayload{Members: []*storepb.GroupMember{{+ Member: common.FormatUserEmail(adminEmail),+ Role: storepb.GroupMember_MEMBER,+ }}},+ })+ require.NoError(t, err)+ setWorkspaceIAMPolicy(ctx, t, stores, workspaceID, &storepb.IamPolicy{Bindings: []*storepb.Binding{{+ Role: common.FormatRole(store.WorkspaceAdminRole),+ Members: []string{common.FormatGroupEmail(group.Email)},+ }}})++ result, err := service.EnablePasswordSignin(ctx, workspaceID)+ require.NoError(t, err)+ require.Equal(t, 1, result.UsableAdminCount)+ })++ for _, tc := range []struct {+ name string+ workspaceID string+ password string+ deleted bool+ wantErrorText string+ }{+ {name: "no effective admin", workspaceID: "recovery-enable-no-admin", wantErrorText: "no usable workspace administrator"},+ {name: "deleted admin", workspaceID: "recovery-enable-deleted", password: "KnownPassword1!", deleted: true, wantErrorText: "no usable workspace administrator"},+ {name: "admin without password", workspaceID: "recovery-enable-no-password", wantErrorText: "no usable workspace administrator"},+ } {+ t.Run(tc.name, func(t *testing.T) {+ adminEmail := tc.workspaceID + "@example.com"+ createRecoveryWorkspace(ctx, t, stores, tc.workspaceID, adminEmail, recoveryProfile())+ if tc.name != "no effective admin" {+ createRecoveryUser(ctx, t, stores, adminEmail, tc.password, tc.deleted, nil, nil)+ }++ result, err := service.EnablePasswordSignin(ctx, tc.workspaceID)+ require.ErrorContains(t, err, tc.wantErrorText)+ require.Nil(t, result)+ profile, getErr := stores.GetWorkspaceProfileSetting(ctx, tc.workspaceID)+ require.NoError(t, getErr)+ require.True(t, profile.DisallowPasswordSignin)+ })+ }+}++func TestResetUserPassword(t *testing.T) {+ ctx := context.Background()+ stores := setupRecoveryStore(ctx, t)+ service := recovery.NewService(stores)++ t.Run("returns the workspace password restriction", func(t *testing.T) {+ const workspaceID = "recovery-password-restriction"+ profile := recoveryProfile()+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", profile)++ restriction, err := service.GetPasswordRestriction(ctx, workspaceID)++ require.NoError(t, err)+ require.True(t, proto.Equal(profile.PasswordRestriction, restriction))+ })++ t.Run("resets an existing user password and only password metadata", func(t *testing.T) {+ const (+ workspaceID = "recovery-reset-success"+ email = "[email protected]"+ oldPassword = "OriginalPassword1!"+ newPassword = "ReplacementPassword1!"+ )+ workspaceProfile := recoveryProfile()+ createRecoveryWorkspace(ctx, t, stores, workspaceID, email, workspaceProfile)+ userProfile := &storepb.UserProfile{Source: "entra-id", LastLoginWorkspace: "another-workspace"}+ mfa := &storepb.MFAConfig{OtpSecret: "otp-secret", RecoveryCodes: []string{"recovery-code"}}+ createRecoveryUser(ctx, t, stores, email, oldPassword, false, userProfile, mfa)+ require.NoError(t, stores.CreateWebRefreshToken(ctx, &store.WebRefreshTokenMessage{+ TokenHash: "existing-admin-token",+ UserEmail: email,+ ExpiresAt: time.Now().Add(time.Hour),+ }))+ policyBefore, err := stores.GetWorkspaceIamPolicy(ctx, workspaceID)+ require.NoError(t, err)+ policySnapshot := proto.CloneOf(policyBefore.Policy)+ settingSnapshot := proto.CloneOf(workspaceProfile)++ result, err := service.ResetUserPassword(ctx, recovery.ResetUserPasswordRequest{+ WorkspaceID: workspaceID,+ Email: "[email protected]",+ Password: []byte(newPassword),+ })+ require.NoError(t, err)+ require.Equal(t, &recovery.ResetUserPasswordResult{WorkspaceID: workspaceID, Email: email, Changed: true}, result)++ user, err := stores.GetUserByEmail(ctx, email)+ require.NoError(t, err)+ require.False(t, user.MemberDeleted)+ require.NoError(t, bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(newPassword)))+ require.True(t, proto.Equal(mfa, user.MFAConfig))+ require.Equal(t, "entra-id", user.Profile.Source)+ require.Equal(t, "another-workspace", user.Profile.LastLoginWorkspace)+ require.NotNil(t, user.Profile.LastChangePasswordTime)++ policyAfter, err := stores.GetWorkspaceIamPolicy(ctx, workspaceID)+ require.NoError(t, err)+ require.True(t, proto.Equal(policySnapshot, policyAfter.Policy))+ profileAfter, err := stores.GetWorkspaceProfileSetting(ctx, workspaceID)+ require.NoError(t, err)+ require.True(t, proto.Equal(settingSnapshot, profileAfter))+ token, err := stores.GetWebRefreshToken(ctx, "existing-admin-token")+ require.NoError(t, err)+ require.NotNil(t, token)++ result, err = service.ResetUserPassword(ctx, recovery.ResetUserPasswordRequest{+ WorkspaceID: workspaceID,+ Email: email,+ Password: []byte(newPassword),+ })+ require.NoError(t, err)+ require.False(t, result.Changed)++ logs, err := stores.SearchAuditLogs(ctx, &store.AuditLogFind{Workspace: workspaceID})+ require.NoError(t, err)+ require.Len(t, logs, 2)+ for _, auditLog := range logs {+ payload := auditLog.Payload+ require.Equal(t, "/bytebase.cli.Recovery/ResetUserPassword", payload.Method)+ require.Equal(t, storepb.AuditLog_WARNING, payload.Severity)+ require.Empty(t, payload.User)+ require.Contains(t, payload.Request, email)+ require.NotContains(t, payload.Request, newPassword)+ require.NotContains(t, strings.ToLower(payload.Request), "password")+ require.NotContains(t, payload.Request, "$2")+ }+ })++ t.Run("accepts a user who belongs through a group", func(t *testing.T) {+ const (+ workspaceID = "recovery-reset-group"+ email = "[email protected]"+ )+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", recoveryProfile())+ createRecoveryUser(ctx, t, stores, email, "OriginalPassword1!", false, nil, nil)+ group, err := stores.CreateGroup(ctx, &store.GroupMessage{+ Workspace: workspaceID,+ Email: "[email protected]",+ Title: "Reset admins",+ Payload: &storepb.GroupPayload{Members: []*storepb.GroupMember{{+ Member: common.FormatUserEmail(email),+ Role: storepb.GroupMember_MEMBER,+ }}},+ })+ require.NoError(t, err)+ setWorkspaceIAMPolicy(ctx, t, stores, workspaceID, &storepb.IamPolicy{Bindings: []*storepb.Binding{{+ Role: "roles/workspaceMember",+ Members: []string{common.FormatGroupEmail(group.Email)},+ }}})++ result, err := service.ResetUserPassword(ctx, recovery.ResetUserPasswordRequest{+ WorkspaceID: workspaceID,+ Email: email,+ Password: []byte("ReplacementPassword1!"),+ })+ require.NoError(t, err)+ require.True(t, result.Changed)+ member, err := service.IsUserInWorkspace(ctx, workspaceID, email)+ require.NoError(t, err)+ require.True(t, member)+ })++ t.Run("accepts a direct non-admin workspace member", func(t *testing.T) {+ const (+ workspaceID = "recovery-reset-member"+ email = "[email protected]"+ )+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", recoveryProfile())+ createRecoveryUser(ctx, t, stores, email, "OriginalPassword1!", false, nil, nil)+ setWorkspaceIAMPolicy(ctx, t, stores, workspaceID, &storepb.IamPolicy{Bindings: []*storepb.Binding{{+ Role: "roles/workspaceMember",+ Members: []string{common.FormatUserEmail(email)},+ }}})++ result, err := service.ResetUserPassword(ctx, recovery.ResetUserPasswordRequest{+ WorkspaceID: workspaceID,+ Email: email,+ Password: []byte("ReplacementPassword1!"),+ })+ require.NoError(t, err)+ require.True(t, result.Changed)+ member, err := service.IsUserInWorkspace(ctx, workspaceID, email)+ require.NoError(t, err)+ require.True(t, member)+ })++ t.Run("reports a user covered by allUsers as a workspace member", func(t *testing.T) {+ const (+ workspaceID = "recovery-reset-all-users"+ email = "[email protected]"+ )+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", recoveryProfile())+ createRecoveryUser(ctx, t, stores, email, "OriginalPassword1!", false, nil, nil)+ setWorkspaceIAMPolicy(ctx, t, stores, workspaceID, &storepb.IamPolicy{Bindings: []*storepb.Binding{{+ Role: "roles/workspaceMember",+ Members: []string{common.AllUsers},+ }}})++ member, err := service.IsUserInWorkspace(ctx, workspaceID, email)+ require.NoError(t, err)+ require.True(t, member)+ })++ t.Run("resets a user outside the workspace before reporting membership", func(t *testing.T) {+ const (+ workspaceID = "recovery-reset-unrelated"+ email = "[email protected]"+ newPassword = "ReplacementPassword1!"+ )+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", recoveryProfile())+ createRecoveryUser(ctx, t, stores, email, "OriginalPassword1!", false, nil, nil)++ result, err := service.ResetUserPassword(ctx, recovery.ResetUserPasswordRequest{+ WorkspaceID: workspaceID,+ Email: email,+ Password: []byte(newPassword),+ })+ require.NoError(t, err)+ require.True(t, result.Changed)+ member, err := service.IsUserInWorkspace(ctx, workspaceID, email)+ require.NoError(t, err)+ require.False(t, member)+ user, err := stores.GetUserByEmail(ctx, email)+ require.NoError(t, err)+ require.NoError(t, bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(newPassword)))+ })++ for _, tc := range []struct {+ name string+ workspaceID string+ email string+ create func(context.Context, *testing.T, *store.Store, string, string)+ }{+ {+ name: "service account",+ workspaceID: "recovery-reset-service-account",+ email: "[email protected]",+ create: func(ctx context.Context, t *testing.T, stores *store.Store, workspaceID, email string) {+ _, err := stores.CreateServiceAccount(ctx, &store.CreateServiceAccountMessage{+ Email: email, Name: "Automation", Workspace: workspaceID, ServiceKeyHash: "unused",+ })+ require.NoError(t, err)+ },+ },+ {+ name: "workload identity",+ workspaceID: "recovery-reset-workload-identity",+ email: "[email protected]",+ create: func(ctx context.Context, t *testing.T, stores *store.Store, workspaceID, email string) {+ _, err := stores.CreateWorkloadIdentity(ctx, &store.CreateWorkloadIdentityMessage{+ Email: email, Name: "Automation", Workspace: workspaceID, Config: &storepb.WorkloadIdentityConfig{},+ })+ require.NoError(t, err)+ },+ },+ } {+ t.Run("rejects "+tc.name, func(t *testing.T) {+ createRecoveryWorkspace(ctx, t, stores, tc.workspaceID, "[email protected]", recoveryProfile())+ tc.create(ctx, t, stores, tc.workspaceID, tc.email)++ result, err := service.ResetUserPassword(ctx, recovery.ResetUserPasswordRequest{+ WorkspaceID: tc.workspaceID,+ Email: tc.email,+ Password: []byte("ReplacementPassword1!"),+ })+ require.ErrorContains(t, err, "not an active end user")+ require.Nil(t, result)+ })+ }++ for _, tc := range []struct {+ name string+ workspaceID string+ email string+ profile *storepb.WorkspaceProfileSetting+ password string+ createUser bool+ deleted bool+ wantError string+ }{+ {+ name: "missing user",+ workspaceID: "recovery-reset-missing",+ email: "[email protected]",+ profile: recoveryProfile(),+ password: "ReplacementPassword1!",+ wantError: "does not exist",+ },+ {+ name: "deleted user",+ workspaceID: "recovery-reset-deleted",+ email: "[email protected]",+ profile: recoveryProfile(),+ password: "ReplacementPassword1!",+ createUser: true,+ deleted: true,+ wantError: "not an active end user",+ },+ {+ name: "outside enforced domain",+ workspaceID: "recovery-reset-domain",+ email: "[email protected]",+ profile: func() *storepb.WorkspaceProfileSetting {+ profile := recoveryProfile()+ profile.EnforceIdentityDomain = true+ profile.Domains = []string{"allowed.example"}+ return profile+ }(),+ password: "ReplacementPassword1!",+ createUser: true,+ wantError: "allowed domains",+ },+ {+ name: "password restriction",+ workspaceID: "recovery-reset-password",+ email: "[email protected]",+ profile: recoveryProfile(),+ password: "too-short",+ createUser: true,+ wantError: "password length",+ },+ } {+ t.Run(tc.name, func(t *testing.T) {+ createRecoveryWorkspace(ctx, t, stores, tc.workspaceID, tc.email, tc.profile)+ if tc.createUser {+ createRecoveryUser(ctx, t, stores, tc.email, "OriginalPassword1!", tc.deleted, nil, nil)+ }+ result, err := service.ResetUserPassword(ctx, recovery.ResetUserPasswordRequest{+ WorkspaceID: tc.workspaceID,+ Email: tc.email,+ Password: []byte(tc.password),+ })+ require.ErrorContains(t, err, tc.wantError)+ require.Nil(t, result)+ user, getErr := stores.GetUserByEmail(ctx, tc.email)+ require.NoError(t, getErr)+ if tc.createUser {+ require.NoError(t, bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte("OriginalPassword1!")))+ } else {+ require.Nil(t, user)+ }+ profile, getErr := stores.GetWorkspaceProfileSetting(ctx, tc.workspaceID)+ require.NoError(t, getErr)+ require.True(t, profile.DisallowPasswordSignin)+ })+ }+}++func TestListRoles(t *testing.T) {+ ctx := context.Background()+ stores := setupRecoveryStore(ctx, t)+ service := recovery.NewService(stores)+ const workspaceID = "recovery-list-roles"+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", recoveryProfile())+ _, err := stores.CreateRole(ctx, &store.RoleMessage{+ ResourceID: "recoveryOperator",+ Workspace: workspaceID,+ Name: "Recovery operator",+ })+ require.NoError(t, err)++ roles, err := service.ListRoles(ctx, workspaceID)+ require.NoError(t, err)+ require.Greater(t, len(roles), 3)+ require.Equal(t, []*recovery.Role{+ {Name: "roles/workspaceAdmin", Title: "Workspace admin"},+ {Name: "roles/workspaceDBA", Title: "Workspace DBA"},+ {Name: "roles/workspaceMember", Title: "Workspace member"},+ }, roles[:3])+ require.Contains(t, roles, &recovery.Role{Name: "roles/recoveryOperator", Title: "Recovery operator"})++ var remaining []string+ for _, role := range roles[3:] {+ remaining = append(remaining, strings.ToLower(role.Title)+"\x00"+role.Name)+ }+ sorted := append([]string(nil), remaining...)+ slices.Sort(sorted)+ require.Equal(t, sorted, remaining)+}++func TestAddUserToWorkspace(t *testing.T) {+ ctx := context.Background()+ stores := setupRecoveryStore(ctx, t)+ service := recovery.NewService(stores)++ t.Run("adds one direct role and records an audit", func(t *testing.T) {+ const (+ workspaceID = "recovery-add-user"+ adminEmail = "[email protected]"+ email = "[email protected]"+ role = "roles/workspaceDBA"+ )+ createRecoveryWorkspace(ctx, t, stores, workspaceID, adminEmail, recoveryProfile())+ createRecoveryUser(ctx, t, stores, adminEmail, "OriginalPassword1!", false, nil, nil)+ createRecoveryUser(ctx, t, stores, email, "OriginalPassword1!", false, nil, nil)++ result, err := service.AddUserToWorkspace(ctx, recovery.AddUserToWorkspaceRequest{+ WorkspaceID: workspaceID,+ Email: strings.ToUpper(email),+ Role: role,+ })+ require.NoError(t, err)+ require.Equal(t, &recovery.AddUserToWorkspaceResult{+ WorkspaceID: workspaceID,+ Email: email,+ Role: role,+ Changed: true,+ }, result)++ policy, err := stores.GetWorkspaceIamPolicy(ctx, workspaceID)+ require.NoError(t, err)+ require.True(t, bindingContains(policy.Policy, "roles/workspaceAdmin", common.FormatUserEmail(adminEmail)))+ require.True(t, bindingContains(policy.Policy, role, common.FormatUserEmail(email)))++ result, err = service.AddUserToWorkspace(ctx, recovery.AddUserToWorkspaceRequest{+ WorkspaceID: workspaceID,+ Email: email,+ Role: role,+ })+ require.NoError(t, err)+ require.False(t, result.Changed)++ logs, err := stores.SearchAuditLogs(ctx, &store.AuditLogFind{Workspace: workspaceID})+ require.NoError(t, err)+ require.Len(t, logs, 2)+ for _, auditLog := range logs {+ payload := auditLog.Payload+ require.Equal(t, "/bytebase.cli.Recovery/AddUserToWorkspace", payload.Method)+ require.Contains(t, payload.Request, email)+ require.Contains(t, payload.Request, role)+ require.NotContains(t, strings.ToLower(payload.Request), "password")+ require.NotContains(t, payload.Request, "$2")+ }+ })++ t.Run("rejects an unknown role", func(t *testing.T) {+ const (+ workspaceID = "recovery-add-unknown-role"+ email = "[email protected]"+ )+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", recoveryProfile())+ createRecoveryUser(ctx, t, stores, email, "OriginalPassword1!", false, nil, nil)++ result, err := service.AddUserToWorkspace(ctx, recovery.AddUserToWorkspaceRequest{+ WorkspaceID: workspaceID,+ Email: email,+ Role: "roles/doesNotExist",+ })+ require.ErrorContains(t, err, "role")+ require.Nil(t, result)+ })++ t.Run("rejects an email outside the enforced domain", func(t *testing.T) {+ const (+ workspaceID = "recovery-add-domain"+ email = "[email protected]"+ )+ profile := recoveryProfile()+ profile.EnforceIdentityDomain = true+ profile.Domains = []string{"allowed.example"}+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", profile)+ createRecoveryUser(ctx, t, stores, email, "OriginalPassword1!", false, nil, nil)++ result, err := service.AddUserToWorkspace(ctx, recovery.AddUserToWorkspaceRequest{+ WorkspaceID: workspaceID,+ Email: email,+ Role: "roles/workspaceMember",+ })+ require.ErrorContains(t, err, "allowed domains")+ require.Nil(t, result)+ })++ t.Run("rejects a non-end-user identity", func(t *testing.T) {+ const (+ workspaceID = "recovery-add-service-account"+ email = "[email protected]"+ )+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "[email protected]", recoveryProfile())+ _, err := stores.CreateServiceAccount(ctx, &store.CreateServiceAccountMessage{+ Email: email, Name: "Recovery automation", Workspace: workspaceID, ServiceKeyHash: "unused",+ })+ require.NoError(t, err)++ result, err := service.AddUserToWorkspace(ctx, recovery.AddUserToWorkspaceRequest{+ WorkspaceID: workspaceID,+ Email: email,+ Role: "roles/workspaceMember",+ })+ require.ErrorContains(t, err, "not an active end user")+ require.Nil(t, result)+ })++ for _, tc := range []struct {+ name string+ email string+ createUser bool+ deleted bool+ }{+ {name: "missing user", email: "[email protected]"},+ {name: "deleted user", email: "[email protected]", createUser: true, deleted: true},+ } {+ t.Run("rejects "+tc.name, func(t *testing.T) {+ workspaceID := "recovery-add-" + strings.ReplaceAll(tc.name, " ", "-")+ createRecoveryWorkspace(ctx, t, stores, workspaceID, "admin-"+tc.email, recoveryProfile())+ if tc.createUser {+ createRecoveryUser(ctx, t, stores, tc.email, "OriginalPassword1!", tc.deleted, nil, nil)+ }++ result, err := service.AddUserToWorkspace(ctx, recovery.AddUserToWorkspaceRequest{+ WorkspaceID: workspaceID,+ Email: tc.email,+ Role: "roles/workspaceMember",+ })+ require.Error(t, err)+ require.Nil(t, result)+ })+ }+}++func setupRecoveryStore(ctx context.Context, t *testing.T) *store.Store {+ t.Helper()+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(ctx) })+ require.NoError(t, migrator.MigrateSchema(ctx, container.GetDB()))++ pgURL := fmt.Sprintf("host=%s port=%s user=postgres password=root-password database=postgres", container.GetHost(), container.GetPort())+ stores, err := store.New(ctx, pgURL, false)+ require.NoError(t, err)+ t.Cleanup(func() { require.NoError(t, stores.Close()) })+ return stores+}++func createRecoveryWorkspace(ctx context.Context, t *testing.T, stores *store.Store, workspaceID, adminEmail string, profile *storepb.WorkspaceProfileSetting) {+ t.Helper()+ _, err := stores.CreateWorkspace(ctx, &store.WorkspaceMessage{+ ResourceID: workspaceID,+ Payload: &storepb.WorkspacePayload{Title: workspaceID},+ }, adminEmail)+ require.NoError(t, err)+ _, err = stores.UpsertSetting(ctx, &store.SettingMessage{+ Name: storepb.SettingName_WORKSPACE_PROFILE,+ Workspace: workspaceID,+ Value: profile,+ })+ require.NoError(t, err)+}++func recoveryProfile() *storepb.WorkspaceProfileSetting {+ return &storepb.WorkspaceProfileSetting{+ DisallowPasswordSignin: true,+ DisallowSignup: true,+ ExternalUrl: "https://recovery.example.com",+ PasswordRestriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{+ MinLength: 12,+ RequireNumber: true,+ RequireLetter: true,+ RequireUppercaseLetter: true,+ RequireSpecialCharacter: true,+ },+ }+}++func createRecoveryUser(ctx context.Context, t *testing.T, stores *store.Store, email, password string, deleted bool, profile *storepb.UserProfile, mfa *storepb.MFAConfig) {+ t.Helper()+ var passwordHash string+ if password != "" {+ hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)+ require.NoError(t, err)+ passwordHash = string(hash)+ }+ user, err := stores.CreateUser(ctx, &store.UserMessage{+ Email: email,+ Name: email,+ PasswordHash: passwordHash,+ Profile: profile,+ })+ require.NoError(t, err)+ if deleted || mfa != nil {+ _, err = stores.UpdateUser(ctx, user, &store.UpdateUserMessage{Delete: &deleted, MFAConfig: mfa})+ require.NoError(t, err)+ }+}++func setWorkspaceIAMPolicy(ctx context.Context, t *testing.T, stores *store.Store, workspaceID string, policy *storepb.IamPolicy) {+ t.Helper()+ payload, err := protojson.Marshal(policy)+ require.NoError(t, err)+ _, err = stores.CreatePolicy(ctx, &store.PolicyMessage{+ Workspace: workspaceID,+ Resource: common.FormatWorkspace(workspaceID),+ ResourceType: storepb.Policy_WORKSPACE,+ Payload: string(payload),+ Type: storepb.Policy_IAM,+ InheritFromParent: false,+ Enforce: true,+ })+ require.NoError(t, err)+}++func bindingContains(policy *storepb.IamPolicy, role, member string) bool {+ for _, binding := range policy.Bindings {+ if binding.Role == role && slices.Contains(binding.Members, member) {+ return true+ }+ }+ return false+}diff --git a/backend/generated-go/store/setting.pb.go b/backend/generated-go/store/setting.pb.goindex 1393816603..f8642be656 100644--- a/backend/generated-go/store/setting.pb.go+++ b/backend/generated-go/store/setting.pb.go@@ -587,7 +587,7 @@ type WorkspaceProfileSetting struct {EnforceIdentityDomain bool `protobuf:"varint,8,opt,name=enforce_identity_domain,json=enforceIdentityDomain,proto3" json:"enforce_identity_domain,omitempty"`// The workspace database change mode.DatabaseChangeMode WorkspaceProfileSetting_DatabaseChangeMode `protobuf:"varint,9,opt,name=database_change_mode,json=databaseChangeMode,proto3,enum=bytebase.store.WorkspaceProfileSetting_DatabaseChangeMode" json:"database_change_mode,omitempty"`- // Whether to disallow password signin. (Except workspace admins)+ // Whether password sign-in is disabled for all end users.DisallowPasswordSignin bool `protobuf:"varint,10,opt,name=disallow_password_signin,json=disallowPasswordSignin,proto3" json:"disallow_password_signin,omitempty"`// Whether to enable metric collection for the workspace.EnableMetricCollection bool `protobuf:"varint,11,opt,name=enable_metric_collection,json=enableMetricCollection,proto3" json:"enable_metric_collection,omitempty"`diff --git a/backend/generated-go/v1/actuator_service.pb.go b/backend/generated-go/v1/actuator_service.pb.goindex 74ce89e3a8..7c95fb758b 100644--- a/backend/generated-go/v1/actuator_service.pb.go+++ b/backend/generated-go/v1/actuator_service.pb.go@@ -114,7 +114,7 @@ type Restriction struct {state protoimpl.MessageState `protogen:"open.v1"`// Whether self-service user signup is disabled.DisallowSignup bool `protobuf:"varint,1,opt,name=disallow_signup,json=disallowSignup,proto3" json:"disallow_signup,omitempty"`- // Whether password-based signin is disabled (except for workspace admins).+ // Whether password sign-in is disabled for all end users.DisallowPasswordSignin bool `protobuf:"varint,2,opt,name=disallow_password_signin,json=disallowPasswordSignin,proto3" json:"disallow_password_signin,omitempty"`// Password complexity and restriction requirements.PasswordRestriction *WorkspaceProfileSetting_PasswordRestriction `protobuf:"bytes,3,opt,name=password_restriction,json=passwordRestriction,proto3" json:"password_restriction,omitempty"`diff --git a/backend/generated-go/v1/setting_service.pb.go b/backend/generated-go/v1/setting_service.pb.goindex b766794c8d..53c130d7c9 100644--- a/backend/generated-go/v1/setting_service.pb.go+++ b/backend/generated-go/v1/setting_service.pb.go@@ -1062,7 +1062,7 @@ type WorkspaceProfileSetting struct {EnforceIdentityDomain bool `protobuf:"varint,8,opt,name=enforce_identity_domain,json=enforceIdentityDomain,proto3" json:"enforce_identity_domain,omitempty"`// The workspace database change mode.DatabaseChangeMode DatabaseChangeMode `protobuf:"varint,9,opt,name=database_change_mode,json=databaseChangeMode,proto3,enum=bytebase.v1.DatabaseChangeMode" json:"database_change_mode,omitempty"`- // Whether to disallow password signin. (Except workspace admins)+ // Whether password sign-in is disabled for all end users.DisallowPasswordSignin bool `protobuf:"varint,10,opt,name=disallow_password_signin,json=disallowPasswordSignin,proto3" json:"disallow_password_signin,omitempty"`// Whether to enable metric collection for the workspace.EnableMetricCollection bool `protobuf:"varint,11,opt,name=enable_metric_collection,json=enableMetricCollection,proto3" json:"enable_metric_collection,omitempty"`diff --git a/backend/store/stats.go b/backend/store/stats.goindex 7cc40b7827..c51edf48d9 100644--- a/backend/store/stats.go+++ b/backend/store/stats.go@@ -8,6 +8,21 @@ import ("github.com/bytebase/bytebase/backend/common/qb")+// CountWorkspaces counts all workspaces.+func (s *Store) CountWorkspaces(ctx context.Context) (int, error) {+ q := qb.Q().Space("SELECT count(1) FROM workspace")+ query, args, err := q.ToSQL()+ if err != nil {+ return 0, errors.Wrap(err, "failed to build sql")+ }++ var count int+ if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(&count); err != nil {+ return 0, err+ }+ return count, nil+}+// CountActiveInstances counts the number of instances.func (s *Store) CountActiveInstances(ctx context.Context, workspaceID string) (int, error) {q := qb.Q().Space("SELECT count(1) FROM instance WHERE instance.workspace = ?", workspaceID).And("instance.deleted = ?", false)diff --git a/docs/operations/admin-recovery.md b/docs/operations/admin-recovery.mdnew file mode 100644index 0000000000..0a01e5f498--- /dev/null+++ b/docs/operations/admin-recovery.md@@ -0,0 +1,207 @@+# Recover administrator access++This runbook restores ordinary password sign-in for a self-hosted Bytebase+deployment. Recovery changes metadata through the Bytebase store; it does not+provide an alternate authentication endpoint or bypass the workspace password+policy.++## Support boundary++Use this procedure only when all of the following are true:++- You operate a self-hosted Bytebase deployment and control its metadata+ database.+- The metadata database contains exactly one workspace, and it is active.+- At least one existing, active end-user identity remains.+- You can run the same Bytebase binary version against the same metadata+ database from a terminal.++The recovery workflow does not create or reactivate identities, create or edit+roles, clear MFA, revoke tokens, or repair an identity provider. When an+existing user is no longer a workspace member, the operator can explicitly add+one existing role. Direct metadata SQL changes are not a supported recovery+procedure.++After recovery, sign in through the ordinary+`/auth` page.++## Choose the action++| Situation | Recovery action |+| --- | --- |+| An existing administrator password is known, but password sign-in is disabled | **Enable password sign-in** |+| An existing user's password is unknown | **Reset user password** |+| An existing user was removed from the workspace IAM policy | **Reset user password**, confirm adding the user, and select a role |+| An administrator password is unknown and password sign-in is disabled | **Reset user password**, then **Enable password sign-in** in the same session |++## Before recovery++1. Back up the metadata database using your normal database backup procedure.+ - For external PostgreSQL, use a managed snapshot or a consistent PostgreSQL+ backup of the database referenced by `PG_URL`.+ - For embedded PostgreSQL, do not copy a live `pgdata` directory as a file+ backup. Use a consistent PostgreSQL backup, or stop Bytebase before taking+ a file-level snapshot.+2. Use the same Bytebase binary version as the deployment. The recovery command+ neither initializes nor migrates the metadata schema.+3. Stop every Bytebase server instance or replica connected to the metadata+ database. Keep them stopped until the recovery session exits so no process+ uses stale cached settings or IAM policies during recovery.+4. Reuse the deployment's metadata connection configuration. Recovery does not+ define a separate format. Follow the existing+ [Docker deployment guide](https://docs.bytebase.com/get-started/self-host/deploy-with-docker)+ for embedded data and port configuration, or+ [Configure External PostgreSQL](https://docs.bytebase.com/get-started/self-host/external-postgres)+ for `PG_URL`.+5. Run the command from an interactive terminal. It rejects redirected or+ otherwise non-terminal input and output.++## Start the recovery session++Run recovery with the same metadata connection configuration as the Bytebase+server:++```bash+bytebase recovery+```++For embedded PostgreSQL, include the deployment's `--data` and any custom+`--port`. For external PostgreSQL, make the deployment's `PG_URL` available to+the recovery process.++The command requires exactly one workspace in the metadata database, verifies+that it is active, resolves it automatically, and displays:++```text+Stop all Bytebase servers that use this metadata database before continuing.+Restart all Bytebase servers after recovery so they reload updated settings and IAM policies.++Select a recovery action:+1. Enable password sign-in+2. Reset user password+q. Exit+```++For an embedded deployment, the command connects to the metadata database when+available. Otherwise it starts only an existing initialized `pgdata` and stops+only the PostgreSQL instance it started itself. All Bytebase server processes+must remain stopped throughout the recovery session.++## Enable password sign-in++1. Select `1. Enable password sign-in`.+2. Confirm the change with `y`.+3. Wait for the completion message. The action verifies that the workspace has+ an effective, active end-user administrator with a password credential, then+ sets only `DisallowPasswordSignin` to `false` and records a warning audit+ event.+4. Restart all Bytebase servers so authentication reloads the updated workspace+ setting.+5. Sign in at `/auth` using the known administrator email and password.+6. Repair and verify the configured identity provider.+7. Re-enable **Disallow password sign-in** in the workspace authentication+ settings after federated sign-in works again.+8. Select `q. Exit` when no other recovery action is needed.++The action does not ask for an administrator email or password and does not+change any user, MFA configuration, IAM policy, or identity-provider setting.++## Reset a user password++1. Select `2. Reset user password`.+2. Enter the existing user's email. A blank email cancels the action.+3. Review the displayed workspace password requirements.+4. Enter the new password. Password input is hidden and is never accepted+ through a flag or environment variable. A policy violation explains the+ problem and prompts for the password again before confirmation.+5. Confirm the valid new password. A mismatch prompts for both entries again.+ Press `Ctrl+C` at either password prompt to exit recovery immediately.+6. Wait for the password completion message. The command validates the password+ before submitting it, and the recovery service validates it again before+ updating the credential and recording a warning audit event.+7. If the user is not a workspace member, choose whether to add the user. When+ confirmed, select one numbered role, verify the email and role,+ and confirm the IAM change. Role IDs are displayed for reference but are not+ entered manually. Declining leaves the completed password reset intact.+8. If password sign-in is disabled and this user is an administrator needed for+ recovery, select **Enable password sign-in** in the same session.+9. Restart all Bytebase servers so authentication reloads the updated+ credential, workspace setting, and IAM policy.+10. Sign in at `/auth` with the new password, repair and verify the identity+ provider, then re-enable **Disallow password sign-in**.+11. Select `q. Exit`.++The action accepts only an existing active end user. Existing effective+membership through a direct binding, group, or `allUsers` needs no IAM change.+For a user without effective membership, recovery can add exactly one selected+direct role while preserving unrelated IAM bindings. It does not create or+reactivate the user, clear MFA, change profile data, revoke refresh tokens, or+modify workspace settings.++Keep every Bytebase server stopped until the recovery session exits. Restarted+servers read the recovered credential, workspace setting, and IAM policy from+the metadata database without retaining a stale process-local cache.++## Troubleshooting++### Recovery requires terminal input and output++Run the command from a terminal. When running inside a container or remote+execution environment, allocate an interactive TTY. Do not pipe input into the+command because password entry must remain hidden.++### No usable workspace administrator exists++The enable action requires an effective, active end-user administrator with a+password credential. If such an administrator identity still exists but its+password is unknown, reset that identity's password and retry the enable action.+If an existing active user lost its administrator binding, reset the password,+confirm adding the user, and select **Workspace admin**. Recovery cannot create+or reactivate an identity.++### The user does not belong to the workspace++Verify the email. For an existing active end user, the reset action offers to+add one selected role. Missing, deleted, service-account, and workload-identity+targets remain rejected.++### The password is rejected++Choose a password that satisfies the deployment's password restriction.+If identity-domain enforcement is enabled, the email must also belong to an+allowed domain.++### The metadata database cannot be opened++Verify that the command uses the deployment's current Bytebase binary and the+same metadata connection configuration described in the deployment guides.+Recovery refuses an uninitialized embedded data directory and does not migrate+an old metadata schema.++### Multiple workspaces are found++Recovery is supported only for a self-hosted metadata database with exactly one+workspace, and that workspace must be active. The command does not infer+deployment mode from the process-local `--saas` flag because a separate recovery+process does not inherit the running server's flags. Verify that the command is+connected to the intended self-hosted metadata database.++## After recovery++1. Restart all Bytebase servers, then confirm the recovered administrator can+ sign in through `/auth`.+2. Verify the identity-provider configuration and federated sign-in.+3. Re-enable **Disallow password sign-in** if it was enabled before the outage.+4. Review the warning-level recovery audit events. They identify the operation+ and user email. IAM recovery events also identify the selected role. They+ must not contain a password, password hash, or metadata credential.+5. Confirm unrelated MFA configuration, IAM bindings, refresh tokens, profiles,+ and workspace settings remain unchanged. When membership recovery was used,+ confirm only the selected direct IAM binding was added.++## Related docs++- [Deploy with Docker](https://docs.bytebase.com/get-started/self-host/deploy-with-docker)+- [Configure External PostgreSQL](https://docs.bytebase.com/get-started/self-host/external-postgres)+- [High availability](./high-availability.md)+- [Upgrade guidance](./upgrade.md)diff --git a/docs/operations/high-availability.md b/docs/operations/high-availability.mdindex 60714b53a5..f6ab625465 100644--- a/docs/operations/high-availability.md+++ b/docs/operations/high-availability.md@@ -80,6 +80,19 @@ Use this checklist when enabling or validating HA:4. After adding or restarting replicas, allow at least 30 seconds for the active replica count to settle.5. Review logs for HA-license warnings before declaring the topology healthy.+## Administrator recovery++Stop every Bytebase replica before running the interactive administrator+recovery command. Run `bytebase recovery` with the exact same shared `PG_URL`+used by every replica. The command connects directly to the metadata database+and does not start an HTTP server, scheduler, or background runner. Restart all+replicas after recovery so they reload the updated settings and IAM policy.++Follow the [administrator recovery runbook](./admin-recovery.md) for backup,+terminal, action-selection, login, and cleanup requirements. Recovery is not an+alternative to HA licensing or replica coordination, and it does not repair the+deployment topology.+## Troubleshooting### `replicaCount` stays at `1`@@ -107,5 +120,6 @@ Stale heartbeat rows are cleaned up separately and do not define the active repl## Related docs+- [Administrator recovery](./admin-recovery.md)- [Upgrade guidance](./upgrade.md)- [Helm chart README](../../helm-charts/bytebase/README.md)diff --git a/frontend/src/app/SessionExpiredSurfaceGate.test.tsx b/frontend/src/app/SessionExpiredSurfaceGate.test.tsxindex 5fe4e2eaff..d26ec76058 100644--- a/frontend/src/app/SessionExpiredSurfaceGate.test.tsx+++ b/frontend/src/app/SessionExpiredSurfaceGate.test.tsx@@ -32,7 +32,6 @@ vi.mock("@/utils/auth", () => ({isAuthRelatedRoute: (name: string) =>["auth.signin",- "auth.signin.admin","auth.signup","auth.mfa","auth.password.reset",diff --git a/frontend/src/app/router/guard.test.ts b/frontend/src/app/router/guard.test.tsindex eb572168d1..5e5696da96 100644--- a/frontend/src/app/router/guard.test.ts+++ b/frontend/src/app/router/guard.test.ts@@ -150,6 +150,13 @@ describe("rootGuard", () => {expect(response.headers.get("Location")).toBe("/404");});+ test("/auth/admin matches the catch-all route", () => {+ const matched = matchRoutes(routes, "/auth/admin");+ const leafRoute = matched?.at(-1)?.route;+ const handle = leafRoute?.handle as { name?: string } | undefined;+ expect(handle?.name).toBe(WORKSPACE_ROUTE_404);+ });+test("oauth callback is allowed directly", () => {expect(run(AUTH_OAUTH_CALLBACK_MODULE, "/auth/oauth/callback")).toBeNull();});diff --git a/frontend/src/app/router/guard.ts b/frontend/src/app/router/guard.tsindex ecfd42969a..7625ced7a0 100644--- a/frontend/src/app/router/guard.ts+++ b/frontend/src/app/router/guard.ts@@ -14,7 +14,6 @@ import {AUTH_PASSWORD_FORGOT_MODULE,AUTH_PASSWORD_RESET_MODULE,AUTH_PROFILE_SETUP_MODULE,- AUTH_SIGNIN_ADMIN_MODULE,AUTH_SIGNIN_MODULE,AUTH_SIGNUP_MODULE,DATABASE_ROUTE_DASHBOARD,@@ -45,7 +44,6 @@ const SIGNIN_QUERY_PARAMS = [export function isAuthRelatedRoute(routeName: string): boolean {return [AUTH_SIGNIN_MODULE,- AUTH_SIGNIN_ADMIN_MODULE,AUTH_SIGNUP_MODULE,AUTH_MFA_MODULE,AUTH_PASSWORD_RESET_MODULE,diff --git a/frontend/src/app/router/handles.ts b/frontend/src/app/router/handles.tsindex 1ff891f11a..82ea0fd9b7 100644--- a/frontend/src/app/router/handles.ts+++ b/frontend/src/app/router/handles.ts@@ -37,7 +37,6 @@ export const WORKSPACE_ROUTE_404 = "error.404";// --- auth.ts ---export const AUTH_SIGNIN_MODULE = "auth.signin";-export const AUTH_SIGNIN_ADMIN_MODULE = "auth.signin.admin";export const AUTH_SIGNUP_MODULE = "auth.signup";export const AUTH_MFA_MODULE = "auth.mfa";export const AUTH_PASSWORD_RESET_MODULE = "auth.password.reset";diff --git a/frontend/src/app/router/routes/auth.tsx b/frontend/src/app/router/routes/auth.tsxindex 7207c00677..a3c0828800 100644--- a/frontend/src/app/router/routes/auth.tsx+++ b/frontend/src/app/router/routes/auth.tsx@@ -8,7 +8,6 @@ import {AUTH_PASSWORD_FORGOT_MODULE,AUTH_PASSWORD_RESET_MODULE,AUTH_PROFILE_SETUP_MODULE,- AUTH_SIGNIN_ADMIN_MODULE,AUTH_SIGNIN_MODULE,AUTH_SIGNUP_MODULE,OAUTH2_CONSENT_MODULE,@@ -56,14 +55,6 @@ export const authRoutes: RouteObject[] = [(m) => m.SigninPage),},- {- path: "admin",- handle: { name: AUTH_SIGNIN_ADMIN_MODULE },- lazy: lazyPage(- () => import("@/routes/auth/SigninAdminPage"),- (m) => m.SigninAdminPage- ),- },{path: "signup",handle: { name: AUTH_SIGNUP_MODULE },diff --git a/frontend/src/locales/en-US.json b/frontend/src/locales/en-US.jsonindex 8e3087e008..71e5c3be5a 100644--- a/frontend/src/locales/en-US.json+++ b/frontend/src/locales/en-US.json@@ -444,7 +444,6 @@"show-less": "Show less","show-more": "Show more","sign-in": "Sign in",- "sign-in-as-admin": "Sign in as administrator","sign-up": "Sign up","skip": "Skip","skipped": "Skipped",diff --git a/frontend/src/locales/es-ES.json b/frontend/src/locales/es-ES.jsonindex 97595ade8f..66cbe1808e 100644--- a/frontend/src/locales/es-ES.json+++ b/frontend/src/locales/es-ES.json@@ -444,7 +444,6 @@"show-less": "Mostrar menos","show-more": "Mostrar más","sign-in": "Iniciar sesión",- "sign-in-as-admin": "Iniciar sesión como administrador","sign-up": "Registrarse","skip": "Omitir","skipped": "Omitido",diff --git a/frontend/src/locales/ja-JP.json b/frontend/src/locales/ja-JP.jsonindex 7eb6aeb5e8..e64ff24a5d 100644--- a/frontend/src/locales/ja-JP.json+++ b/frontend/src/locales/ja-JP.json@@ -444,7 +444,6 @@"show-less": "折りたたむ","show-more": "もっと見る","sign-in": "ログイン",- "sign-in-as-admin": "管理者としてサインイン","sign-up": "登録する","skip": "スキップ","skipped": "スキップ",diff --git a/frontend/src/locales/vi-VN.json b/frontend/src/locales/vi-VN.jsonindex 201384444f..3753732b25 100644--- a/frontend/src/locales/vi-VN.json+++ b/frontend/src/locales/vi-VN.json@@ -444,7 +444,6 @@"show-less": "Thu gọn","show-more": "Hiển thị thêm","sign-in": "Đăng nhập",- "sign-in-as-admin": "Đăng nhập với tư cách quản trị viên","sign-up": "Đăng ký","skip": "Bỏ qua","skipped": "Đã bỏ qua",diff --git a/frontend/src/locales/zh-CN.json b/frontend/src/locales/zh-CN.jsonindex 04e8b3b5c0..5f6e17f343 100644--- a/frontend/src/locales/zh-CN.json+++ b/frontend/src/locales/zh-CN.json@@ -444,7 +444,6 @@"show-less": "收起","show-more": "显示更多","sign-in": "登录",- "sign-in-as-admin": "以管理员身份登录","sign-up": "注册","skip": "跳过","skipped": "已跳过",diff --git a/frontend/src/routes/auth/SigninAdminPage.tsx b/frontend/src/routes/auth/SigninAdminPage.tsxdeleted file mode 100644index 4bd28dfb40..0000000000--- a/frontend/src/routes/auth/SigninAdminPage.tsx+++ /dev/null@@ -1,42 +0,0 @@-import { useState } from "react";-import { useTranslation } from "react-i18next";-import { AuthFooter } from "@/components/auth/AuthFooter";-import { PasswordSigninForm } from "@/components/auth/PasswordSigninForm";-import { BytebaseLogo } from "@/components/BytebaseLogo";-import { useAppStore } from "@/stores/app";-import type { LoginRequest } from "@/types/proto-es/v1/auth_service_pb";--export function SigninAdminPage() {- const { t } = useTranslation();- const [isLoading, setIsLoading] = useState(false);-- const trySignin = async (request: LoginRequest) => {- if (isLoading) return;- setIsLoading(true);- try {- await useAppStore.getState().login({ request, redirect: true });- } finally {- setIsLoading(false);- }- };-- return (- <>- <div className="h-full flex flex-col justify-center mx-auto w-full max-w-sm">- <BytebaseLogo className="mx-auto mb-8" />-- <div className="rounded-sm border border-control-border bg-white p-6">- <p className="text-xl pl-1 font-medium mb-4">- {t("common.sign-in-as-admin")}- </p>- <PasswordSigninForm- loading={isLoading}- showForgotPassword={false}- onSignin={trySignin}- />- </div>- </div>- <AuthFooter />- </>- );-}diff --git a/frontend/src/types/proto-es/v1/actuator_service_pb.d.ts b/frontend/src/types/proto-es/v1/actuator_service_pb.d.tsindex a0c94c1477..a679d1916b 100644--- a/frontend/src/types/proto-es/v1/actuator_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/actuator_service_pb.d.ts@@ -61,7 +61,7 @@ export declare type Restriction = Message<"bytebase.v1.Restriction"> & {disallowSignup: boolean;/**- * Whether password-based signin is disabled (except for workspace admins).+ * Whether password sign-in is disabled for all end users.** @generated from field: bool disallow_password_signin = 2;*/diff --git a/frontend/src/types/proto-es/v1/setting_service_pb.d.ts b/frontend/src/types/proto-es/v1/setting_service_pb.d.tsindex a7cee08fd4..ff04836cc0 100644--- a/frontend/src/types/proto-es/v1/setting_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/setting_service_pb.d.ts@@ -554,7 +554,7 @@ export declare type WorkspaceProfileSetting = Message<"bytebase.v1.WorkspaceProfdatabaseChangeMode: DatabaseChangeMode;/**- * Whether to disallow password signin. (Except workspace admins)+ * Whether password sign-in is disabled for all end users.** @generated from field: bool disallow_password_signin = 10;*/diff --git a/frontend/src/utils/auth.ts b/frontend/src/utils/auth.tsindex efc8468d18..b71b29d6db 100644--- a/frontend/src/utils/auth.ts+++ b/frontend/src/utils/auth.ts@@ -5,7 +5,6 @@// ↔ @/types). The values mirror `@/app/router/handles`.const AUTH_RELATED_ROUTES = ["auth.signin",- "auth.signin.admin","auth.signup","auth.mfa","auth.password.reset",diff --git a/go.mod b/go.modindex d5fec45fc6..f0ee0575be 100644--- a/go.mod+++ b/go.mod@@ -95,6 +95,7 @@ require (go.uber.org/multierr v1.11.0golang.org/x/crypto v0.54.0golang.org/x/oauth2 v0.36.0+ golang.org/x/term v0.45.0golang.org/x/text v0.40.0google.golang.org/api v0.290.0google.golang.org/genproto v0.0.0-20260720211330-0afa2a65878a@@ -266,7 +267,6 @@ require (golang.org/x/mod v0.38.0 // indirectgolang.org/x/sys v0.47.0 // indirectgolang.org/x/telemetry v0.0.0-20260625142307-59b4966ccb57 // indirect- golang.org/x/term v0.45.0 // indirectgonum.org/v1/gonum v0.17.0 // indirectgopkg.in/go-jose/go-jose.v2 v2.6.3 // indirectgopkg.in/ini.v1 v1.67.0 // indirectdiff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex cb821f0473..aef1ac6329 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -28021,7 +28021,7 @@ components:disallowPasswordSignin:type: booleantitle: disallow_password_signin- description: Whether password-based signin is disabled (except for workspace admins).+ description: Whether password sign-in is disabled for all end users.readOnly: truepasswordRestriction:title: password_restriction@@ -32546,7 +32546,7 @@ components:disallowPasswordSignin:type: booleantitle: disallow_password_signin- description: Whether to disallow password signin. (Except workspace admins)+ description: Whether password sign-in is disabled for all end users.enableMetricCollection:type: booleantitle: enable_metric_collectiondiff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.mdindex 8700a1e1db..49367d080e 100644--- a/proto/gen/grpc-doc/store/README.md+++ b/proto/gen/grpc-doc/store/README.md@@ -4796,7 +4796,7 @@ All other settings live in per-workspace WORKSPACE_PROFILE.| domains | [string](#string) | repeated | The workspace domain, e.g., bytebase.com. || enforce_identity_domain | [bool](#bool) | | Only user and group from the domains can be created and login. || database_change_mode | [WorkspaceProfileSetting.DatabaseChangeMode](#bytebase-store-WorkspaceProfileSetting-DatabaseChangeMode) | | The workspace database change mode. |-| disallow_password_signin | [bool](#bool) | | Whether to disallow password signin. (Except workspace admins) |+| disallow_password_signin | [bool](#bool) | | Whether password sign-in is disabled for all end users. || enable_metric_collection | [bool](#bool) | | Whether to enable metric collection for the workspace. || inactive_session_timeout | [google.protobuf.Duration](#google-protobuf-Duration) | | The session expiration time if not activity detected for the user. Value <= 0 means no limit. || enable_audit_log_stdout | [bool](#bool) | | Whether to enable audit logging to stdout in structured JSON format. Requires TEAM or ENTERPRISE license. |diff --git a/proto/gen/grpc-doc/store/index.html b/proto/gen/grpc-doc/store/index.htmlindex 73a762a579..acdf1da199 100644--- a/proto/gen/grpc-doc/store/index.html+++ b/proto/gen/grpc-doc/store/index.html@@ -13109,7 +13109,7 @@ are /[a-z][0-9]-/. </p></td><td>disallow_password_signin</td><td><a href="#bool">bool</a></td><td></td>- <td><p>Whether to disallow password signin. (Except workspace admins) </p></td>+ <td><p>Whether password sign-in is disabled for all end users. </p></td></tr><tr>diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex 8ff78ebfc5..43506bccfa 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -4529,7 +4529,7 @@ For examples: resource.environment_id == "prod" && statement.aff| domains | [string](#string) | repeated | The workspace domain, e.g., bytebase.com. || enforce_identity_domain | [bool](#bool) | | Only user and group from the domains can be created and login. || database_change_mode | [DatabaseChangeMode](#bytebase-v1-DatabaseChangeMode) | | The workspace database change mode. |-| disallow_password_signin | [bool](#bool) | | Whether to disallow password signin. (Except workspace admins) |+| disallow_password_signin | [bool](#bool) | | Whether password sign-in is disabled for all end users. || enable_metric_collection | [bool](#bool) | | Whether to enable metric collection for the workspace. || inactive_session_timeout | [google.protobuf.Duration](#google-protobuf-Duration) | | The session expiration time if not activity detected for the user. Value <= 0 means no limit. || enable_audit_log_stdout | [bool](#bool) | | Whether to enable audit logging to stdout in structured JSON format. Requires TEAM or ENTERPRISE license. |@@ -4794,7 +4794,7 @@ Request message for getting actuator information.| Field | Type | Label | Description || ----- | ---- | ----- | ----------- || disallow_signup | [bool](#bool) | | Whether self-service user signup is disabled. |-| disallow_password_signin | [bool](#bool) | | Whether password-based signin is disabled (except for workspace admins). |+| disallow_password_signin | [bool](#bool) | | Whether password sign-in is disabled for all end users. || password_restriction | [WorkspaceProfileSetting.PasswordRestriction](#bytebase-v1-WorkspaceProfileSetting-PasswordRestriction) | | Password complexity and restriction requirements. || allow_email_code_signin | [bool](#bool) | | Whether email + 6-digit code signin is enabled for this workspace. || password_reset_enabled | [bool](#bool) | | Whether password reset via email is available for this workspace. True when the workspace (or deployment) has an email setting configured. |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex 9dbbd9af09..617dfe2a44 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -13131,7 +13131,7 @@ resource.table_name.matches("sensitive_.*") && resource.db_engin<td>disallow_password_signin</td><td><a href="#bool">bool</a></td><td></td>- <td><p>Whether to disallow password signin. (Except workspace admins) </p></td>+ <td><p>Whether password sign-in is disabled for all end users. </p></td></tr><tr>@@ -13997,7 +13997,7 @@ or no workspace-scoped fields are returned (SaaS). </p></td><td>disallow_password_signin</td><td><a href="#bool">bool</a></td><td></td>- <td><p>Whether password-based signin is disabled (except for workspace admins). </p></td>+ <td><p>Whether password sign-in is disabled for all end users. </p></td></tr><tr>diff --git a/proto/store/store/setting.proto b/proto/store/store/setting.protoindex bda00100cb..0d5843b886 100644--- a/proto/store/store/setting.proto+++ b/proto/store/store/setting.proto@@ -109,7 +109,7 @@ message WorkspaceProfileSetting {// The workspace database change mode.DatabaseChangeMode database_change_mode = 9;- // Whether to disallow password signin. (Except workspace admins)+ // Whether password sign-in is disabled for all end users.bool disallow_password_signin = 10;// Whether to enable metric collection for the workspace.diff --git a/proto/v1/v1/actuator_service.proto b/proto/v1/v1/actuator_service.protoindex 3c848009a0..c9485f4b00 100644--- a/proto/v1/v1/actuator_service.proto+++ b/proto/v1/v1/actuator_service.proto@@ -57,7 +57,7 @@ message Restriction {// Whether self-service user signup is disabled.bool disallow_signup = 1 [(google.api.field_behavior) = OUTPUT_ONLY];- // Whether password-based signin is disabled (except for workspace admins).+ // Whether password sign-in is disabled for all end users.bool disallow_password_signin = 2 [(google.api.field_behavior) = OUTPUT_ONLY];// Password complexity and restriction requirements.diff --git a/proto/v1/v1/setting_service.proto b/proto/v1/v1/setting_service.protoindex 9e818a4e45..d311e4c2c3 100644--- a/proto/v1/v1/setting_service.proto+++ b/proto/v1/v1/setting_service.proto@@ -216,7 +216,7 @@ message WorkspaceProfileSetting {// The workspace database change mode.DatabaseChangeMode database_change_mode = 9;- // Whether to disallow password signin. (Except workspace admins)+ // Whether password sign-in is disabled for all end users.bool disallow_password_signin = 10;// Whether to enable metric collection for the workspace.