Merge branch 'dev'

internal/cli/auth/device_flow.go

@@ -0,0 +1,113 @@
+package auth
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/bnema/gordon/internal/common"
+)
+
+func DeviceFlowAuth(config *common.Config) error {
+	fmt.Println("Starting device flow authentication...")
+
+	// Request device code
+	deviceCode, err := requestDeviceCode(config)
+	if err != nil {
+		return fmt.Errorf("error requesting device code: %w", err)
+	}
+
+	fmt.Printf("Please go to %v and enter the code: %v\n", deviceCode["verification_uri"], deviceCode["user_code"])
+
+	// Poll for access token
+	interval := 5 // Default to 5 seconds if not provided
+	if i, ok := deviceCode["interval"].(float64); ok {
+		interval = int(i)
+	}
+
+	token, err := pollForAccessToken(config, deviceCode["device_code"].(string), interval)
+	if err != nil {
+		return fmt.Errorf("error polling for access token: %w", err)
+	}
+
+	// Save the token
+	config.SetToken(token)
+
+	fmt.Println("Authentication successful!")
+	return nil
+}
+
+func requestDeviceCode(config *common.Config) (map[string]interface{}, error) {
+	resp, err := http.PostForm(config.GetBackendURL()+"/api/device/code", url.Values{})
+	if err != nil {
+		return nil, fmt.Errorf("error making request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("error reading response body: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("server returned non-200 status code: %d. Body: %s", resp.StatusCode, string(body))
+	}
+
+	var deviceCode map[string]interface{}
+	if err := json.Unmarshal(body, &deviceCode); err != nil {
+		return nil, fmt.Errorf("error parsing JSON response: %w", err)
+	}
+
+	// Check for required fields
+	requiredFields := []string{"verification_uri", "user_code", "device_code", "interval"}
+	for _, field := range requiredFields {
+		if _, ok := deviceCode[field]; !ok {
+			return nil, fmt.Errorf("missing required field in response: %s", field)
+		}
+	}
+
+	return deviceCode, nil
+}
+
+func pollForAccessToken(config *common.Config, deviceCode string, interval int) (string, error) {
+	maxAttempts := 60 // Maximum number of attempts (5 minutes with 5-second intervals)
+	for attempt := 0; attempt < maxAttempts; attempt++ {
+		time.Sleep(time.Duration(interval) * time.Second)
+
+		resp, err := http.PostForm(config.GetBackendURL()+"/api/device/token", url.Values{
+			"device_code": {deviceCode},
+		})
+		if err != nil {
+			continue
+		}
+		defer resp.Body.Close()
+
+		body, err := io.ReadAll(resp.Body)
+		if err != nil {
+			continue
+		}
+
+		var tokenResp map[string]interface{}
+		if err := json.Unmarshal(body, &tokenResp); err != nil {
+			continue
+		}
+
+		if accessToken, ok := tokenResp["access_token"].(string); ok && accessToken != "" {
+			return accessToken, nil
+		}
+
+		if tokenResp["error"] == "authorization_pending" {
+			// Optionally, you can print a dot to show progress without cluttering the output
+			fmt.Print(".")
+			continue
+		}
+
+		// If we get here, there's an unexpected response but we can continue to try
+		// fmt.Printf("Unexpected response from server (attempt %d): %v\n", attempt+1, tokenResp)
+	}
+
+	return "", fmt.Errorf("max attempts reached, failed to obtain access token")
+}

internal/cli/cmd/deploy.go

@@ -56,7 +56,7 @@ func NewDeployCommand(a *cli.App) *cobra.Command {
 					log.Error("Deployment failed",
 						"status_code", deployErr.StatusCode,
 						"message", deployErr.Message,
-						"raw_response", deployErr.RawResponse)
+					)
 				} else {
 					log.Error("Deployment failed", "error", err)
 				}

internal/cli/handler/fieldcheck.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/bnema/gordon/internal/cli"
+	"github.com/bnema/gordon/internal/cli/auth"
 	"github.com/bnema/gordon/internal/common"
 )
 
@@ -31,15 +32,17 @@ func FieldCheck(a *cli.App) error {
 		return err
 	}
 
-	wasTokenEmpty, err := checkAndSetField(&a.Config.General.Token,
-		"Enter the token (check your backend config.yml):",
-		"Token is not set in config.yml")
-	if err != nil {
-		return err
+	if a.Config.General.Token == "" {
+		fmt.Println("Token is not set. Starting OAuth device flow...")
+		err := auth.DeviceFlowAuth(&a.Config)
+		if err != nil {
+			fmt.Printf("Device flow authentication error: %v\n", err)
+			return fmt.Errorf("failed to complete device flow authentication: %w", err)
+		}
 	}
 
-	// Save config if one of the fields was empty
-	if wasBackendURLEmpty || wasTokenEmpty {
+	// Save config if BackendURL was empty or if a new token was set
+	if wasBackendURLEmpty || a.Config.General.Token != "" {
 		err = a.Config.SaveConfig()
 		if err != nil {
 			return err

internal/cli/handler/pingrequest.go

@@ -32,7 +32,8 @@ func PerformPingRequest(a *cli.App) (PingResponse, error) {
 	defer resp.Http.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		return PingResponse{}, fmt.Errorf("expected status code 200, got %d", resp.StatusCode)
+		// Return the error message from the server
+		return PingResponse{}, fmt.Errorf("server returned status %d: %s", resp.StatusCode, string(resp.Body))
 	}
 
 	// Unmarshal the JSON response into the PingResponse struct

internal/common/initconfig.go

@@ -194,3 +194,11 @@ func (config *Config) GetVersion() string {
 func (config *Config) GetStorageDir() string {
 	return config.General.StorageDir
 }
+
+func (c *Config) GetBackendURL() string {
+	return c.Http.BackendURL
+}
+
+func (c *Config) SetToken(token string) {
+	c.General.Token = token
+}

internal/httpserve/handler/oauth.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"time"
 
 	"github.com/bnema/gordon/internal/db"
@@ -20,6 +21,7 @@ import (
 
 var urlToken string
 
+// ClLI :
 // compareGordonToken compares the token from the URL query parameter with the one from the config.yml
 func CompareGordonToken(c echo.Context, a *server.App) error {
 	configToken, err := a.Config.GetToken()
@@ -328,3 +330,49 @@ func githubGetUserDetails(c echo.Context, a *server.App) (userInfo *queries.Gith
 
 	return userInfo, nil
 }
+
+func DeviceCodeRequest(c echo.Context, a *server.App) error {
+	proxyURL := a.Config.Build.ProxyURL
+	resp, err := http.Post(proxyURL+"/github/device/code", "application/json", nil)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return c.JSON(resp.StatusCode, map[string]string{"error": string(body)})
+	}
+
+	var deviceCode map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&deviceCode); err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to decode response"})
+	}
+
+	return c.JSON(http.StatusOK, deviceCode)
+}
+
+func DeviceTokenRequest(c echo.Context, a *server.App) error {
+	proxyURL := a.Config.Build.ProxyURL
+	deviceCode := c.FormValue("device_code")
+
+	resp, err := http.PostForm(proxyURL+"/github/device/token", url.Values{
+		"device_code": {deviceCode},
+	})
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return c.JSON(resp.StatusCode, map[string]string{"error": string(body)})
+	}
+
+	var tokenResp map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to decode response"})
+	}
+
+	return c.JSON(http.StatusOK, tokenResp)
+}