Add rwx logs command (#261)

Author: robinaugh

cmd/rwx/logs.go

@@ -0,0 +1,78 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/rwx-cloud/cli/internal/cli"
+	"github.com/rwx-cloud/cli/internal/errors"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	LogsOutput string
+
+	logsCmd = &cobra.Command{
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			return requireAccessToken()
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if len(args) == 0 {
+				return errors.New("task ID is required")
+			}
+
+			taskId := args[0]
+
+			outputDir := LogsOutput
+			if outputDir == "" {
+				var err error
+				outputDir, err = getDefaultLogsDir()
+				if err != nil {
+					return errors.Wrap(err, "unable to determine default logs directory")
+				}
+			}
+
+			if err := os.MkdirAll(outputDir, 0755); err != nil {
+				return errors.Wrapf(err, "unable to create output directory %s", outputDir)
+			}
+
+			absOutputDir, err := filepath.Abs(outputDir)
+			if err != nil {
+				return errors.Wrapf(err, "unable to resolve absolute path for %s", outputDir)
+			}
+
+			err = service.DownloadLogs(cli.DownloadLogsConfig{
+				TaskID:    taskId,
+				OutputDir: absOutputDir,
+			})
+			if err != nil {
+				return err
+			}
+
+			return nil
+		},
+		Short: "Download logs for a task",
+		Use:   "logs <taskId> [flags]",
+	}
+)
+
+func init() {
+	logsCmd.Flags().StringVarP(&LogsOutput, "output", "o", "", "output directory for the downloaded log file (defaults to Downloads folder)")
+}
+
+func getDefaultLogsDir() (string, error) {
+	if runtime.GOOS == "linux" {
+		if xdgDownload := os.Getenv("XDG_DOWNLOAD_DIR"); xdgDownload != "" {
+			return xdgDownload, nil
+		}
+	}
+
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", errors.Wrap(err, "unable to determine user home directory")
+	}
+
+	return filepath.Join(homeDir, "Downloads"), nil
+}

cmd/rwx/root.go

@@ -118,6 +118,7 @@ func init() {
 	rootCmd.AddCommand(mcpCmd)
 	rootCmd.AddCommand(imageCmd)
 	rootCmd.AddCommand(pushCmd)
+	rootCmd.AddCommand(logsCmd)
 
 	cobra.OnInitialize(func() {
 		if AccessToken == "$RWX_ACCESS_TOKEN" {

internal/api/client.go

@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"net/url"
 	"strings"
+	"time"
 
 	"github.com/rwx-cloud/cli/cmd/rwx/config"
 	"github.com/rwx-cloud/cli/internal/accesstoken"
@@ -575,6 +576,131 @@ func (c Client) TaskStatus(cfg TaskStatusConfig) (TaskStatusResult, error) {
 	return result, nil
 }
 
+func (c Client) GetLogDownloadRequest(taskId string) (LogDownloadRequestResult, error) {
+	endpoint := fmt.Sprintf("/mint/api/log_downloads/%s", url.PathEscape(taskId))
+	result := LogDownloadRequestResult{}
+
+	req, err := http.NewRequest(http.MethodGet, endpoint, nil)
+	if err != nil {
+		return result, errors.Wrap(err, "unable to create new HTTP request")
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.RoundTrip(req)
+	if err != nil {
+		return result, errors.Wrap(err, "HTTP request failed")
+	}
+	defer resp.Body.Close()
+
+	if err = decodeResponseJSON(resp, &result); err != nil {
+		return result, err
+	}
+
+	return result, nil
+}
+
+func (c Client) DownloadLogs(request LogDownloadRequestResult, maxRetryDurationSeconds ...int) ([]byte, error) {
+	maxRetryDuration := 30 * time.Second
+	if len(maxRetryDurationSeconds) > 0 && maxRetryDurationSeconds[0] > 0 {
+		maxRetryDuration = time.Duration(maxRetryDurationSeconds[0]) * time.Second
+	}
+	const initialBackoff = 1 * time.Second
+
+	startTime := time.Now()
+	backoff := initialBackoff
+	attempt := 0
+
+	var lastErr error
+
+	for {
+		attempt++
+
+		// need to recreate for each attempt since body readers are consumed
+		var req *http.Request
+		var err error
+
+		if request.Contents != nil {
+			// POST approach, for zip files (group tasks)
+			formData := url.Values{}
+			formData.Set("token", request.Token)
+			formData.Set("filename", request.Filename)
+			formData.Set("contents", *request.Contents)
+			encodedBody := formData.Encode()
+
+			req, err = http.NewRequest(http.MethodPost, request.URL, strings.NewReader(encodedBody))
+			if err != nil {
+				return nil, errors.Wrap(err, "unable to create new HTTP request")
+			}
+			req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+			req.Header.Set("Accept", "application/octet-stream")
+		} else {
+			// GET approach, for single log files
+			req, err = http.NewRequest(http.MethodGet, request.URL, nil)
+			if err != nil {
+				return nil, errors.Wrap(err, "unable to create new HTTP request")
+			}
+			req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", request.Token))
+			req.Header.Set("Accept", "application/octet-stream")
+		}
+
+		// Use http.DefaultClient directly since the logs will come from a task server URL rather than Cloud
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			lastErr = errors.Wrap(err, "HTTP request failed")
+
+			if time.Since(startTime) >= maxRetryDuration {
+				return nil, errors.Wrapf(lastErr, "failed after %d attempts over %v", attempt, time.Since(startTime).Round(time.Second))
+			}
+
+			time.Sleep(backoff)
+			backoff *= 2
+			if backoff > 5*time.Second {
+				backoff = 5 * time.Second
+			}
+			continue
+		}
+
+		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+			defer resp.Body.Close()
+			logBytes, err := io.ReadAll(resp.Body)
+			if err != nil {
+				return nil, errors.Wrap(err, "unable to read response body")
+			}
+			return logBytes, nil
+		}
+
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		resp.Body.Close()
+
+		// Don't retry on 4xx errors
+		if resp.StatusCode >= 400 && resp.StatusCode < 500 {
+			errMsg := extractErrorMessage(bytes.NewReader(bodyBytes))
+			if errMsg == "" {
+				errMsg = fmt.Sprintf("Unable to download logs - %s", resp.Status)
+			}
+			return nil, errors.New(errMsg)
+		}
+
+		// Retry on 5xx errors - task server may be waking up
+		errMsg := extractErrorMessage(bytes.NewReader(bodyBytes))
+		if errMsg == "" {
+			errMsg = fmt.Sprintf("Unable to download logs - %s", resp.Status)
+		}
+		lastErr = errors.New(errMsg)
+
+		if time.Since(startTime) >= maxRetryDuration {
+			return nil, errors.Wrapf(lastErr, "failed after %d attempts over %v", attempt, time.Since(startTime).Round(time.Second))
+		}
+
+		time.Sleep(backoff)
+		backoff *= 2
+		if backoff > 5*time.Second {
+			backoff = 5 * time.Second
+		}
+	}
+}
+
 func decodeResponseJSON(resp *http.Response, result any) error {
 	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
 		if result == nil {