refactor: hookdeck api calls using latest version

refactor: move hookdeck api calls to pkg/hookdeck
chore: hookdeck api calls using latest version

Author: alexluong

main.go

@@ -5,7 +5,7 @@ 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
+	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,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hookdeck-cli",
-  "version": "1.3.0-beta.1",
+  "version": "1.3.0",
   "description": "Hookdeck CLI",
   "repository": {
     "type": "git",

pkg/hookdeck/auth.go

@@ -0,0 +1,271 @@
+package hookdeck
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/url"
+	"strings"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+const maxAttemptsDefault = 2 * 60
+const intervalDefault = 2 * time.Second
+const maxBackoffInterval = 30 * time.Second
+
+// ValidateAPIKeyResponse returns the user and team associated with a key
+type ValidateAPIKeyResponse struct {
+	UserID           string `json:"user_id"`
+	UserName         string `json:"user_name"`
+	UserEmail        string `json:"user_email"`
+	OrganizationName string `json:"organization_name"`
+	OrganizationID   string `json:"organization_id"`
+	ProjectID        string `json:"team_id"`
+	ProjectName      string `json:"team_name_no_org"`
+	ProjectMode      string `json:"team_mode"`
+	ClientID         string `json:"client_id"`
+}
+
+// PollAPIKeyResponse returns the data of the polling client login
+type PollAPIKeyResponse struct {
+	Claimed          bool   `json:"claimed"`
+	UserID           string `json:"user_id"`
+	UserName         string `json:"user_name"`
+	UserEmail        string `json:"user_email"`
+	OrganizationName string `json:"organization_name"`
+	OrganizationID   string `json:"organization_id"`
+	ProjectID        string `json:"team_id"`
+	ProjectName      string `json:"team_name"`
+	ProjectMode      string `json:"team_mode"`
+	APIKey           string `json:"key"`
+	ClientID         string `json:"client_id"`
+}
+
+// UpdateClientInput represents the input for updating a CLI client
+type UpdateClientInput struct {
+	DeviceName string `json:"device_name"`
+}
+
+// LoginSession represents an in-progress login flow
+type LoginSession struct {
+	BrowserURL string
+	pollURL    string
+}
+
+// GuestSession represents an in-progress guest login flow
+type GuestSession struct {
+	BrowserURL string
+	GuestURL   string
+	pollURL    string
+}
+
+// StartLogin initiates the login flow and returns a session to wait for completion
+func (c *Client) StartLogin(deviceName string) (*LoginSession, error) {
+	data := struct {
+		DeviceName string `json:"device_name"`
+	}{
+		DeviceName: deviceName,
+	}
+
+	jsonData, err := json.Marshal(data)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := c.Post(context.Background(), "/2025-07-01/cli-auth", jsonData, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var links struct {
+		BrowserURL string `json:"browser_url"`
+		PollURL    string `json:"poll_url"`
+	}
+	err = json.Unmarshal(body, &links)
+	if err != nil {
+		return nil, err
+	}
+
+	return &LoginSession{
+		BrowserURL: links.BrowserURL,
+		pollURL:    links.PollURL,
+	}, nil
+}
+
+// StartGuestLogin initiates a guest login flow and returns a session to wait for completion
+func (c *Client) StartGuestLogin(deviceName string) (*GuestSession, error) {
+	guest, err := c.CreateGuestUser(CreateGuestUserInput{
+		DeviceName: deviceName,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &GuestSession{
+		BrowserURL: guest.BrowserURL,
+		GuestURL:   guest.Url,
+		pollURL:    guest.PollURL,
+	}, nil
+}
+
+// WaitForAPIKey polls until the user completes login and returns the API key response
+func (s *LoginSession) WaitForAPIKey(interval time.Duration, maxAttempts int) (*PollAPIKeyResponse, error) {
+	return pollForAPIKey(s.pollURL, interval, maxAttempts)
+}
+
+// WaitForAPIKey polls until the user completes login and returns the API key response
+func (s *GuestSession) WaitForAPIKey(interval time.Duration, maxAttempts int) (*PollAPIKeyResponse, error) {
+	return pollForAPIKey(s.pollURL, interval, maxAttempts)
+}
+
+// PollForAPIKeyWithKey polls for login completion using a CLI API key (for interactive login)
+func (c *Client) PollForAPIKeyWithKey(apiKey string, interval time.Duration, maxAttempts int) (*PollAPIKeyResponse, error) {
+	pollURL := c.BaseURL.String() + "/2025-07-01/cli-auth/poll?key=" + apiKey
+	return pollForAPIKey(pollURL, interval, maxAttempts)
+}
+
+// ValidateAPIKey validates an API key and returns user/project information
+func (c *Client) ValidateAPIKey() (*ValidateAPIKeyResponse, error) {
+	res, err := c.Get(context.Background(), "/2025-07-01/cli-auth/validate", "", nil)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var response ValidateAPIKeyResponse
+	err = json.Unmarshal(body, &response)
+	if err != nil {
+		return nil, err
+	}
+
+	return &response, nil
+}
+
+// pollForAPIKey polls Hookdeck at the specified interval until either the API key is available or we've reached the max attempts.
+// This is an internal function that creates its own client for polling with rate limit suppression.
+func pollForAPIKey(pollURL string, interval time.Duration, maxAttempts int) (*PollAPIKeyResponse, error) {
+	if maxAttempts == 0 {
+		maxAttempts = maxAttemptsDefault
+	}
+
+	if interval == 0 {
+		interval = intervalDefault
+	}
+
+	parsedURL, err := url.Parse(pollURL)
+	if err != nil {
+		return nil, err
+	}
+
+	baseURL := &url.URL{Scheme: parsedURL.Scheme, Host: parsedURL.Host}
+
+	client := &Client{
+		BaseURL:                 baseURL,
+		SuppressRateLimitErrors: true, // Rate limiting is expected during polling
+	}
+
+	var count = 0
+	currentInterval := interval
+	consecutiveRateLimits := 0
+
+	for count < maxAttempts {
+		res, err := client.Get(context.TODO(), parsedURL.Path, parsedURL.Query().Encode(), nil)
+
+		// Check if error is due to rate limiting (429)
+		if err != nil && isRateLimitError(err) {
+			consecutiveRateLimits++
+			backoffInterval := calculateBackoff(currentInterval, consecutiveRateLimits)
+
+			log.WithFields(log.Fields{
+				"attempt":          count + 1,
+				"max_attempts":     maxAttempts,
+				"backoff_interval": backoffInterval,
+				"rate_limits":      consecutiveRateLimits,
+			}).Debug("Rate limited while polling, waiting before retry...")
+
+			time.Sleep(backoffInterval)
+			currentInterval = backoffInterval
+			count++
+			continue
+		}
+
+		// Reset back-off on successful request
+		if err == nil {
+			consecutiveRateLimits = 0
+			currentInterval = interval
+		}
+
+		// Handle other errors (non-429)
+		if err != nil {
+			return nil, err
+		}
+
+		var response PollAPIKeyResponse
+
+		defer res.Body.Close()
+		body, err := io.ReadAll(res.Body)
+		if err != nil {
+			return nil, err
+		}
+		err = json.Unmarshal(body, &response)
+		if err != nil {
+			return nil, err
+		}
+
+		if response.Claimed {
+			return &response, nil
+		}
+
+		count++
+		time.Sleep(currentInterval)
+	}
+
+	return nil, errors.New("exceeded max attempts")
+}
+
+// UpdateClient updates a CLI client's device name
+func (c *Client) UpdateClient(clientID string, input UpdateClientInput) error {
+	jsonData, err := json.Marshal(input)
+	if err != nil {
+		return err
+	}
+
+	_, err = c.Put(context.Background(), "/2025-07-01/cli/"+clientID, jsonData, nil)
+	return err
+}
+
+// isRateLimitError checks if an error is a 429 rate limit error
+func isRateLimitError(err error) bool {
+	if err == nil {
+		return false
+	}
+	errMsg := err.Error()
+	return strings.Contains(errMsg, "429") || strings.Contains(errMsg, "Too Many Requests")
+}
+
+// calculateBackoff implements exponential back-off with a maximum cap
+func calculateBackoff(baseInterval time.Duration, consecutiveFailures int) time.Duration {
+	// Exponential: baseInterval * 2^consecutiveFailures
+	backoff := baseInterval * time.Duration(1<<uint(consecutiveFailures))
+
+	// Cap at maxBackoffInterval
+	if backoff > maxBackoffInterval {
+		backoff = maxBackoffInterval
+	}
+
+	return backoff
+}

pkg/hookdeck/ci.go

@@ -29,7 +29,7 @@ func (c *Client) CreateCIClient(input CreateCIClientInput) (CIClient, error) {
 	if err != nil {
 		return CIClient{}, err
 	}
-	res, err := c.Post(context.Background(), "/cli-auth/ci", input_bytes, nil)
+	res, err := c.Post(context.Background(), "/2025-07-01/cli-auth/ci", input_bytes, nil)
 	if err != nil {
 		return CIClient{}, err
 	}

pkg/hookdeck/events.go

@@ -0,0 +1,18 @@
+package hookdeck
+
+import (
+	"context"
+	"fmt"
+)
+
+// RetryEvent retries an event by ID
+func (c *Client) RetryEvent(eventID string) error {
+	retryURL := fmt.Sprintf("/2025-07-01/events/%s/retry", eventID)
+	resp, err := c.Post(context.Background(), retryURL, []byte("{}"), nil)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	return nil
+}

pkg/hookdeck/guest.go

@@ -24,7 +24,7 @@ func (c *Client) CreateGuestUser(input CreateGuestUserInput) (GuestUser, error)
 	if err != nil {
 		return GuestUser{}, err
 	}
-	res, err := c.Post(context.Background(), "/cli/guest", input_bytes, nil)
+	res, err := c.Post(context.Background(), "/2025-07-01/cli/guest", input_bytes, nil)
 	if err != nil {
 		return GuestUser{}, err
 	}

pkg/hookdeck/projects.go

@@ -13,7 +13,7 @@ type Project struct {
 }
 
 func (c *Client) ListProjects() ([]Project, error) {
-	res, err := c.Get(context.Background(), "/teams", "", nil)
+	res, err := c.Get(context.Background(), "/2025-07-01/teams", "", nil)
 	if err != nil {
 		return []Project{}, err
 	}

pkg/hookdeck/session.go

@@ -29,7 +29,7 @@ func (c *Client) CreateSession(input CreateSessionInput) (Session, error) {
 	if err != nil {
 		return Session{}, err
 	}
-	res, err := c.Post(context.Background(), "/cli-sessions", input_bytes, nil)
+	res, err := c.Post(context.Background(), "/2025-07-01/cli-sessions", input_bytes, nil)
 	if err != nil {
 		return Session{}, err
 	}

pkg/listen/tui/model.go

@@ -11,6 +11,7 @@ import (
 	tea "github.com/charmbracelet/bubbletea"
 	hookdecksdk "github.com/hookdeck/hookdeck-go-sdk"
 
+	"github.com/hookdeck/hookdeck-cli/pkg/hookdeck"
 	"github.com/hookdeck/hookdeck-cli/pkg/websocket"
 )
 
@@ -39,6 +40,9 @@ type Model struct {
 	// Configuration
 	cfg *Config
 
+	// API client (initialized once)
+	client *hookdeck.Client
+
 	// Event history
 	events        []EventInfo
 	selectedIndex int
@@ -83,8 +87,15 @@ type Config struct {
 
 // NewModel creates a new TUI model
 func NewModel(cfg *Config) Model {
+	parsedBaseURL, _ := url.Parse(cfg.APIBaseURL)
+
 	return Model{
-		cfg:           cfg,
+		cfg: cfg,
+		client: &hookdeck.Client{
+			BaseURL:   parsedBaseURL,
+			APIKey:    cfg.APIKey,
+			ProjectID: cfg.ProjectID,
+		},
 		events:        make([]EventInfo, 0),
 		selectedIndex: -1,
 		ready:         false,

pkg/listen/tui/styles.go

@@ -41,7 +41,7 @@ var (
 			Bold(true)
 
 	brandAccentStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.Color("4")) // Blue
+				Foreground(lipgloss.Color("4")) // Blue
 
 	// Component styles
 	selectionIndicatorStyle = lipgloss.NewStyle().