hookdeck-cli 0.6.2

package/pkg/hookdeck/sources.go

@@ -0,0 +1,73 @@
+package hookdeck
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+type Source struct {
+	Id    string
+	Alias string
+	Label string
+	Url   string
+}
+
+type CreateSourceInput struct {
+	Alias string `json:"alias"`
+	Label string `json:"label"`
+}
+
+type SourceList struct {
+	Count  int
+	Models []Source
+}
+
+func (c *Client) GetSourceByAlias(alias string) (Source, error) {
+	res, err := c.Get(context.Background(), "/sources", "alias="+alias, nil)
+	if err != nil {
+		return Source{}, err
+	}
+	if res.StatusCode != http.StatusOK {
+		return Source{}, fmt.Errorf("unexpected http status code: %d %s", res.StatusCode, err)
+	}
+	sources := SourceList{}
+	postprocessJsonResponse(res, &sources)
+
+	if len(sources.Models) > 0 {
+		return sources.Models[0], nil
+	}
+	return Source{}, nil
+}
+
+func (c *Client) ListSources() ([]Source, error) {
+	res, err := c.Get(context.Background(), "/sources", "", nil)
+	if err != nil {
+		return []Source{}, err
+	}
+	if res.StatusCode != http.StatusOK {
+		return []Source{}, fmt.Errorf("unexpected http status code: %d %s", res.StatusCode, err)
+	}
+	sources := SourceList{}
+	postprocessJsonResponse(res, &sources)
+
+	return sources.Models, nil
+}
+
+func (c *Client) CreateSource(input CreateSourceInput) (Source, error) {
+	input_bytes, err := json.Marshal(input)
+	if err != nil {
+		return Source{}, err
+	}
+	res, err := c.Post(context.Background(), "/sources", input_bytes, nil)
+	if err != nil {
+		return Source{}, err
+	}
+	if res.StatusCode != http.StatusOK {
+		return Source{}, fmt.Errorf("unexpected http status code: %d %s", res.StatusCode, err)
+	}
+	source := Source{}
+	postprocessJsonResponse(res, &source)
+	return source, nil
+}

package/pkg/hookdeck/telemetry.go

@@ -0,0 +1,84 @@
+package hookdeck
+
+import (
+	"encoding/json"
+	"strings"
+	"sync"
+
+	"github.com/spf13/cobra"
+)
+
+//
+// Public types
+//
+
+// CLITelemetry is the structure that holds telemetry data sent to Hookdeck in
+// API requests.
+type CLITelemetry struct {
+	CommandPath       string `json:"command_path"`
+	DeviceName        string `json:"device_name"`
+	GeneratedResource bool   `json:"generated_resource"`
+}
+
+// SetCommandContext sets the telemetry values for the command being executed.
+func (t *CLITelemetry) SetCommandContext(cmd *cobra.Command) {
+	t.CommandPath = cmd.CommandPath()
+	t.GeneratedResource = false
+
+	for _, value := range cmd.Annotations {
+		// Generated commands have an annotation called "operation", we can
+		// search for that to let us know it's generated
+		if value == "operation" {
+			t.GeneratedResource = true
+		}
+	}
+}
+
+// SetDeviceName puts the device name into telemetry
+func (t *CLITelemetry) SetDeviceName(deviceName string) {
+	t.DeviceName = deviceName
+}
+
+//
+// Public functions
+//
+
+// GetTelemetryInstance returns the CLITelemetry instance (initializing it
+// first if necessary).
+func GetTelemetryInstance() *CLITelemetry {
+	once.Do(func() {
+		instance = &CLITelemetry{}
+	})
+
+	return instance
+}
+
+//
+// Private variables
+//
+
+var instance *CLITelemetry
+var once sync.Once
+
+//
+// Private functions
+//
+
+func getTelemetryHeader() (string, error) {
+	telemetry := GetTelemetryInstance()
+	b, err := json.Marshal(telemetry)
+
+	if err != nil {
+		return "", err
+	}
+
+	return string(b), nil
+}
+
+// telemetryOptedOut returns true if the user has opted out of telemetry,
+// false otherwise.
+func telemetryOptedOut(optoutVar string) bool {
+	optoutVar = strings.ToLower(optoutVar)
+
+	return optoutVar == "1" || optoutVar == "true"
+}

package/pkg/hookdeck/telemetry_test.go

@@ -0,0 +1,35 @@
+package hookdeck
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetTelemetryInstance(t *testing.T) {
+	t1 := GetTelemetryInstance()
+	t2 := GetTelemetryInstance()
+	require.Equal(t, t1, t2)
+}
+
+func TestSetCommandContext(t *testing.T) {
+	tel := GetTelemetryInstance()
+	cmd := &cobra.Command{
+		Use: "foo",
+	}
+	tel.SetCommandContext(cmd)
+	require.Equal(t, "foo", tel.CommandPath)
+}
+
+func TestTelemetryOptedOut(t *testing.T) {
+	require.False(t, telemetryOptedOut(""))
+	require.False(t, telemetryOptedOut("0"))
+	require.False(t, telemetryOptedOut("false"))
+	require.False(t, telemetryOptedOut("False"))
+	require.False(t, telemetryOptedOut("FALSE"))
+	require.True(t, telemetryOptedOut("1"))
+	require.True(t, telemetryOptedOut("true"))
+	require.True(t, telemetryOptedOut("True"))
+	require.True(t, telemetryOptedOut("TRUE"))
+}

package/pkg/hookdeck/verbosetransport.go

@@ -0,0 +1,82 @@
+package hookdeck
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/ansi"
+)
+
+// inspectHeaders is the whitelist of headers that will be printed.
+var inspectHeaders = []string{
+	"Authorization",
+	"Content-Type",
+	"Date",
+	"Idempotency-Key",
+	"Idempotency-Replayed",
+	"Request-Id",
+	"Hookdeck-Account",
+	"Hookdeck-Version",
+}
+
+type verboseTransport struct {
+	Transport *http.Transport
+	Verbose   bool
+	Out       io.Writer
+}
+
+func (t *verboseTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	if t.Verbose {
+		t.dumpRequest(req)
+	}
+
+	resp, err = t.Transport.RoundTrip(req)
+
+	if err == nil && t.Verbose {
+		t.dumpResponse(resp)
+	}
+
+	return
+}
+
+func (t *verboseTransport) dumpRequest(req *http.Request) {
+	info := fmt.Sprintf("> %s %s://%s%s", req.Method, req.URL.Scheme, req.URL.Host, req.URL.RequestURI())
+	t.verbosePrintln(info)
+	t.dumpHeaders(req.Header, ">")
+}
+
+func (t *verboseTransport) dumpResponse(resp *http.Response) {
+	info := fmt.Sprintf("< HTTP %d", resp.StatusCode)
+	t.verbosePrintln(info)
+	t.dumpHeaders(resp.Header, "<")
+}
+
+func (t *verboseTransport) dumpHeaders(header http.Header, indent string) {
+	for _, listed := range inspectHeaders {
+		for name, vv := range header {
+			if !strings.EqualFold(name, listed) {
+				continue
+			}
+
+			for _, v := range vv {
+				if v != "" {
+					r := regexp.MustCompile("(?i)^(basic|bearer) (.+)")
+					if r.MatchString(v) {
+						v = r.ReplaceAllString(v, "$1 [REDACTED]")
+					}
+
+					info := fmt.Sprintf("%s %s: %s", indent, name, v)
+					t.verbosePrintln(info)
+				}
+			}
+		}
+	}
+}
+
+func (t *verboseTransport) verbosePrintln(msg string) {
+	color := ansi.Color(t.Out)
+	fmt.Fprintln(t.Out, color.Cyan(msg))
+}

package/pkg/hookdeck/verbosetransport_test.go

@@ -0,0 +1,47 @@
+package hookdeck
+
+import (
+	"bytes"
+	"net/http"
+	"net/http/httptest"
+	"regexp"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestVerboseTransport_Verbose(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Request-Id", "req_123")
+		w.Header().Set("Non-Whitelisted-Header", "foo")
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer ts.Close()
+
+	var b bytes.Buffer
+
+	httpTransport := &http.Transport{}
+	tr := &verboseTransport{
+		Transport: httpTransport,
+		Verbose:   true,
+		Out:       &b,
+	}
+	client := &http.Client{Transport: tr}
+	req, err := http.NewRequest("POST", ts.URL+"/test", nil)
+	require.NoError(t, err)
+	req.Header.Set("Authorization", "Bearer token")
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+
+	defer resp.Body.Close()
+
+	out := b.String()
+	require.Regexp(t, regexp.MustCompile("> POST http://(.+)/test\n"), out)
+	require.Contains(t, out, "> Authorization: Bearer [REDACTED]\n")
+	require.Contains(t, out, "> Content-Type: application/x-www-form-urlencoded\n")
+	require.Contains(t, out, "< HTTP 200\n")
+	require.Contains(t, out, "< Request-Id: req_123\n")
+	require.NotContains(t, out, "Non-Whitelisted-Header")
+}

package/pkg/listen/connection.go

@@ -0,0 +1,91 @@
+package listen
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/gosimple/slug"
+	"github.com/hookdeck/hookdeck-cli/pkg/hookdeck"
+)
+
+func getConnections(client *hookdeck.Client, source hookdeck.Source, connection_query string) ([]hookdeck.Connection, error) {
+	// TODO: Filter connections using connection_query
+	var connections []hookdeck.Connection
+	connections, err := client.ListConnectionsBySource(source.Id)
+	if err != nil {
+		return connections, err
+	}
+
+	var filtered_connections []hookdeck.Connection
+	for _, connection := range connections {
+		if connection.Destination.CliPath != "" {
+			filtered_connections = append(filtered_connections, connection)
+		}
+	}
+	connections = filtered_connections
+
+	if connection_query != "" {
+		is_path, err := isPath(connection_query)
+		if err != nil {
+			return connections, err
+		}
+		var filtered_connections []hookdeck.Connection
+		for _, connection := range connections {
+			if (is_path && strings.Contains(connection.Destination.CliPath, connection_query)) || connection.Alias == connection_query {
+				filtered_connections = append(filtered_connections, connection)
+			}
+		}
+		connections = filtered_connections
+	}
+
+	if len(connections) == 0 {
+		answers := struct {
+			Label string `survey:"label"`
+			Path  string `survey:"path"`
+		}{}
+		var qs = []*survey.Question{
+			{
+				Name:   "path",
+				Prompt: &survey.Input{Message: "What path should the webhooks be forwarded to (ie: /webhooks)?"},
+				Validate: func(val interface{}) error {
+					str, ok := val.(string)
+					is_path, err := isPath(str)
+					if !ok || !is_path || err != nil {
+						return errors.New("invalid path")
+					}
+					return nil
+				},
+			},
+			{
+				Name:     "label",
+				Prompt:   &survey.Input{Message: "What's your connection label (ie: My API)?"},
+				Validate: survey.Required,
+			},
+		}
+
+		err := survey.Ask(qs, &answers)
+		if err != nil {
+			fmt.Println(err.Error())
+			return connections, err
+		}
+		alias := slug.Make(answers.Label)
+		connection, err := client.CreateConnection(hookdeck.CreateConnectionInput{
+			Alias:    alias,
+			Label:    answers.Label,
+			SourceId: source.Id,
+			Destination: hookdeck.CreateDestinationInput{
+				Alias:   alias,
+				Label:   answers.Label,
+				CliPath: answers.Path,
+			},
+		})
+		if err != nil {
+			return connections, err
+		}
+		connections = append(connections, connection)
+	}
+
+	return connections, nil
+}

package/pkg/listen/listen.go

@@ -0,0 +1,140 @@
+/*
+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 listen
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"regexp"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/ansi"
+	"github.com/hookdeck/hookdeck-cli/pkg/config"
+	"github.com/hookdeck/hookdeck-cli/pkg/hookdeck"
+	"github.com/hookdeck/hookdeck-cli/pkg/login"
+	"github.com/hookdeck/hookdeck-cli/pkg/proxy"
+	"github.com/hookdeck/hookdeck-cli/pkg/validators"
+	log "github.com/sirupsen/logrus"
+)
+
+type Flags struct {
+	NoWSS     bool
+	WSBaseURL string
+}
+
+// listenCmd represents the listen command
+func Listen(URL *url.URL, source_alias string, connection_query string, flags Flags, config *config.Config) error {
+	var key string
+	var err error
+	var guest_url string
+
+	key, err = config.Profile.GetAPIKey()
+	if err != nil {
+		errString := err.Error()
+		if errString == validators.ErrAPIKeyNotConfigured.Error() || errString == validators.ErrDeviceNameNotConfigured.Error() {
+			guest_url, _ = login.GuestLogin(config)
+			if guest_url == "" {
+				return err
+			}
+
+			key, err = config.Profile.GetAPIKey()
+			if err != nil {
+				return err
+			}
+		} else {
+			return err
+		}
+	}
+
+	parsedBaseURL, err := url.Parse(config.APIBaseURL)
+	if err != nil {
+		return err
+	}
+
+	client := &hookdeck.Client{
+		BaseURL: parsedBaseURL,
+		APIKey:  key,
+	}
+
+	source, err := getSource(client, source_alias)
+	if err != nil {
+		return err
+	}
+
+	connections, err := getConnections(client, source, connection_query)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println()
+	fmt.Println(ansi.Bold("Dashboard"))
+	if guest_url != "" {
+		fmt.Println("👤 Console URL: " + guest_url)
+		fmt.Println("Sign up in the Console to make your webhook URL permanent.")
+		fmt.Println()
+	} else {
+		var url = config.DashboardBaseURL
+		if config.Profile.GetTeamId() != "" {
+			url += "?team_id=" + config.Profile.GetTeamId()
+		}
+		if config.Profile.GetTeamMode() == "console" {
+			url = config.ConsoleBaseURL + "?source_id=" + source.Id
+		}
+		fmt.Println("👉 Inspect and replay webhooks: " + url)
+		fmt.Println()
+	}
+
+	fmt.Println(ansi.Bold(source.Label + " Source"))
+	fmt.Println("🔌 Webhook URL: " + source.Url)
+	fmt.Println()
+
+	fmt.Println(ansi.Bold("Connections"))
+	for _, connection := range connections {
+		fmt.Println(connection.Label + " forwarding to " + connection.Destination.CliPath)
+	}
+	fmt.Println()
+
+	deviceName, err := config.Profile.GetDeviceName()
+	if err != nil {
+		return err
+	}
+
+	p := proxy.New(&proxy.Config{
+		DeviceName:       deviceName,
+		Key:              key,
+		APIBaseURL:       config.APIBaseURL,
+		DashboardBaseURL: config.DashboardBaseURL,
+		ConsoleBaseURL:   config.ConsoleBaseURL,
+		Profile:          config.Profile,
+		WSBaseURL:        flags.WSBaseURL,
+		NoWSS:            flags.NoWSS,
+		URL:              URL,
+		Log:              log.StandardLogger(),
+		Insecure:         config.Insecure,
+	}, source, connections)
+
+	err = p.Run(context.Background())
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func isPath(value string) (bool, error) {
+	is_path, err := regexp.MatchString("^(/)+([/.a-zA-Z0-9-_]*)$", value)
+	return is_path, err
+}

package/pkg/listen/source.go

@@ -0,0 +1,84 @@
+package listen
+
+import (
+	"fmt"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/gosimple/slug"
+	"github.com/hookdeck/hookdeck-cli/pkg/hookdeck"
+)
+
+func getSource(client *hookdeck.Client, source_alias string) (hookdeck.Source, error) {
+	var source hookdeck.Source
+	if source_alias != "" {
+		source, _ = client.GetSourceByAlias(source_alias)
+		if source.Id == "" {
+			// TODO: Prompt here?
+			source, _ = client.CreateSource(hookdeck.CreateSourceInput{
+				Alias: source_alias,
+				// TODO: labelized alias
+				Label: source_alias,
+			})
+		}
+	} else {
+		sources, _ := client.ListSources()
+		if len(sources) > 0 {
+			var sources_alias []string
+			for _, temp_source := range sources {
+				sources_alias = append(sources_alias, temp_source.Alias)
+			}
+
+			answers := struct {
+				SourceAlias string `survey:"source"`
+			}{}
+
+			var qs = []*survey.Question{
+				{
+					Name: "source",
+					Prompt: &survey.Select{
+						Message: "Select a source",
+						Options: append(sources_alias, "Create new source"),
+					},
+				},
+			}
+
+			err := survey.Ask(qs, &answers)
+			if err != nil {
+				fmt.Println(err.Error())
+				return source, err
+			}
+
+			if answers.SourceAlias != "Create new source" {
+				for _, temp_source := range sources {
+					if temp_source.Alias == answers.SourceAlias {
+						source = temp_source
+					}
+				}
+			}
+		}
+
+		if source.Id == "" {
+			answers := struct {
+				Label string `survey:"label"` // or you can tag fields to match a specific name
+			}{}
+			var qs = []*survey.Question{
+				{
+					Name:     "label",
+					Prompt:   &survey.Input{Message: "What should be your new source label?"},
+					Validate: survey.Required,
+				},
+			}
+
+			err := survey.Ask(qs, &answers)
+			if err != nil {
+				return source, err
+			}
+
+			source, _ = client.CreateSource(hookdeck.CreateSourceInput{
+				Alias: slug.Make(answers.Label),
+				Label: answers.Label,
+			})
+		}
+	}
+	return source, nil
+}