reworked api interfaces

pkg/garth/client/auth.go

@@ -0,0 +1,37 @@
+package client
+
+import (
+	"time"
+)
+
+// OAuth1Token represents OAuth 1.0a credentials
+type OAuth1Token struct {
+	Token       string
+	TokenSecret string
+	CreatedAt   time.Time
+}
+
+// Expired checks if token is expired (OAuth1 tokens typically don't expire but we'll implement for consistency)
+func (t *OAuth1Token) Expired() bool {
+	return false // OAuth1 tokens don't typically expire
+}
+
+// OAuth2Token represents OAuth 2.0 credentials
+type OAuth2Token struct {
+	AccessToken  string
+	RefreshToken string
+	TokenType    string
+	ExpiresIn    int
+	ExpiresAt    time.Time
+}
+
+// Expired checks if token is expired
+func (t *OAuth2Token) Expired() bool {
+	return time.Now().After(t.ExpiresAt)
+}
+
+// RefreshIfNeeded refreshes token if expired (implementation pending)
+func (t *OAuth2Token) RefreshIfNeeded(client *Client) error {
+	// Placeholder for token refresh logic
+	return nil
+}

pkg/garth/client/auth_test.go

@@ -0,0 +1,36 @@
+package client
+
+import (
+	"testing"
+
+	credentials "github.com/sstent/go-garth/pkg/garth/auth/credentials"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient_Login_Functional(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping functional test in short mode")
+	}
+
+	// Load credentials from .env file
+	email, password, domain, err := credentials.LoadEnvCredentials()
+	require.NoError(t, err, "Failed to load credentials from .env file. Please ensure GARMIN_EMAIL, GARMIN_PASSWORD, and GARMIN_DOMAIN are set.")
+
+	// Create client
+	c, err := NewClient(domain)
+	require.NoError(t, err, "Failed to create client")
+
+	// Perform login
+	err = c.Login(email, password)
+	require.NoError(t, err, "Login failed")
+
+	// Verify login
+	assert.NotEmpty(t, c.AuthToken, "AuthToken should not be empty after login")
+	assert.NotEmpty(t, c.Username, "Username should not be empty after login")
+
+	// Logout for cleanup
+	err = c.Logout()
+	assert.NoError(t, err, "Logout failed")
+}

pkg/garth/client/client.go

@@ -0,0 +1,964 @@
+package client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/sstent/go-garth/internal/auth/sso"
+	"github.com/sstent/go-garth/internal/errors"
+	garth "github.com/sstent/go-garth/pkg/garth/types"
+	shared "github.com/sstent/go-garth/shared/interfaces"
+	models "github.com/sstent/go-garth/shared/models"
+)
+
+// Client represents the Garmin Connect API client
+type Client struct {
+	Domain      string
+	HTTPClient  *http.Client
+	Username    string
+	AuthToken   string
+	OAuth1Token *garth.OAuth1Token
+	OAuth2Token *garth.OAuth2Token
+}
+
+// Verify that Client implements shared.APIClient
+var _ shared.APIClient = (*Client)(nil)
+
+// GetUsername returns the authenticated username
+func (c *Client) GetUsername() string {
+	return c.Username
+}
+
+// GetUserSettings retrieves the current user's settings
+func (c *Client) GetUserSettings() (*models.UserSettings, error) {
+	scheme := "https"
+	if strings.HasPrefix(c.Domain, "127.0.0.1") {
+		scheme = "http"
+	}
+	host := c.Domain
+	if !strings.HasPrefix(c.Domain, "127.0.0.1") {
+		host = "connectapi." + c.Domain
+	}
+	settingsURL := fmt.Sprintf("%s://%s/userprofile-service/userprofile/user-settings", scheme, host)
+
+	req, err := http.NewRequest("GET", settingsURL, nil)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to create user settings request",
+					Cause:   err,
+				},
+			},
+		}
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "com.garmin.android.apps.connectmobile")
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to get user settings",
+					Cause:   err,
+				},
+			},
+		}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				StatusCode: resp.StatusCode,
+				Response:   string(body),
+				GarthError: errors.GarthError{
+					Message: "User settings request failed",
+				},
+			},
+		}
+	}
+
+	var settings models.UserSettings
+	if err := json.NewDecoder(resp.Body).Decode(&settings); err != nil {
+		return nil, &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to parse user settings",
+				Cause:   err,
+			},
+		}
+	}
+
+	return &settings, nil
+}
+
+// NewClient creates a new Garmin Connect client
+func NewClient(domain string) (*Client, error) {
+	if domain == "" {
+		domain = "garmin.com"
+	}
+
+	// Extract host without scheme if present
+	if strings.Contains(domain, "://") {
+		if u, err := url.Parse(domain); err == nil {
+			domain = u.Host
+		}
+	}
+
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to create cookie jar",
+				Cause:   err,
+			},
+		}
+	}
+
+	return &Client{
+		Domain: domain,
+		HTTPClient: &http.Client{
+			Jar:     jar,
+			Timeout: 30 * time.Second,
+			CheckRedirect: func(req *http.Request, via []*http.Request) error {
+				if len(via) >= 10 {
+					return &errors.APIError{
+						GarthHTTPError: errors.GarthHTTPError{
+							GarthError: errors.GarthError{
+								Message: "Too many redirects",
+							},
+						},
+					}
+				}
+				return nil
+			},
+		},
+	}, nil
+}
+
+// Login authenticates to Garmin Connect using SSO
+func (c *Client) Login(email, password string) error {
+	// Extract host without scheme if present
+	host := c.Domain
+	if strings.Contains(host, "://") {
+		if u, err := url.Parse(host); err == nil {
+			host = u.Host
+		}
+	}
+
+	ssoClient := sso.NewClient(c.Domain)
+	oauth2Token, mfaContext, err := ssoClient.Login(email, password)
+	if err != nil {
+		return &errors.AuthenticationError{
+			GarthError: errors.GarthError{
+				Message: "SSO login failed",
+				Cause:   err,
+			},
+		}
+	}
+
+	// Handle MFA required
+	if mfaContext != nil {
+		return &errors.AuthenticationError{
+			GarthError: errors.GarthError{
+				Message: "MFA required - not implemented yet",
+			},
+		}
+	}
+
+	c.OAuth2Token = oauth2Token
+	c.AuthToken = fmt.Sprintf("%s %s", oauth2Token.TokenType, oauth2Token.AccessToken)
+
+	// Get user profile to set username
+	profile, err := c.GetUserProfile()
+	if err != nil {
+		return &errors.AuthenticationError{
+			GarthError: errors.GarthError{
+				Message: "Failed to get user profile after login",
+				Cause:   err,
+			},
+		}
+	}
+	c.Username = profile.UserName
+
+	return nil
+}
+
+// Logout clears the current session and tokens.
+func (c *Client) Logout() error {
+	c.AuthToken = ""
+	c.Username = ""
+	c.OAuth1Token = nil
+	c.OAuth2Token = nil
+
+	// Clear cookies
+	if c.HTTPClient != nil && c.HTTPClient.Jar != nil {
+		// Create a dummy URL for the domain to clear all cookies associated with it
+		dummyURL, err := url.Parse(fmt.Sprintf("https://%s", c.Domain))
+		if err == nil {
+			c.HTTPClient.Jar.SetCookies(dummyURL, []*http.Cookie{})
+		}
+	}
+	return nil
+}
+
+// GetUserProfile retrieves the current user's full profile
+func (c *Client) GetUserProfile() (*garth.UserProfile, error) {
+	scheme := "https"
+	if strings.HasPrefix(c.Domain, "127.0.0.1") {
+		scheme = "http"
+	}
+	host := c.Domain
+	if !strings.HasPrefix(c.Domain, "127.0.0.1") {
+		host = "connectapi." + c.Domain
+	}
+	profileURL := fmt.Sprintf("%s://%s/userprofile-service/socialProfile", scheme, host)
+
+	req, err := http.NewRequest("GET", profileURL, nil)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to create profile request",
+					Cause:   err,
+				},
+			},
+		}
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "com.garmin.android.apps.connectmobile")
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to get user profile",
+					Cause:   err,
+				},
+			},
+		}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				StatusCode: resp.StatusCode,
+				Response:   string(body),
+				GarthError: errors.GarthError{
+					Message: "Profile request failed",
+				},
+			},
+		}
+	}
+
+	var profile garth.UserProfile
+	if err := json.NewDecoder(resp.Body).Decode(&profile); err != nil {
+		return nil, &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to parse profile",
+				Cause:   err,
+			},
+		}
+	}
+
+	return &profile, nil
+}
+
+// ConnectAPI makes a raw API request to the Garmin Connect API
+func (c *Client) ConnectAPI(path string, method string, params url.Values, body io.Reader) ([]byte, error) {
+	scheme := "https"
+	if strings.HasPrefix(c.Domain, "127.0.0.1") {
+		scheme = "http"
+	}
+	u := &url.URL{
+		Scheme:   scheme,
+		Host:     c.Domain,
+		Path:     path,
+		RawQuery: params.Encode(),
+	}
+
+	req, err := http.NewRequest(method, u.String(), body)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to create request",
+					Cause:   err,
+				},
+			},
+		}
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "garth-go-client/1.0")
+	req.Header.Set("Accept", "application/json")
+
+	if body != nil && req.Header.Get("Content-Type") == "" {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Request failed",
+					Cause:   err,
+				},
+			},
+		}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				StatusCode: resp.StatusCode,
+				Response:   string(bodyBytes),
+				GarthError: errors.GarthError{
+					Message: fmt.Sprintf("API request failed with status %d: %s",
+						resp.StatusCode, tryReadErrorBody(bytes.NewReader(bodyBytes))),
+				},
+			},
+		}
+	}
+
+	return io.ReadAll(resp.Body)
+}
+
+func tryReadErrorBody(r io.Reader) string {
+	body, err := io.ReadAll(r)
+	if err != nil {
+		return "failed to read error response"
+	}
+	return string(body)
+}
+
+// Upload sends a file to Garmin Connect
+func (c *Client) Upload(filePath string) error {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to open file",
+				Cause:   err,
+			},
+		}
+	}
+	defer file.Close()
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile("file", filepath.Base(filePath))
+	if err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to create form file",
+				Cause:   err,
+			},
+		}
+	}
+
+	if _, err := io.Copy(part, file); err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to copy file content",
+				Cause:   err,
+			},
+		}
+	}
+
+	if err := writer.Close(); err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to close multipart writer",
+				Cause:   err,
+			},
+		}
+	}
+
+	_, err = c.ConnectAPI("/upload-service/upload", "POST", nil, body)
+	if err != nil {
+		return &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "File upload failed",
+					Cause:   err,
+				},
+			},
+		}
+	}
+
+	return nil
+}
+
+// Download retrieves a file from Garmin Connect
+func (c *Client) Download(activityID string, format string, filePath string) error {
+	params := url.Values{}
+	params.Add("activityId", activityID)
+	// Add format parameter if provided and not empty
+	if format != "" {
+		params.Add("format", format)
+	}
+
+	resp, err := c.ConnectAPI("/download-service/export", "GET", params, nil)
+	if err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(filePath, resp, 0644); err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to save file",
+				Cause:   err,
+			},
+		}
+	}
+
+	return nil
+}
+
+// GetActivities retrieves recent activities
+func (c *Client) GetActivities(limit int) ([]garth.Activity, error) {
+	if limit <= 0 {
+		limit = 10
+	}
+
+	scheme := "https"
+	if strings.HasPrefix(c.Domain, "127.0.0.1") {
+		scheme = "http"
+	}
+
+	activitiesURL := fmt.Sprintf("%s://connectapi.%s/activitylist-service/activities/search/activities?limit=%d&start=0", scheme, c.Domain, limit)
+
+	req, err := http.NewRequest("GET", activitiesURL, nil)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to create activities request",
+					Cause:   err,
+				},
+			},
+		}
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "com.garmin.android.apps.connectmobile")
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to get activities",
+					Cause:   err,
+				},
+			},
+		}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				StatusCode: resp.StatusCode,
+				Response:   string(body),
+				GarthError: errors.GarthError{
+					Message: "Activities request failed",
+				},
+			},
+		}
+	}
+
+	var activities []garth.Activity
+	if err := json.NewDecoder(resp.Body).Decode(&activities); err != nil {
+		return nil, &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to parse activities",
+				Cause:   err,
+			},
+		}
+	}
+
+	return activities, nil
+}
+
+func (c *Client) GetSleepData(startDate, endDate time.Time) ([]garth.SleepData, error) {
+	// TODO: Implement GetSleepData
+	return nil, fmt.Errorf("GetSleepData not implemented")
+}
+
+// GetHrvData retrieves HRV data for a specified number of days
+func (c *Client) GetHrvData(days int) ([]garth.HrvData, error) {
+	// TODO: Implement GetHrvData
+	return nil, fmt.Errorf("GetHrvData not implemented")
+}
+
+// GetStressData retrieves stress data
+func (c *Client) GetStressData(startDate, endDate time.Time) ([]garth.StressData, error) {
+	// TODO: Implement GetStressData
+	return nil, fmt.Errorf("GetStressData not implemented")
+}
+
+// GetBodyBatteryData retrieves Body Battery data
+func (c *Client) GetBodyBatteryData(startDate, endDate time.Time) ([]garth.BodyBatteryData, error) {
+	// TODO: Implement GetBodyBatteryData
+	return nil, fmt.Errorf("GetBodyBatteryData not implemented")
+}
+
+// GetStepsData retrieves steps data for a specified date range
+func (c *Client) GetStepsData(startDate, endDate time.Time) ([]garth.StepsData, error) {
+	// TODO: Implement GetStepsData
+	return nil, fmt.Errorf("GetStepsData not implemented")
+}
+
+// GetDistanceData retrieves distance data for a specified date range
+func (c *Client) GetDistanceData(startDate, endDate time.Time) ([]garth.DistanceData, error) {
+	// TODO: Implement GetDistanceData
+	return nil, fmt.Errorf("GetDistanceData not implemented")
+}
+
+// GetCaloriesData retrieves calories data for a specified date range
+func (c *Client) GetCaloriesData(startDate, endDate time.Time) ([]garth.CaloriesData, error) {
+	// TODO: Implement GetCaloriesData
+	return nil, fmt.Errorf("GetCaloriesData not implemented")
+}
+
+// GetVO2MaxData retrieves VO2 max data using the modern approach via user settings
+func (c *Client) GetVO2MaxData(startDate, endDate time.Time) ([]garth.VO2MaxData, error) {
+	// Get user settings which contains current VO2 max values
+	settings, err := c.GetUserSettings()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get user settings: %w", err)
+	}
+
+	// Create VO2MaxData for the date range
+	var results []garth.VO2MaxData
+	current := startDate
+	for !current.After(endDate) {
+		vo2Data := garth.VO2MaxData{
+			Date:          current,
+			UserProfilePK: settings.ID,
+		}
+
+		// Set VO2 max values if available
+		if settings.UserData.VO2MaxRunning != nil {
+			vo2Data.VO2MaxRunning = settings.UserData.VO2MaxRunning
+		}
+		if settings.UserData.VO2MaxCycling != nil {
+			vo2Data.VO2MaxCycling = settings.UserData.VO2MaxCycling
+		}
+
+		results = append(results, vo2Data)
+		current = current.AddDate(0, 0, 1)
+	}
+
+	return results, nil
+}
+
+// GetCurrentVO2Max retrieves the current VO2 max values from user profile
+func (c *Client) GetCurrentVO2Max() (*garth.VO2MaxProfile, error) {
+	settings, err := c.GetUserSettings()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get user settings: %w", err)
+	}
+
+	profile := &garth.VO2MaxProfile{
+		UserProfilePK: settings.ID,
+		LastUpdated:   time.Now(),
+	}
+
+	// Add running VO2 max if available
+	if settings.UserData.VO2MaxRunning != nil && *settings.UserData.VO2MaxRunning > 0 {
+		profile.Running = &garth.VO2MaxEntry{
+			Value:        *settings.UserData.VO2MaxRunning,
+			ActivityType: "running",
+			Date:         time.Now(),
+			Source:       "user_settings",
+		}
+	}
+
+	// Add cycling VO2 max if available
+	if settings.UserData.VO2MaxCycling != nil && *settings.UserData.VO2MaxCycling > 0 {
+		profile.Cycling = &garth.VO2MaxEntry{
+			Value:        *settings.UserData.VO2MaxCycling,
+			ActivityType: "cycling",
+			Date:         time.Now(),
+			Source:       "user_settings",
+		}
+	}
+
+	return profile, nil
+}
+
+// GetHeartRateZones retrieves heart rate zone data
+func (c *Client) GetHeartRateZones() (*garth.HeartRateZones, error) {
+	scheme := "https"
+	if strings.HasPrefix(c.Domain, "127.0.0.1") {
+		scheme = "http"
+	}
+
+	hrzURL := fmt.Sprintf("%s://connectapi.%s/userprofile-service/userprofile/heartRateZones", scheme, c.Domain)
+
+	req, err := http.NewRequest("GET", hrzURL, nil)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to create HR zones request",
+					Cause:   err,
+				},
+			},
+		}
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "com.garmin.android.apps.connectmobile")
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to get HR zones data",
+					Cause:   err,
+				},
+			},
+		}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				StatusCode: resp.StatusCode,
+				Response:   string(body),
+				GarthError: errors.GarthError{
+					Message: "HR zones request failed",
+				},
+			},
+		}
+	}
+
+	var hrZones garth.HeartRateZones
+	if err := json.NewDecoder(resp.Body).Decode(&hrZones); err != nil {
+		return nil, &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to parse HR zones data",
+				Cause:   err,
+			},
+		}
+	}
+
+	return &hrZones, nil
+}
+
+// GetWellnessData retrieves comprehensive wellness data for a specified date range
+func (c *Client) GetWellnessData(startDate, endDate time.Time) ([]garth.WellnessData, error) {
+	scheme := "https"
+	if strings.HasPrefix(c.Domain, "127.0.0.1") {
+		scheme = "http"
+	}
+
+	params := url.Values{}
+	params.Add("startDate", startDate.Format("2006-01-02"))
+	params.Add("endDate", endDate.Format("2006-01-02"))
+
+	wellnessURL := fmt.Sprintf("%s://connectapi.%s/wellness-service/wellness/daily/wellness?%s", scheme, c.Domain, params.Encode())
+
+	req, err := http.NewRequest("GET", wellnessURL, nil)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to create wellness data request",
+					Cause:   err,
+				},
+			},
+		}
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "com.garmin.android.apps.connectmobile")
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to get wellness data",
+					Cause:   err,
+				},
+			},
+		}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				StatusCode: resp.StatusCode,
+				Response:   string(body),
+				GarthError: errors.GarthError{
+					Message: "Wellness data request failed",
+				},
+			},
+		}
+	}
+
+	var wellnessData []garth.WellnessData
+	if err := json.NewDecoder(resp.Body).Decode(&wellnessData); err != nil {
+		return nil, &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to parse wellness data",
+				Cause:   err,
+			},
+		}
+	}
+
+	return wellnessData, nil
+}
+
+// SaveSession saves the current session to a file
+func (c *Client) SaveSession(filename string) error {
+	session := garth.SessionData{
+		Domain:    c.Domain,
+		Username:  c.Username,
+		AuthToken: c.AuthToken,
+	}
+
+	data, err := json.MarshalIndent(session, "", "  ")
+	if err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to marshal session",
+				Cause:   err,
+			},
+		}
+	}
+
+	if err := os.WriteFile(filename, data, 0600); err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to write session file",
+				Cause:   err,
+			},
+		}
+	}
+
+	return nil
+}
+
+// GetDetailedSleepData retrieves comprehensive sleep data for a date
+func (c *Client) GetDetailedSleepData(date time.Time) (*garth.DetailedSleepData, error) {
+	dateStr := date.Format("2006-01-02")
+	path := fmt.Sprintf("/wellness-service/wellness/dailySleepData/%s?date=%s&nonSleepBufferMinutes=60",
+		c.Username, dateStr)
+
+	data, err := c.ConnectAPI(path, "GET", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get detailed sleep data: %w", err)
+	}
+
+	if len(data) == 0 {
+		return nil, nil
+	}
+
+	var response struct {
+		DailySleepDTO                       *garth.DetailedSleepData `json:"dailySleepDTO"`
+		SleepMovement                       []garth.SleepMovement    `json:"sleepMovement"`
+		RemSleepData                        bool                     `json:"remSleepData"`
+		SleepLevels                         []garth.SleepLevel       `json:"sleepLevels"`
+		SleepRestlessMoments                []interface{}            `json:"sleepRestlessMoments"`
+		RestlessMomentsCount                int                      `json:"restlessMomentsCount"`
+		WellnessSpO2SleepSummaryDTO         interface{}              `json:"wellnessSpO2SleepSummaryDTO"`
+		WellnessEpochSPO2DataDTOList        []interface{}            `json:"wellnessEpochSPO2DataDTOList"`
+		WellnessEpochRespirationDataDTOList []interface{}            `json:"wellnessEpochRespirationDataDTOList"`
+		SleepStress                         interface{}              `json:"sleepStress"`
+	}
+
+	if err := json.Unmarshal(data, &response); err != nil {
+		return nil, fmt.Errorf("failed to parse detailed sleep response: %w", err)
+	}
+
+	if response.DailySleepDTO == nil {
+		return nil, nil
+	}
+
+	// Populate additional data
+	response.DailySleepDTO.SleepMovement = response.SleepMovement
+	response.DailySleepDTO.SleepLevels = response.SleepLevels
+
+	return response.DailySleepDTO, nil
+}
+
+// GetDailyHRVData retrieves comprehensive daily HRV data for a date
+func (c *Client) GetDailyHRVData(date time.Time) (*garth.DailyHRVData, error) {
+	dateStr := date.Format("2006-01-02")
+	path := fmt.Sprintf("/wellness-service/wellness/dailyHrvData/%s?date=%s",
+		c.Username, dateStr)
+
+	data, err := c.ConnectAPI(path, "GET", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get HRV data: %w", err)
+	}
+
+	if len(data) == 0 {
+		return nil, nil
+	}
+
+	var response struct {
+		HRVSummary  garth.DailyHRVData `json:"hrvSummary"`
+		HRVReadings []garth.HRVReading `json:"hrvReadings"`
+	}
+
+	if err := json.Unmarshal(data, &response); err != nil {
+		return nil, fmt.Errorf("failed to parse HRV response: %w", err)
+	}
+
+	// Combine summary and readings
+	response.HRVSummary.HRVReadings = response.HRVReadings
+	return &response.HRVSummary, nil
+}
+
+// GetDetailedBodyBatteryData retrieves comprehensive Body Battery data for a date
+func (c *Client) GetDetailedBodyBatteryData(date time.Time) (*garth.DetailedBodyBatteryData, error) {
+	dateStr := date.Format("2006-01-02")
+
+	// Get main Body Battery data
+	path1 := fmt.Sprintf("/wellness-service/wellness/dailyStress/%s", dateStr)
+	data1, err := c.ConnectAPI(path1, "GET", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get Body Battery stress data: %w", err)
+	}
+
+	// Get Body Battery events
+	path2 := fmt.Sprintf("/wellness-service/wellness/bodyBattery/%s", dateStr)
+	data2, err := c.ConnectAPI(path2, "GET", nil, nil)
+	if err != nil {
+		// Events might not be available, continue without them
+		data2 = []byte("[]")
+	}
+
+	var result garth.DetailedBodyBatteryData
+	if len(data1) > 0 {
+		if err := json.Unmarshal(data1, &result); err != nil {
+			return nil, fmt.Errorf("failed to parse Body Battery data: %w", err)
+		}
+	}
+
+	var events []garth.BodyBatteryEvent
+	if len(data2) > 0 {
+		if err := json.Unmarshal(data2, &events); err == nil {
+			result.Events = events
+		}
+	}
+
+	return &result, nil
+}
+
+// GetTrainingStatus retrieves current training status
+func (c *Client) GetTrainingStatus(date time.Time) (*garth.TrainingStatus, error) {
+	dateStr := date.Format("2006-01-02")
+	path := fmt.Sprintf("/metrics-service/metrics/trainingStatus/%s", dateStr)
+
+	data, err := c.ConnectAPI(path, "GET", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get training status: %w", err)
+	}
+
+	if len(data) == 0 {
+		return nil, nil
+	}
+
+	var result garth.TrainingStatus
+	if err := json.Unmarshal(data, &result); err != nil {
+		return nil, fmt.Errorf("failed to parse training status: %w", err)
+	}
+
+	return &result, nil
+}
+
+// GetTrainingLoad retrieves training load data
+func (c *Client) GetTrainingLoad(date time.Time) (*garth.TrainingLoad, error) {
+	dateStr := date.Format("2006-01-02")
+	endDate := date.AddDate(0, 0, 6).Format("2006-01-02") // Get week of data
+	path := fmt.Sprintf("/metrics-service/metrics/trainingLoad/%s/%s", dateStr, endDate)
+
+	data, err := c.ConnectAPI(path, "GET", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get training load: %w", err)
+	}
+
+	if len(data) == 0 {
+		return nil, nil
+	}
+
+	var results []garth.TrainingLoad
+	if err := json.Unmarshal(data, &results); err != nil {
+		return nil, fmt.Errorf("failed to parse training load: %w", err)
+	}
+
+	if len(results) == 0 {
+		return nil, nil
+	}
+
+	return &results[0], nil
+}
+
+// LoadSession loads a session from a file
+func (c *Client) LoadSession(filename string) error {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to read session file",
+				Cause:   err,
+			},
+		}
+	}
+
+	var session garth.SessionData
+	if err := json.Unmarshal(data, &session); err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to unmarshal session",
+				Cause:   err,
+			},
+		}
+	}
+
+	c.Domain = session.Domain
+	c.Username = session.Username
+	c.AuthToken = session.AuthToken
+
+	return nil
+}
+
+// RefreshSession refreshes the authentication tokens
+func (c *Client) RefreshSession() error {
+	// TODO: Implement token refresh logic
+	return fmt.Errorf("RefreshSession not implemented")
+}

pkg/garth/client/client_test.go

@@ -0,0 +1,48 @@
+package client_test
+
+import (
+	"crypto/tls"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+
+	"github.com/sstent/go-garth/internal/testutils"
+	"github.com/sstent/go-garth/pkg/garth/client"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient_GetUserProfile(t *testing.T) {
+	// Create mock server returning user profile
+	server := testutils.MockJSONResponse(http.StatusOK, `{ 
+		"userName": "testuser",
+		"displayName": "Test User",
+		"fullName": "Test User",
+		"location": "Test Location"
+	}`)
+	defer server.Close()
+
+	// Create client with test configuration
+	u, _ := url.Parse(server.URL)
+	c, err := client.NewClient(u.Host)
+	require.NoError(t, err)
+	c.Domain = u.Host
+	require.NoError(t, err)
+	c.HTTPClient = &http.Client{
+		Timeout: 5 * time.Second,
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+	}
+	c.AuthToken = "Bearer testtoken"
+
+	// Get user profile
+	profile, err := c.GetUserProfile()
+
+	// Verify response
+	require.NoError(t, err)
+	assert.Equal(t, "testuser", profile.UserName)
+	assert.Equal(t, "Test User", profile.DisplayName)
+}

pkg/garth/client/doc.go

@@ -0,0 +1,6 @@
+// Package client implements the low-level Garmin Connect HTTP client.
+// It is responsible for authentication (via SSO helpers), request construction,
+// header and cookie handling, error mapping, and JSON decoding. Higher-level
+// public APIs in pkg/garmin delegate to this package for actual network I/O.
+// Note: This is an internal package and not intended for direct external use.
+package client

pkg/garth/client/http.go

@@ -0,0 +1,4 @@
+package client
+
+// This file intentionally left blank.
+// All HTTP client methods are now implemented in client.go.

pkg/garth/client/http_client.go

@@ -0,0 +1,11 @@
+package client
+
+import (
+	"io"
+	"net/url"
+)
+
+// HTTPClient defines the interface for HTTP operations
+type HTTPClient interface {
+	ConnectAPI(path string, method string, params url.Values, body io.Reader) ([]byte, error)
+}

pkg/garth/client/profile.go

@@ -0,0 +1,71 @@
+package client
+
+import (
+	"time"
+)
+
+type UserProfile struct {
+	ID                            int       `json:"id"`
+	ProfileID                     int       `json:"profileId"`
+	GarminGUID                    string    `json:"garminGuid"`
+	DisplayName                   string    `json:"displayName"`
+	FullName                      string    `json:"fullName"`
+	UserName                      string    `json:"userName"`
+	ProfileImageType              *string   `json:"profileImageType"`
+	ProfileImageURLLarge          *string   `json:"profileImageUrlLarge"`
+	ProfileImageURLMedium         *string   `json:"profileImageUrlMedium"`
+	ProfileImageURLSmall          *string   `json:"profileImageUrlSmall"`
+	Location                      *string   `json:"location"`
+	FacebookURL                   *string   `json:"facebookUrl"`
+	TwitterURL                    *string   `json:"twitterUrl"`
+	PersonalWebsite               *string   `json:"personalWebsite"`
+	Motivation                    *string   `json:"motivation"`
+	Bio                           *string   `json:"bio"`
+	PrimaryActivity               *string   `json:"primaryActivity"`
+	FavoriteActivityTypes         []string  `json:"favoriteActivityTypes"`
+	RunningTrainingSpeed          float64   `json:"runningTrainingSpeed"`
+	CyclingTrainingSpeed          float64   `json:"cyclingTrainingSpeed"`
+	FavoriteCyclingActivityTypes  []string  `json:"favoriteCyclingActivityTypes"`
+	CyclingClassification         *string   `json:"cyclingClassification"`
+	CyclingMaxAvgPower            float64   `json:"cyclingMaxAvgPower"`
+	SwimmingTrainingSpeed         float64   `json:"swimmingTrainingSpeed"`
+	ProfileVisibility             string    `json:"profileVisibility"`
+	ActivityStartVisibility       string    `json:"activityStartVisibility"`
+	ActivityMapVisibility         string    `json:"activityMapVisibility"`
+	CourseVisibility              string    `json:"courseVisibility"`
+	ActivityHeartRateVisibility   string    `json:"activityHeartRateVisibility"`
+	ActivityPowerVisibility       string    `json:"activityPowerVisibility"`
+	BadgeVisibility               string    `json:"badgeVisibility"`
+	ShowAge                       bool      `json:"showAge"`
+	ShowWeight                    bool      `json:"showWeight"`
+	ShowHeight                    bool      `json:"showHeight"`
+	ShowWeightClass               bool      `json:"showWeightClass"`
+	ShowAgeRange                  bool      `json:"showAgeRange"`
+	ShowGender                    bool      `json:"showGender"`
+	ShowActivityClass             bool      `json:"showActivityClass"`
+	ShowVO2Max                    bool      `json:"showVo2Max"`
+	ShowPersonalRecords           bool      `json:"showPersonalRecords"`
+	ShowLast12Months              bool      `json:"showLast12Months"`
+	ShowLifetimeTotals            bool      `json:"showLifetimeTotals"`
+	ShowUpcomingEvents            bool      `json:"showUpcomingEvents"`
+	ShowRecentFavorites           bool      `json:"showRecentFavorites"`
+	ShowRecentDevice              bool      `json:"showRecentDevice"`
+	ShowRecentGear                bool      `json:"showRecentGear"`
+	ShowBadges                    bool      `json:"showBadges"`
+	OtherActivity                 *string   `json:"otherActivity"`
+	OtherPrimaryActivity          *string   `json:"otherPrimaryActivity"`
+	OtherMotivation               *string   `json:"otherMotivation"`
+	UserRoles                     []string  `json:"userRoles"`
+	NameApproved                  bool      `json:"nameApproved"`
+	UserProfileFullName           string    `json:"userProfileFullName"`
+	MakeGolfScorecardsPrivate     bool      `json:"makeGolfScorecardsPrivate"`
+	AllowGolfLiveScoring          bool      `json:"allowGolfLiveScoring"`
+	AllowGolfScoringByConnections bool      `json:"allowGolfScoringByConnections"`
+	UserLevel                     int       `json:"userLevel"`
+	UserPoint                     int       `json:"userPoint"`
+	LevelUpdateDate               time.Time `json:"levelUpdateDate"`
+	LevelIsViewed                 bool      `json:"levelIsViewed"`
+	LevelPointThreshold           int       `json:"levelPointThreshold"`
+	UserPointOffset               int       `json:"userPointOffset"`
+	UserPro                       bool      `json:"userPro"`
+}