hookdeck-cli 0.6.2

package/pkg/cmd/whoami.go

@@ -0,0 +1,50 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/ansi"
+	"github.com/hookdeck/hookdeck-cli/pkg/login"
+	"github.com/hookdeck/hookdeck-cli/pkg/validators"
+	"github.com/spf13/cobra"
+)
+
+type whoamiCmd struct {
+	cmd         *cobra.Command
+	interactive bool
+}
+
+func newWhoamiCmd() *whoamiCmd {
+	lc := &whoamiCmd{}
+
+	lc.cmd = &cobra.Command{
+		Use:   "whoami",
+		Args:  validators.NoArgs,
+		Short: "Show the logged-in user",
+		RunE:  lc.runWhoamiCmd,
+	}
+
+	return lc
+}
+
+func (lc *whoamiCmd) runWhoamiCmd(cmd *cobra.Command, args []string) error {
+	key, err := Config.Profile.GetAPIKey()
+	if err != nil {
+		return err
+	}
+	response, err := login.ValidateKey(Config.APIBaseURL, key)
+	if err != nil {
+		return err
+	}
+
+	color := ansi.Color(os.Stdout)
+
+	fmt.Printf(
+		"Logged in as %s in workspace %s\n",
+		color.Bold(response.UserName),
+		color.Bold(response.TeamName),
+	)
+
+	return nil
+}

package/pkg/config/config.go

@@ -0,0 +1,326 @@
+package config
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/BurntSushi/toml"
+	"github.com/mitchellh/go-homedir"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
+	prefixed "github.com/x-cray/logrus-prefixed-formatter"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/ansi"
+)
+
+// ColorOn represnets the on-state for colors
+const ColorOn = "on"
+
+// ColorOff represents the off-state for colors
+const ColorOff = "off"
+
+// ColorAuto represents the auto-state for colors
+const ColorAuto = "auto"
+
+// Config handles all overall configuration for the CLI
+type Config struct {
+	Color            string
+	LogLevel         string
+	Profile          Profile
+	ProfilesFile     string
+	APIBaseURL       string
+	DashboardBaseURL string
+	ConsoleBaseURL   string
+	Insecure         bool
+}
+
+// GetConfigFolder retrieves the folder where the profiles file is stored
+// It searches for the xdg environment path first and will secondarily
+// place it in the home directory
+func (c *Config) GetConfigFolder(xdgPath string) string {
+	configPath := xdgPath
+
+	log.WithFields(log.Fields{
+		"prefix": "config.Config.GetProfilesFolder",
+		"path":   configPath,
+	}).Debug("Using profiles file")
+
+	if configPath == "" {
+		home, err := homedir.Dir()
+		if err != nil {
+			fmt.Println(err)
+			os.Exit(1)
+		}
+
+		configPath = filepath.Join(home, ".config")
+	}
+
+	return filepath.Join(configPath, "hookdeck")
+}
+
+// InitConfig reads in profiles file and ENV variables if set.
+func (c *Config) InitConfig() {
+	logFormatter := &prefixed.TextFormatter{
+		FullTimestamp:   true,
+		TimestampFormat: time.RFC1123,
+	}
+
+	c.Profile.Config = c
+
+	if c.ProfilesFile != "" {
+		viper.SetConfigFile(c.ProfilesFile)
+	} else {
+		configFolder := c.GetConfigFolder(os.Getenv("XDG_CONFIG_HOME"))
+		configFile := filepath.Join(configFolder, "config.toml")
+		c.ProfilesFile = configFile
+		viper.SetConfigType("toml")
+		viper.SetConfigFile(configFile)
+		viper.SetConfigPermissions(os.FileMode(0600))
+
+		// Try to change permissions manually, because we used to create files
+		// with default permissions (0644)
+		err := os.Chmod(configFile, os.FileMode(0600))
+		if err != nil && !os.IsNotExist(err) {
+			log.Fatalf("%s", err)
+		}
+	}
+
+	// If a profiles file is found, read it in.
+	if err := viper.ReadInConfig(); err == nil {
+		log.WithFields(log.Fields{
+			"prefix": "config.Config.InitConfig",
+			"path":   viper.ConfigFileUsed(),
+		}).Debug("Using profiles file")
+	}
+
+	if c.Profile.DeviceName == "" {
+		deviceName, err := os.Hostname()
+		if err != nil {
+			deviceName = "unknown"
+		}
+
+		c.Profile.DeviceName = deviceName
+	}
+
+	color, err := c.Profile.GetColor()
+	if err != nil {
+		log.Fatalf("%s", err)
+	}
+
+	switch color {
+	case ColorOn:
+		ansi.ForceColors = true
+		logFormatter.ForceColors = true
+	case ColorOff:
+		ansi.DisableColors = true
+		logFormatter.DisableColors = true
+	case ColorAuto:
+		// Nothing to do
+	default:
+		log.Fatalf("Unrecognized color value: %s. Expected one of on, off, auto.", c.Color)
+	}
+
+	log.SetFormatter(logFormatter)
+
+	// Set log level
+	switch c.LogLevel {
+	case "debug":
+		log.SetLevel(log.DebugLevel)
+	case "info":
+		log.SetLevel(log.InfoLevel)
+	case "warn":
+		log.SetLevel(log.WarnLevel)
+	case "error":
+		log.SetLevel(log.ErrorLevel)
+	default:
+		log.Fatalf("Unrecognized log level value: %s. Expected one of debug, info, warn, error.", c.LogLevel)
+	}
+}
+
+// EditConfig opens the configuration file in the default editor.
+func (c *Config) EditConfig() error {
+	var err error
+
+	fmt.Println("Opening config file:", c.ProfilesFile)
+
+	switch runtime.GOOS {
+	case "darwin", "linux":
+		editor := os.Getenv("EDITOR")
+		if editor == "" {
+			editor = "vi"
+		}
+
+		cmd := exec.Command(editor, c.ProfilesFile)
+		// Some editors detect whether they have control of stdin/out and will
+		// fail if they do not.
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+
+		return cmd.Run()
+	case "windows":
+		// As far as I can tell, Windows doesn't have an easily accesible or
+		// comparable option to $EDITOR, so default to notepad for now
+		err = exec.Command("notepad", c.ProfilesFile).Run()
+	default:
+		err = fmt.Errorf("unsupported platform")
+	}
+
+	return err
+}
+
+// PrintConfig outputs the contents of the configuration file.
+func (c *Config) PrintConfig() error {
+	if c.Profile.ProfileName == "default" {
+		configFile, err := ioutil.ReadFile(c.ProfilesFile)
+		if err != nil {
+			return err
+		}
+
+		fmt.Print(string(configFile))
+	} else {
+		configs := viper.GetStringMapString(c.Profile.ProfileName)
+
+		if len(configs) > 0 {
+			fmt.Printf("[%s]\n", c.Profile.ProfileName)
+			for field, value := range configs {
+				fmt.Printf("  %s=%s\n", field, value)
+			}
+		}
+	}
+
+	return nil
+}
+
+// RemoveProfile removes the profile whose name matches the provided
+// profileName from the config file.
+func (c *Config) RemoveProfile(profileName string) error {
+	runtimeViper := viper.GetViper()
+	var err error
+
+	for field, value := range runtimeViper.AllSettings() {
+		if isProfile(value) && field == profileName {
+			runtimeViper, err = removeKey(runtimeViper, field)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return syncConfig(runtimeViper)
+}
+
+// RemoveAllProfiles removes all the profiles from the config file.
+func (c *Config) RemoveAllProfiles() error {
+	runtimeViper := viper.GetViper()
+	var err error
+
+	for field, value := range runtimeViper.AllSettings() {
+		if isProfile(value) {
+			runtimeViper, err = removeKey(runtimeViper, field)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return syncConfig(runtimeViper)
+}
+
+// isProfile identifies whether a value in the config pertains to a profile.
+func isProfile(value interface{}) bool {
+	// TODO: ianjabour - ideally find a better way to identify projects in config
+	_, ok := value.(map[string]interface{})
+	return ok
+}
+
+// syncConfig merges a runtimeViper instance with the config file being used.
+func syncConfig(runtimeViper *viper.Viper) error {
+	runtimeViper.MergeInConfig()
+	profilesFile := viper.ConfigFileUsed()
+	runtimeViper.SetConfigFile(profilesFile)
+	// Ensure we preserve the config file type
+	runtimeViper.SetConfigType(filepath.Ext(profilesFile))
+
+	err := runtimeViper.WriteConfig()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Temporary workaround until https://github.com/spf13/viper/pull/519 can remove a key from viper
+func removeKey(v *viper.Viper, key string) (*viper.Viper, error) {
+	configMap := v.AllSettings()
+	path := strings.Split(key, ".")
+	lastKey := strings.ToLower(path[len(path)-1])
+	deepestMap := deepSearch(configMap, path[0:len(path)-1])
+	delete(deepestMap, lastKey)
+
+	buf := new(bytes.Buffer)
+
+	encodeErr := toml.NewEncoder(buf).Encode(configMap)
+	if encodeErr != nil {
+		return nil, encodeErr
+	}
+
+	nv := viper.New()
+	nv.SetConfigType("toml") // hint to viper that we've encoded the data as toml
+
+	err := nv.ReadConfig(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return nv, nil
+}
+
+func makePath(path string) error {
+	dir := filepath.Dir(path)
+
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		err = os.MkdirAll(dir, os.ModePerm)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// taken from https://github.com/spf13/viper/blob/master/util.go#L199,
+// we need this to delete configs, remove when viper supprts unset natively
+func deepSearch(m map[string]interface{}, path []string) map[string]interface{} {
+	for _, k := range path {
+		m2, ok := m[k]
+		if !ok {
+			// intermediate key does not exist
+			// => create it and continue from there
+			m3 := make(map[string]interface{})
+			m[k] = m3
+			m = m3
+
+			continue
+		}
+
+		m3, ok := m2.(map[string]interface{})
+		if !ok {
+			// intermediate key is a value
+			// => replace with a new map
+			m3 = make(map[string]interface{})
+			m[k] = m3
+		}
+
+		// continue search from here
+		m = m3
+	}
+
+	return m
+}

package/pkg/config/config_test.go

@@ -0,0 +1,20 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRemoveKey(t *testing.T) {
+	v := viper.New()
+	v.Set("remove", "me")
+	v.Set("stay", "here")
+
+	nv, err := removeKey(v, "remove")
+	require.NoError(t, err)
+
+	require.EqualValues(t, []string{"stay"}, nv.AllKeys())
+	require.ElementsMatch(t, []string{"stay", "remove"}, v.AllKeys())
+}

package/pkg/config/profile.go

@@ -0,0 +1,296 @@
+package config
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/spf13/viper"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/hookdeck"
+	"github.com/hookdeck/hookdeck-cli/pkg/validators"
+)
+
+// Profile handles all things related to managing the project specific configurations
+type Profile struct {
+	Config      *Config
+	DeviceName  string
+	ProfileName string
+	TeamName    string
+	TeamID      string
+	TeamMode    string
+	APIKey      string
+	ClientID    string
+	DisplayName string
+}
+
+type partialPollResponse struct {
+	TeamName string `json:"team_name"`
+}
+
+// CreateProfile creates a profile when logging in
+func (p *Profile) CreateProfile() error {
+	writeErr := p.writeProfile(viper.GetViper())
+	if writeErr != nil {
+		return writeErr
+	}
+
+	return nil
+}
+
+// GetColor gets the color setting for the user based on the flag or the
+// persisted color stored in the config file
+func (p *Profile) GetColor() (string, error) {
+	color := viper.GetString("color")
+	if color != "" {
+		return color, nil
+	}
+
+	color = viper.GetString(p.GetConfigField("color"))
+	switch color {
+	case "", ColorAuto:
+		return ColorAuto, nil
+	case ColorOn:
+		return ColorOn, nil
+	case ColorOff:
+		return ColorOff, nil
+	default:
+		return "", fmt.Errorf("color value not supported: %s", color)
+	}
+}
+
+// GetDeviceName returns the configured device name
+func (p *Profile) GetDeviceName() (string, error) {
+	if os.Getenv("HOOKDECK_DEVICE_NAME") != "" {
+		return os.Getenv("HOOKDECK_DEVICE_NAME"), nil
+	}
+
+	if p.DeviceName != "" {
+		return p.DeviceName, nil
+	}
+
+	if err := viper.ReadInConfig(); err == nil {
+		return viper.GetString(p.GetConfigField("device_name")), nil
+	}
+
+	return "", validators.ErrDeviceNameNotConfigured
+}
+
+// GetAPIKey will return the existing key for the given profile
+func (p *Profile) GetAPIKey() (string, error) {
+	envKey := os.Getenv("HOOKDECK_CLI_KEY")
+	if envKey != "" {
+		err := validators.APIKey(envKey)
+		if err != nil {
+			return "", err
+		}
+
+		return envKey, nil
+	}
+
+	if p.APIKey != "" {
+		err := validators.APIKey(p.APIKey)
+		if err != nil {
+			return "", err
+		}
+
+		return p.APIKey, nil
+	}
+
+	// Try to fetch the API key from the configuration file
+	if err := viper.ReadInConfig(); err == nil {
+		key := viper.GetString(p.GetConfigField("api_key"))
+
+		err := validators.APIKey(key)
+		if err != nil {
+			return "", err
+		}
+
+		return key, nil
+	}
+
+	return "", validators.ErrAPIKeyNotConfigured
+}
+
+// GetDisplayName returns the account display name of the user
+func (p *Profile) GetDisplayName() string {
+	if err := viper.ReadInConfig(); err == nil {
+		return viper.GetString(p.GetConfigField("display_name"))
+	}
+
+	return ""
+}
+
+func (p *Profile) GetTeamMode() string {
+	if p.TeamMode != "" {
+		return p.TeamMode
+	}
+	if err := viper.ReadInConfig(); err == nil {
+		return viper.GetString(p.GetConfigField("team_mode"))
+	}
+
+	return ""
+}
+
+func (p *Profile) GetTeamId() string {
+	if p.TeamID != "" {
+		return p.TeamID
+	}
+	if err := viper.ReadInConfig(); err == nil {
+		return viper.GetString(p.GetConfigField("team_id"))
+	}
+
+	return ""
+}
+
+func (p *Profile) refreshTeamName() string {
+	apiKey, err := p.GetAPIKey()
+	if err != nil {
+		panic(err)
+	}
+
+	parsedURL, err := url.Parse(p.Config.APIBaseURL + "/cli-auth/poll?key=" + apiKey)
+	if err != nil {
+		panic(err)
+	}
+
+	client := &hookdeck.Client{
+		BaseURL: parsedURL,
+	}
+
+	res, err := client.Get(context.TODO(), parsedURL.Path, parsedURL.Query().Encode(), nil)
+	if err != nil {
+		panic(err)
+	}
+
+	defer res.Body.Close()
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		panic(err)
+	}
+
+	var response partialPollResponse
+
+	err = json.Unmarshal(body, &response)
+	if err != nil {
+		panic(err)
+	}
+
+	p.TeamName = response.TeamName
+	p.CreateProfile()
+
+	return response.TeamName
+}
+
+// GetDisplayName returns the account display name of the team
+func (p *Profile) GetTeamName() string {
+	if err := viper.ReadInConfig(); err != nil {
+		return ""
+	}
+
+	teamName := viper.GetString(p.GetConfigField("team_name"))
+
+	if teamName == p.GetDisplayName() {
+		// Could be a bug where we used to store the display name in the
+		// team name field. But it could also be a legit team name that
+		// just happens to be the same as the user display name.
+		//
+		// Call the CLI poll endpoint to make sure.
+		teamName = p.refreshTeamName()
+	}
+
+	return teamName
+}
+
+// GetTerminalPOSDeviceID returns the device id from the config for Terminal quickstart to use
+func (p *Profile) GetTerminalPOSDeviceID() string {
+	if err := viper.ReadInConfig(); err == nil {
+		return viper.GetString(p.GetConfigField("terminal_pos_device_id"))
+	}
+
+	return ""
+}
+
+// GetConfigField returns the configuration field for the specific profile
+func (p *Profile) GetConfigField(field string) string {
+	return p.ProfileName + "." + field
+}
+
+// RegisterAlias registers an alias for a given key.
+func (p *Profile) RegisterAlias(alias, key string) {
+	viper.RegisterAlias(p.GetConfigField(alias), p.GetConfigField(key))
+}
+
+// WriteConfigField updates a configuration field and writes the updated
+// configuration to disk.
+func (p *Profile) WriteConfigField(field, value string) error {
+	viper.Set(p.GetConfigField(field), value)
+	return viper.WriteConfig()
+}
+
+// DeleteConfigField deletes a configuration field.
+func (p *Profile) DeleteConfigField(field string) error {
+	v, err := removeKey(viper.GetViper(), p.GetConfigField(field))
+	if err != nil {
+		return err
+	}
+
+	return p.writeProfile(v)
+}
+
+func (p *Profile) writeProfile(runtimeViper *viper.Viper) error {
+	profilesFile := viper.ConfigFileUsed()
+
+	err := makePath(profilesFile)
+	if err != nil {
+		return err
+	}
+
+	if p.DeviceName != "" {
+		runtimeViper.Set(p.GetConfigField("device_name"), strings.TrimSpace(p.DeviceName))
+	}
+
+	if p.APIKey != "" {
+		runtimeViper.Set(p.GetConfigField("api_key"), strings.TrimSpace(p.APIKey))
+	}
+
+	if p.ClientID != "" {
+		runtimeViper.Set(p.GetConfigField("client_id"), strings.TrimSpace(p.ClientID))
+	}
+
+	if p.DisplayName != "" {
+		runtimeViper.Set(p.GetConfigField("display_name"), strings.TrimSpace(p.DisplayName))
+	}
+
+	if p.TeamName != "" {
+		runtimeViper.Set(p.GetConfigField("team_name"), strings.TrimSpace(p.TeamName))
+	}
+
+	if p.TeamID != "" {
+		runtimeViper.Set(p.GetConfigField("team_id"), strings.TrimSpace(p.TeamID))
+	}
+
+	if p.TeamMode != "" {
+		runtimeViper.Set(p.GetConfigField("team_mode"), strings.TrimSpace(p.TeamMode))
+	}
+
+	runtimeViper.MergeInConfig()
+
+	runtimeViper.SetConfigFile(profilesFile)
+
+	// Ensure we preserve the config file type
+	runtimeViper.SetConfigType(filepath.Ext(profilesFile))
+
+	err = runtimeViper.WriteConfig()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}