Skip to content

Modern Docker Management, Designed for Everyone

8.5 KB
Raw Blame
package users

import (
	"cmp"
	"fmt"
	"net/http"
	"strings"

	"github.com/getarcaneapp/arcane/types/v2/user"
	"github.com/spf13/cobra"
	"go.getarcane.app/kit/pkg"

	"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
	"github.com/getarcaneapp/arcane/cli/v2/internal/output"
	"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)

// Command is the parent command for user operations
func Command() *cobra.Command {
	command := &cobra.Command{
		Use:     "users",
		Aliases: []string{"user", "usr"},
		Short:   "Manage users",
		Long:    "Manage users. Role assignments are managed separately via `arcane admin roles assign` — the legacy `--role` flag has been removed alongside the binary admin/user model.",
	}
	command.AddCommand(newListCmd())
	command.AddCommand(newCreateCmd())
	command.AddCommand(newGetCmd())
	command.AddCommand(newUpdateCmd())
	command.AddCommand(newDeleteCmd())
	return command
}

func newListCmd() *cobra.Command {
	var opts struct {
		limit int
		start int
		all   bool
	}
	command := &cobra.Command{
		Use:          "list",
		Aliases:      []string{"ls"},
		Short:        "List users",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.RunList(cmd, c, cmdutil.ListSpec[user.User]{
				Resource: "users",
				Endpoint: types.Users(),
				Params:   cmdutil.ListParams{Resource: "users", Limit: opts.limit, FallbackDefault: 20, Start: opts.start, All: opts.all},
				Headers:  []string{"ID", "USERNAME", "DISPLAY NAME", "EMAIL", "ROLE ASSIGNMENTS"},
				Row: func(usr user.User) []string {
					return []string{
						usr.ID,
						usr.Username,
						kit.FromPtr(usr.DisplayName),
						kit.FromPtr(usr.Email),
						roleAssignmentSummary(usr.RoleAssignments),
					}
				},
			})
		},
	}
	command.Flags().IntVarP(&opts.limit, "limit", "n", 20, "Number of users to show")
	command.Flags().IntVar(&opts.start, "start", 0, cmdutil.StartFlagUsage)
	command.Flags().BoolVarP(&opts.all, "all", "a", false, cmdutil.AllFlagUsage)
	return command
}

func newCreateCmd() *cobra.Command {
	var opts struct {
		username    string
		password    string
		displayName string
		email       string
	}
	command := &cobra.Command{
		Use:   "create",
		Short: "Create a new user",
		Long:  "Create a new user. The user is created without any role assignments — grant them via `arcane admin roles assign <userId>` after creation.",

		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			if opts.password == "" {
				if opts.password, err = output.Secret(cmd.Context(), cmd.InOrStdin(), cmd.ErrOrStderr(), "Password", "password"); err != nil {
					return fmt.Errorf("failed to read password: %w", err)
				}
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[user.User]{
				Method:         http.MethodPost,
				Path:           types.Users(),
				FailureMessage: "failed to create user",
				Body: user.CreateUser{
					Username:    opts.username,
					Password:    opts.password,
					DisplayName: kit.Ternary(cmd.Flags().Changed("display-name"), &opts.displayName, nil),
					Email:       kit.Ternary(cmd.Flags().Changed("email"), &opts.email, nil),
				},
				Render: func(data user.User) error {
					output.Success("User %s created successfully", data.Username)
					output.KeyValue("ID", data.ID)
					output.KeyValue("Username", data.Username)
					output.Info("No roles assigned. Use `arcane admin roles assign %s --role <roleId>` to grant access.", data.ID)
					return nil
				},
			})
		},
	}
	command.Flags().StringVar(&opts.username, "username", "", "Username")
	command.Flags().StringVar(&opts.password, "password", "", "Password (if omitted, will prompt securely)")
	command.Flags().StringVar(&opts.displayName, "display-name", "", "Display name")
	command.Flags().StringVar(&opts.email, "email", "", "Email address")
	_ = command.MarkFlagRequired("username")
	return command
}

func newGetCmd() *cobra.Command {
	return &cobra.Command{
		Use:          "get <user-id>",
		Short:        "Get user details",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[user.User]{
				Method:         http.MethodGet,
				Path:           types.User(args[0]),
				FailureMessage: "failed to get user",
				Render: func(data user.User) error {
					output.Header("User Details")
					output.KeyValue("ID", data.ID)
					output.KeyValue("Username", data.Username)
					if data.DisplayName != nil {
						output.KeyValue("Display Name", *data.DisplayName)
					}
					if data.Email != nil {
						output.KeyValue("Email", *data.Email)
					}
					output.KeyValue("Created", data.CreatedAt)

					output.KeyValue("Role Assignments", roleAssignmentSummary(data.RoleAssignments))
					if len(data.RoleAssignments) > 0 {
						rows := make([][]string, len(data.RoleAssignments))
						for i, a := range data.RoleAssignments {
							env := "global"
							if a.EnvironmentID != nil {
								env = *a.EnvironmentID
							}
							rows[i] = []string{a.RoleID, env, a.Source}
						}
						if tableErr := output.Table([]string{"ROLE", "SCOPE", "SOURCE"}, rows); tableErr != nil {
							return tableErr
						}
					}
					return nil
				},
			})
		},
	}
}

func newUpdateCmd() *cobra.Command {
	var opts struct {
		username    string
		displayName string
		email       string
	}
	command := &cobra.Command{
		Use:          "update <user-id>",
		Short:        "Update user profile (role assignments managed separately)",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[user.User]{
				Method:         http.MethodPut,
				Path:           types.User(args[0]),
				FailureMessage: "failed to update user",
				Body: user.UpdateUser{
					Username:    kit.Ternary(cmd.Flags().Changed("username"), &opts.username, nil),
					DisplayName: kit.Ternary(cmd.Flags().Changed("display-name"), &opts.displayName, nil),
					Email:       kit.Ternary(cmd.Flags().Changed("email"), &opts.email, nil),
				},
				Render: func(user.User) error {
					output.Success("User updated successfully")
					return nil
				},
			})
		},
	}
	command.Flags().StringVar(&opts.username, "username", "", "New username")
	command.Flags().StringVar(&opts.displayName, "display-name", "", "Display name")
	command.Flags().StringVar(&opts.email, "email", "", "Email address")
	return command
}

func newDeleteCmd() *cobra.Command {
	var opts struct {
		force bool
	}
	command := &cobra.Command{
		Use:          "delete <user-id>",
		Aliases:      []string{"rm", "remove"},
		Short:        "Delete user",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}
			return cmdutil.RunDelete(cmd, c, cmdutil.DeleteSpec{
				Force:          opts.force,
				Prompt:         fmt.Sprintf("Are you sure you want to delete user %s?", args[0]),
				Path:           types.User(args[0]),
				FailureMessage: "failed to delete user",
				SuccessMessage: "User deleted successfully",
			})
		},
	}
	command.Flags().BoolVarP(&opts.force, "force", "f", false, "Force deletion without confirmation")
	return command
}

func roleAssignmentSummary(assignments []user.RoleAssignmentSummary) string {
	type bucket struct {
		envScoped int
		hasGlobal bool
	}
	buckets := map[string]*bucket{}
	var order []string
	for _, a := range assignments {
		b, ok := buckets[a.RoleID]
		if !ok {
			b = &bucket{}
			buckets[a.RoleID] = b
			order = append(order, a.RoleID)
		}
		if a.EnvironmentID == nil {
			b.hasGlobal = true
		} else {
			b.envScoped++
		}
	}
	parts := make([]string, 0, len(order))
	for _, roleID := range order {
		b := buckets[roleID]
		switch {
		case b.hasGlobal && b.envScoped == 0:
			parts = append(parts, roleID+" (global)")
		case b.hasGlobal && b.envScoped > 0:
			parts = append(parts, fmt.Sprintf("%s (global +%d envs)", roleID, b.envScoped))
		case b.envScoped == 1:
			parts = append(parts, roleID+" on 1 env")
		default:
			parts = append(parts, fmt.Sprintf("%s on %d envs", roleID, b.envScoped))
		}
	}
	return cmp.Or(strings.Join(parts, ", "), "—")
}