hookdeck-cli 0.6.2

package/pkg/ansi/ansi.go

@@ -0,0 +1,208 @@
+package ansi
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/briandowns/spinner"
+	"github.com/logrusorgru/aurora"
+	"github.com/tidwall/pretty"
+	"golang.org/x/term"
+)
+
+var darkTerminalStyle = &pretty.Style{
+	Key:    [2]string{"\x1B[34m", "\x1B[0m"},
+	String: [2]string{"\x1B[30m", "\x1B[0m"},
+	Number: [2]string{"\x1B[94m", "\x1B[0m"},
+	True:   [2]string{"\x1B[35m", "\x1B[0m"},
+	False:  [2]string{"\x1B[35m", "\x1B[0m"},
+	Null:   [2]string{"\x1B[31m", "\x1B[0m"},
+}
+
+//
+// Public variables
+//
+
+// ForceColors forces the use of colors and other ANSI sequences.
+var ForceColors = false
+
+// DisableColors disables all colors and other ANSI sequences.
+var DisableColors = false
+
+// EnvironmentOverrideColors overs coloring based on `CLICOLOR` and
+// `CLICOLOR_FORCE`. Cf. https://bixense.com/clicolors/
+var EnvironmentOverrideColors = true
+
+//
+// Public functions
+//
+
+// Bold returns bolded text if the writer supports colors
+func Bold(text string) string {
+	color := Color(os.Stdout)
+	return color.Sprintf(color.Bold(text))
+}
+
+// Color returns an aurora.Aurora instance with colors enabled or disabled
+// depending on whether the writer supports colors.
+func Color(w io.Writer) aurora.Aurora {
+	return aurora.NewAurora(shouldUseColors(w))
+}
+
+// ColorizeJSON returns a colorized version of the input JSON, if the writer
+// supports colors.
+func ColorizeJSON(json string, darkStyle bool, w io.Writer) string {
+	if !shouldUseColors(w) {
+		return json
+	}
+
+	style := (*pretty.Style)(nil)
+	if darkStyle {
+		style = darkTerminalStyle
+	}
+
+	return string(pretty.Color([]byte(json), style))
+}
+
+// ColorizeStatus returns a colorized number for HTTP status code
+func ColorizeStatus(status int) aurora.Value {
+	color := Color(os.Stdout)
+
+	switch {
+	case status >= 500:
+		return color.Red(status).Bold()
+	case status >= 300:
+		return color.Yellow(status).Bold()
+	default:
+		return color.Green(status).Bold()
+	}
+}
+
+// Faint returns slightly offset color text if the writer supports it
+func Faint(text string) string {
+	color := Color(os.Stdout)
+	return color.Sprintf(color.Faint(text))
+}
+
+// Italic returns italicized text if the writer supports it.
+func Italic(text string) string {
+	color := Color(os.Stdout)
+	return color.Sprintf(color.Italic(text))
+}
+
+// Linkify returns an ANSI escape sequence with an hyperlink, if the writer
+// supports colors.
+func Linkify(text, url string, w io.Writer) string {
+	if !shouldUseColors(w) {
+		return text
+	}
+
+	// See https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
+	// for more information about this escape sequence.
+	return fmt.Sprintf("\x1b]8;;%s\x1b\\%s\x1b]8;;\x1b\\", url, text)
+}
+
+type charset = []string
+
+func getCharset() charset {
+	// See https://github.com/briandowns/spinner#available-character-sets for
+	// list of available charsets
+	if runtime.GOOS == "windows" {
+		// Less fancy, but uses ASCII characters so works with Windows default
+		// console.
+		return spinner.CharSets[8]
+	}
+	return spinner.CharSets[11]
+}
+
+const duration = time.Duration(100) * time.Millisecond
+
+// StartNewSpinner starts a new spinner with the given message. If the writer is not
+// a terminal or doesn't support colors, it simply prints the message.
+func StartNewSpinner(msg string, w io.Writer) *spinner.Spinner {
+	if !isTerminal(w) || !shouldUseColors(w) {
+		fmt.Fprintln(w, msg)
+		return nil
+	}
+
+	s := spinner.New(getCharset(), duration)
+	s.Writer = w
+
+	if msg != "" {
+		s.Suffix = " " + msg
+	}
+
+	s.Start()
+
+	return s
+}
+
+// StartSpinner updates an existing spinner's message, and starts it if it was stopped
+func StartSpinner(s *spinner.Spinner, msg string, w io.Writer) {
+	if s == nil {
+		fmt.Fprintln(w, msg)
+		return
+	}
+	if msg != "" {
+		s.Suffix = " " + msg
+	}
+	if !s.Active() {
+		s.Start()
+	}
+}
+
+// StopSpinner stops a spinner with the given message. If the writer is not
+// a terminal or doesn't support colors, it simply prints the message.
+func StopSpinner(s *spinner.Spinner, msg string, w io.Writer) {
+	if !isTerminal(w) || !shouldUseColors(w) {
+		fmt.Fprintln(w, msg)
+		return
+	}
+
+	if msg != "" {
+		s.FinalMSG = "> " + msg + "\n"
+	}
+
+	s.Stop()
+}
+
+// StrikeThrough returns struck though text if the writer supports colors
+func StrikeThrough(text string) string {
+	color := Color(os.Stdout)
+	return color.Sprintf(color.StrikeThrough(text))
+}
+
+//
+// Private functions
+//
+
+func isTerminal(w io.Writer) bool {
+	switch v := w.(type) {
+	case *os.File:
+		return term.IsTerminal(int(v.Fd()))
+	default:
+		return false
+	}
+}
+
+func shouldUseColors(w io.Writer) bool {
+	useColors := ForceColors || isTerminal(w)
+
+	if EnvironmentOverrideColors {
+		force, ok := os.LookupEnv("CLICOLOR_FORCE")
+
+		switch {
+		case ok && force != "0":
+			useColors = true
+		case ok && force == "0":
+			useColors = false
+		case os.Getenv("CLICOLOR") == "0":
+			useColors = false
+		}
+	}
+
+	return useColors && !DisableColors
+}

package/pkg/ansi/init_windows.go

@@ -0,0 +1,23 @@
+// +build windows
+
+package ansi
+
+import (
+	"os"
+
+	"golang.org/x/sys/windows"
+)
+
+// enableAnsiColors enables support for ANSI color sequences in Windows
+// default console. Note that this only works with Windows 10.
+func enableAnsiColors() {
+	stdout := windows.Handle(os.Stdout.Fd())
+	var originalMode uint32
+
+	windows.GetConsoleMode(stdout, &originalMode)
+	windows.SetConsoleMode(stdout, originalMode|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+}
+
+func init() {
+	enableAnsiColors()
+}

package/pkg/cmd/completion.go

@@ -0,0 +1,128 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"runtime"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/validators"
+)
+
+type completionCmd struct {
+	cmd *cobra.Command
+
+	shell string
+}
+
+func newCompletionCmd() *completionCmd {
+	cc := &completionCmd{}
+
+	cc.cmd = &cobra.Command{
+		Use:   "completion",
+		Short: "Generate bash and zsh completion scripts",
+		Args:  validators.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return selectShell(cc.shell)
+		},
+	}
+
+	cc.cmd.Flags().StringVar(&cc.shell, "shell", "", "The shell to generate completion commands for. Supports \"bash\" or \"zsh\"")
+
+	return cc
+}
+
+const (
+	instructionsHeader = `
+Suggested next steps:
+---------------------`
+
+	zshCompletionInstructions = `
+1. Move ` + "`hookdeck-completion.zsh`" + ` to the correct location:
+    mkdir -p ~/.hookdeck
+    mv hookdeck-completion.zsh ~/.hookdeck
+
+2. Add the following lines to your ` + "`.zshrc`" + ` enabling shell completion for Hookdeck:
+    fpath=(~/.hookdeck $fpath)
+    autoload -Uz compinit && compinit -i
+
+3. Source your ` + "`.zshrc`" + ` or open a new terminal session:
+    source ~/.zshrc`
+
+	bashCompletionInstructionsMac = `
+Set up bash autocompletion on your system:
+1. Install the bash autocompletion package:
+     brew install bash-completion
+2. Follow the post-install instructions displayed by Homebrew; add a line like the following to your bash profile:
+     [[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . "/usr/local/etc/profile.d/bash_completion.sh"
+
+Set up Hookdeck autocompletion:
+3. Move ` + "`hookdeck-completion.bash`" + ` to the correct location:
+    mkdir -p ~/.hookdeck
+    mv hookdeck-completion.bash ~/.hookdeck
+
+4. Add the following line to your bash profile, so that Hookdeck autocompletion will be enabled every time you start a new terminal session:
+    source ~/.hookdeck/hookdeck-completion.bash
+
+5. Either restart your terminal, or run the following command in your current session to enable immediately:
+    source ~/.hookdeck/hookdeck-completion.bash`
+
+	bashCompletionInstructionsLinux = `
+1. Ensure bash autocompletion is installed on your system. Often, this means verifying that ` + "`/etc/profile.d/bash_completion.sh`" + ` exists, and is sourced by your bash profile; the location of this file varies across distributions of Linux.
+
+2. Move ` + "`hookdeck-completion.bash`" + ` to the correct location:
+    mkdir -p ~/.hookdeck
+    mv hookdeck-completion.bash ~/.hookdeck
+
+3. Add the following line to your bash profile, so that Hookdeck autocompletion will be enabled every time you start a new terminal session:
+    source ~/.hookdeck/hookdeck-completion.bash
+
+4. Either restart your terminal, or run the following command in your current session to enable immediately:
+    source ~/.hookdeck/hookdeck-completion.bash`
+)
+
+func selectShell(shell string) error {
+	selected := shell
+	if selected == "" {
+		selected = detectShell()
+	}
+
+	switch {
+	case selected == "zsh":
+		fmt.Println("Detected `zsh`, generating zsh completion file: hookdeck-completion.zsh")
+		err := rootCmd.GenZshCompletionFile("hookdeck-completion.zsh")
+		if err == nil {
+			fmt.Printf("%s%s\n", instructionsHeader, zshCompletionInstructions)
+		}
+		return err
+	case selected == "bash":
+		fmt.Println("Detected `bash`, generating bash completion file: hookdeck-completion.bash")
+		err := rootCmd.GenBashCompletionFile("hookdeck-completion.bash")
+		if err == nil {
+			if runtime.GOOS == "darwin" {
+				fmt.Printf("%s%s\n", instructionsHeader, bashCompletionInstructionsMac)
+			} else if runtime.GOOS == "linux" {
+				fmt.Printf("%s%s\n", instructionsHeader, bashCompletionInstructionsLinux)
+			}
+		}
+		return err
+	default:
+		return fmt.Errorf("Could not automatically detect your shell. Please run the command with the `--shell` flag for either bash or zsh")
+	}
+}
+
+func detectShell() string {
+	shell := os.Getenv("SHELL")
+
+	switch {
+	case strings.Contains(shell, "zsh"):
+		return "zsh"
+	case strings.Contains(shell, "bash"):
+		return "bash"
+	default:
+		return ""
+	}
+}

package/pkg/cmd/listen.go

@@ -0,0 +1,114 @@
+/*
+Copyright © 2020 NAME HERE <EMAIL ADDRESS>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package cmd
+
+import (
+	"errors"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/hookdeck"
+	"github.com/hookdeck/hookdeck-cli/pkg/listen"
+	"github.com/spf13/cobra"
+)
+
+type listenCmd struct {
+	cmd       *cobra.Command
+	wsBaseURL string
+	noWSS     bool
+}
+
+func newListenCmd() *listenCmd {
+	lc := &listenCmd{}
+
+	lc.cmd = &cobra.Command{
+		Use:   "listen",
+		Short: "Forward webhooks for a source to your local server",
+		Args: func(cmd *cobra.Command, args []string) error {
+			if len(args) < 1 {
+				return errors.New("Requires a port or forwarding URL to foward the webhooks to")
+			}
+
+			_, err_port := strconv.ParseInt(args[0], 10, 64)
+
+			var parsed_url *url.URL
+			var err_url error
+			if strings.HasPrefix(args[0], "http") {
+				parsed_url, err_url = url.Parse(args[0])
+			} else {
+				parsed_url, err_url = url.Parse("http://" + args[0])
+			}
+
+			if err_port != nil && err_url != nil {
+				return errors.New("Argument is not a valid port or forwading URL")
+			}
+
+			if err_port != nil {
+				if parsed_url.Host == "" {
+					return errors.New("Forwarding URL must contain a host.")
+				}
+
+				if parsed_url.RawQuery != "" {
+					return errors.New("Forwarding URL cannot contain query params.")
+				}
+			}
+
+			if len(args) > 3 {
+				return errors.New("Invalid extra argument provided")
+			}
+
+			return nil
+		},
+		RunE: lc.runListenCmd,
+	}
+	lc.cmd.Flags().StringVar(&lc.wsBaseURL, "ws-base", hookdeck.DefaultWebsocektURL, "Sets the Websocket base URL")
+	lc.cmd.Flags().BoolVar(&lc.noWSS, "no-wss", false, "Force unencrypted ws:// protocol instead of wss://")
+
+	return lc
+}
+
+// listenCmd represents the listen command
+func (lc *listenCmd) runListenCmd(cmd *cobra.Command, args []string) error {
+	var source_alias, connection_query string
+	if len(args) > 1 {
+		source_alias = args[1]
+	}
+	if len(args) > 2 {
+		connection_query = args[2]
+	}
+
+	_, err_port := strconv.ParseInt(args[0], 10, 64)
+	var url *url.URL
+	if err_port != nil {
+		if strings.HasPrefix(args[0], "http") {
+			url, _ = url.Parse(args[0])
+		} else {
+			url, _ = url.Parse("http://" + args[0])
+		}
+	} else {
+		url, _ = url.Parse("http://localhost:" + args[0])
+	}
+
+	if url.Scheme == "" {
+		url.Scheme = "http"
+	}
+
+	return listen.Listen(url, source_alias, connection_query, listen.Flags{
+		WSBaseURL: lc.wsBaseURL,
+		NoWSS:     lc.noWSS,
+	}, &Config)
+}

package/pkg/cmd/login.go

@@ -0,0 +1,37 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/login"
+	"github.com/hookdeck/hookdeck-cli/pkg/validators"
+)
+
+type loginCmd struct {
+	cmd         *cobra.Command
+	interactive bool
+}
+
+func newLoginCmd() *loginCmd {
+	lc := &loginCmd{}
+
+	lc.cmd = &cobra.Command{
+		Use:   "login",
+		Args:  validators.NoArgs,
+		Short: "Login to your Hookdeck account",
+		Long:  `Login to your Hookdeck account to setup the CLI`,
+		RunE:  lc.runLoginCmd,
+	}
+	lc.cmd.Flags().BoolVarP(&lc.interactive, "interactive", "i", false, "Run interactive configuration mode if you cannot open a browser")
+
+	return lc
+}
+
+func (lc *loginCmd) runLoginCmd(cmd *cobra.Command, args []string) error {
+	if lc.interactive {
+		return login.InteractiveLogin(&Config)
+	}
+	return login.Login(&Config, os.Stdin)
+}

package/pkg/cmd/logout.go

@@ -0,0 +1,35 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/logout"
+	"github.com/hookdeck/hookdeck-cli/pkg/validators"
+)
+
+type logoutCmd struct {
+	cmd *cobra.Command
+	all bool
+}
+
+func newLogoutCmd() *logoutCmd {
+	lc := &logoutCmd{}
+
+	lc.cmd = &cobra.Command{
+		Use:   "logout",
+		Args:  validators.NoArgs,
+		Short: "Logout of your Hookdeck account",
+		Long:  `Logout of your Hookdeck account to setup the CLI`,
+		RunE:  lc.runLogoutCmd,
+	}
+	lc.cmd.Flags().BoolVarP(&lc.all, "all", "a", false, "Clear credentials for all projects you are currently logged into.")
+
+	return lc
+}
+
+func (lc *logoutCmd) runLogoutCmd(cmd *cobra.Command, args []string) error {
+	if lc.all {
+		return logout.All(&Config)
+	}
+	return logout.Logout(&Config)
+}

package/pkg/cmd/root.go

@@ -0,0 +1,112 @@
+/*
+Copyright © 2020 NAME HERE <EMAIL ADDRESS>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"unicode"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/config"
+	"github.com/hookdeck/hookdeck-cli/pkg/hookdeck"
+	"github.com/hookdeck/hookdeck-cli/pkg/validators"
+	"github.com/hookdeck/hookdeck-cli/pkg/version"
+	"github.com/spf13/cobra"
+)
+
+var cfgFile string
+
+var Config config.Config
+
+var rootCmd = &cobra.Command{
+	Use:           "hookdeck",
+	SilenceUsage:  true,
+	SilenceErrors: true,
+	Version:       version.Version,
+	Short:         "A CLI to forward webhooks received on Hookdeck to your local server.",
+}
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		errString := err.Error()
+		isLoginRequiredError := errString == validators.ErrAPIKeyNotConfigured.Error() || errString == validators.ErrDeviceNameNotConfigured.Error()
+
+		switch {
+		case isLoginRequiredError:
+			// capitalize first letter of error because linter
+			errRunes := []rune(errString)
+			errRunes[0] = unicode.ToUpper(errRunes[0])
+
+			fmt.Printf("%s. Running `hookdeck login`...\n", string(errRunes))
+			loginCommand, _, err := rootCmd.Find([]string{"login"})
+
+			if err != nil {
+				fmt.Println(err)
+			}
+
+			err = loginCommand.RunE(&cobra.Command{}, []string{})
+
+			if err != nil {
+				fmt.Println(err)
+			}
+
+		case strings.Contains(errString, "unknown command"):
+			suggStr := "\nS"
+
+			suggestions := rootCmd.SuggestionsFor(os.Args[1])
+			if len(suggestions) > 0 {
+				suggStr = fmt.Sprintf(" Did you mean \"%s\"?\nIf not, s", suggestions[0])
+			}
+
+			fmt.Println(fmt.Sprintf("Unknown command \"%s\" for \"%s\".%s"+
+				"ee \"hookdeck --help\" for a list of available commands.",
+				os.Args[1], rootCmd.CommandPath(), suggStr))
+
+		default:
+			fmt.Println(err)
+		}
+
+		os.Exit(1)
+	}
+}
+
+func init() {
+	cobra.OnInitialize(Config.InitConfig)
+
+	rootCmd.PersistentFlags().StringVar(&Config.Profile.APIKey, "cli-key", "", "Your CLI key to use for the command")
+	rootCmd.PersistentFlags().StringVar(&Config.Color, "color", "", "turn on/off color output (on, off, auto)")
+	rootCmd.PersistentFlags().StringVar(&Config.ProfilesFile, "config", "", "config file (default is $HOME/.config/hookdeck/config.toml)")
+	rootCmd.PersistentFlags().StringVar(&Config.Profile.DeviceName, "device-name", "", "device name")
+	rootCmd.PersistentFlags().StringVar(&Config.LogLevel, "log-level", "info", "log level (debug, info, warn, error)")
+	rootCmd.PersistentFlags().BoolVar(&Config.Insecure, "insecure", false, "Allow invalid TLS certificates")
+	rootCmd.PersistentFlags().StringVarP(&Config.Profile.ProfileName, "project-name", "p", "default", "the project name to read from for config")
+
+	// Hidden configuration flags, useful for dev/debugging
+	rootCmd.PersistentFlags().StringVar(&Config.APIBaseURL, "api-base", hookdeck.DefaultAPIBaseURL, "Sets the API base URL")
+	rootCmd.PersistentFlags().StringVar(&Config.DashboardBaseURL, "dashboard-base", hookdeck.DefaultDashboardBaseURL, "Sets the web dashboard base URL")
+	rootCmd.PersistentFlags().StringVar(&Config.ConsoleBaseURL, "console-base", hookdeck.DefaultConsoleBaseURL, "Sets the web console base URL")
+
+	rootCmd.Flags().BoolP("version", "v", false, "Get the version of the Hookdeck CLI")
+
+	rootCmd.AddCommand(newLoginCmd().cmd)
+	rootCmd.AddCommand(newLogoutCmd().cmd)
+	rootCmd.AddCommand(newListenCmd().cmd)
+	rootCmd.AddCommand(newCompletionCmd().cmd)
+	rootCmd.AddCommand(newWhoamiCmd().cmd)
+}

package/pkg/cmd/version.go

@@ -0,0 +1,25 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/validators"
+	"github.com/hookdeck/hookdeck-cli/pkg/version"
+)
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Args:  validators.NoArgs,
+	Short: "Get the version of the Hookdeck CLI",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Print(version.Template)
+
+		version.CheckLatestVersion()
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(versionCmd)
+}