Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

feat: recovery cmd (#21182)

ecmadao69ad91fd80ed
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yaml
index 2f9d8ce261..73f1fcd2f4 100644
--- a/backend/api/mcp/gen/openapi.yaml
+++ b/backend/api/mcp/gen/openapi.yaml
@@ -16979,7 +16979,7 @@ components:
disallowPasswordSignin:
type: boolean
title: 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_restriction
description: Password complexity and restriction requirements.
@@ -21335,7 +21335,7 @@ components:
disallowPasswordSignin:
type: boolean
title: 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: boolean
title: enable_metric_collection
diff --git a/backend/api/v1/auth_service.go b/backend/api/v1/auth_service.go
index 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.go
index 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.go
index 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.go
index 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 true
diff --git a/backend/bin/server/cmd/recovery.go b/backend/bin/server/cmd/recovery.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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.go
index 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.go
index 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.md
new file mode 100644
index 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.md
index 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.tsx
index 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.ts
index 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.ts
index 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.ts
index 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.tsx
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.tsx
deleted file mode 100644
index 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.ts
index 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.ts
index 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.WorkspaceProf
databaseChangeMode: 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.ts
index 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.mod
index d5fec45fc6..f0ee0575be 100644
--- a/go.mod
+++ b/go.mod
@@ -95,6 +95,7 @@ require (
go.uber.org/multierr v1.11.0
golang.org/x/crypto v0.54.0
golang.org/x/oauth2 v0.36.0
+ golang.org/x/term v0.45.0
golang.org/x/text v0.40.0
google.golang.org/api v0.290.0
google.golang.org/genproto v0.0.0-20260720211330-0afa2a65878a
@@ -266,7 +267,6 @@ require (
golang.org/x/mod v0.38.0 // indirect
golang.org/x/sys v0.47.0 // indirect
golang.org/x/telemetry v0.0.0-20260625142307-59b4966ccb57 // indirect
- golang.org/x/term v0.45.0 // indirect
gonum.org/v1/gonum v0.17.0 // indirect
gopkg.in/go-jose/go-jose.v2 v2.6.3 // indirect
gopkg.in/ini.v1 v1.67.0 // indirect
diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yaml
index cb821f0473..aef1ac6329 100644
--- a/proto/gen/grpc-doc/openapi.yaml
+++ b/proto/gen/grpc-doc/openapi.yaml
@@ -28021,7 +28021,7 @@ components:
disallowPasswordSignin:
type: boolean
title: 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: true
passwordRestriction:
title: password_restriction
@@ -32546,7 +32546,7 @@ components:
disallowPasswordSignin:
type: boolean
title: 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: boolean
title: enable_metric_collection
diff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.md
index 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 &lt;= 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.html
index 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.md
index 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 == &#34;prod&#34; &amp;&amp; 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 &lt;= 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 &#43; 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.html
index 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(&#34;sensitive_.*&#34;) &amp;&amp; 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.proto
index 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.proto
index 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.proto
index 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.