review-bot/github/client.go

// Package github provides a client for the GitHub API.
// It supports pull request operations, file content retrieval,
// and review submission for both github.com and GitHub Enterprise.
package github

import (
	"bytes"
	"context"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"time"
)

const (
	defaultBaseURL = "https://api.github.com"

	// maxRetryAttempts is the number of times doRequest will attempt a request.
	maxRetryAttempts = 3

	// maxRetryAfter caps the maximum delay from a Retry-After header to prevent
	// a server from stalling the client indefinitely.
	maxRetryAfter = 60 * time.Second

	// maxErrorBodyBytes limits how much of an error response body we read
	// to protect against malicious servers sending unbounded data.
	maxErrorBodyBytes = 64 * 1024 // 64 KB

	// maxResponseBodyBytes limits how much of a successful response body we read
	// for defense-in-depth against servers returning excessively large payloads.
	maxResponseBodyBytes = 10 * 1024 * 1024 // 10 MB
)

// APIError represents an HTTP error response from the GitHub API.
// It carries the status code so callers can distinguish between
// different failure modes (e.g. 404 vs 500).
//
// The Body field stores up to 64 KiB of the raw response for programmatic
// inspection. Error() truncates to 200 bytes for safe logging, but callers
// should avoid logging or propagating Body directly in production since it may
// contain sensitive details from the upstream server.
type APIError struct {
	StatusCode int
	Body       string
}

func (e *APIError) Error() string {
	body := e.Body
	if len(body) > 200 {
		body = body[:200] + "...(truncated)"
	}
	// Sanitize newlines to prevent log injection from upstream response bodies.
	body = strings.ReplaceAll(body, "\n", " ")
	body = strings.ReplaceAll(body, "\r", " ")
	return fmt.Sprintf("HTTP %d: %s", e.StatusCode, body)
}

// IsNotFound reports whether an error is an API 404 response.
func IsNotFound(err error) bool {
	if apiErr, ok := asAPIError(err); ok {
		return apiErr.StatusCode == http.StatusNotFound
	}
	return false
}

// IsUnauthorized reports whether an error is an API 401 response.
func IsUnauthorized(err error) bool {
	if apiErr, ok := asAPIError(err); ok {
		return apiErr.StatusCode == http.StatusUnauthorized
	}
	return false
}

func asAPIError(err error) (*APIError, bool) {
	if err == nil {
		return nil, false
	}
	var target *APIError
	if errors.As(err, &target) {
		return target, true
	}
	return nil, false
}

// Client interacts with the GitHub API.
// A Client is safe for concurrent use by multiple goroutines.
// SetHTTPClient and SetRetryBackoff are intended for test setup only and must
// be called before any goroutines issue requests; they have no synchronization.
type Client struct {
	baseURL    string
	token      string
	httpClient *http.Client

	// allowInsecureHTTP permits requests to HTTP (non-TLS) endpoints.
	// When false, doRequest rejects URLs with an http:// scheme.
	allowInsecureHTTP bool

	// retryBackoff defines the delays between retry attempts for 429 responses.
	// retryBackoff[i] is the delay before attempt i+1 (after attempt i fails).
	// If nil, defaults to {1s, 2s}.
	retryBackoff []time.Duration

	// now returns the current time. Defaults to time.Now.
	// Override in tests to control HTTP-date Retry-After calculations.
	now func() time.Time
}

// defaultCheckRedirect is the redirect policy used by NewClient.
// NOTE: This function is intentionally duplicated in gitea/client.go (and vice versa)
// because the packages are separate. Changes here must be mirrored there.
// It rejects HTTPS->HTTP protocol downgrades (to prevent plaintext leakage)
// and cross-host redirects (to prevent following responses from untrusted
// endpoints). Same-host, same-or-upgraded-scheme redirects are allowed.
func defaultCheckRedirect(req *http.Request, via []*http.Request) error {
	if len(via) >= 10 {
		return fmt.Errorf("stopped after 10 redirects")
	}
	// Guard for direct invocation in tests and any future callers;
	// net/http guarantees len(via) >= 1 during actual redirects.
	if len(via) == 0 {
		return nil
	}
	prev := via[len(via)-1]
	// Reject protocol downgrade: HTTPS->HTTP leaks request metadata over plaintext.
	if prev.URL.Scheme == "https" && req.URL.Scheme == "http" {
		return fmt.Errorf("refusing redirect: HTTPS to HTTP downgrade (%s -> %s)", prev.URL.Host, req.URL.Host)
	}
	// Reject cross-host redirect entirely to avoid consuming responses
	// from untrusted endpoints.
	if req.URL.Host != prev.URL.Host {
		return fmt.Errorf("refusing redirect: cross-host (%s -> %s)", prev.URL.Host, req.URL.Host)
	}
	return nil
}

// ClientOption configures optional behavior of a Client.
type ClientOption func(*clientConfig)

type clientConfig struct {
	allowInsecureHTTP    bool
	insecureIsTestBypass bool
}

// AllowInsecureHTTP permits sending credentials over plaintext HTTP connections.
// In production, this option is gated by the REVIEW_BOT_ALLOW_INSECURE=1
// environment variable. Without the env var set, the option is ignored
// and a warning is logged.
//
// For tests, use AllowInsecureHTTPForTest (defined in a _test.go file in the same package) which bypasses the env gate.
func AllowInsecureHTTP() ClientOption {
	return func(cfg *clientConfig) {
		cfg.allowInsecureHTTP = true
	}
}

// NewClient creates a new GitHub API client.
// If baseURL is empty, it defaults to https://api.github.com.
// For GitHub Enterprise, pass the API base URL (e.g. https://github.concur.com/api/v3).
func NewClient(token, baseURL string, opts ...ClientOption) *Client {
	if baseURL == "" {
		baseURL = defaultBaseURL
	}

	var cfg clientConfig
	for _, opt := range opts {
		opt(&cfg)
	}

	if cfg.allowInsecureHTTP && !cfg.insecureIsTestBypass {
		if os.Getenv("REVIEW_BOT_ALLOW_INSECURE") != "1" {
			slog.Warn("AllowInsecureHTTP ignored: set REVIEW_BOT_ALLOW_INSECURE=1 to enable")
			cfg.allowInsecureHTTP = false
		} else {
			slog.Warn("AllowInsecureHTTP enabled — credentials may be sent over plaintext",
				"env", "REVIEW_BOT_ALLOW_INSECURE=1")
		}
	}

	return &Client{
		baseURL:           strings.TrimRight(baseURL, "/"),
		token:             token,
		allowInsecureHTTP: cfg.allowInsecureHTTP,
		httpClient: &http.Client{
			Timeout:       30 * time.Second,
			CheckRedirect: defaultCheckRedirect,
		},
		now: time.Now,
	}
}

// SetHTTPClient sets the underlying HTTP client used for requests.
// This is intended for test setup only to inject mock transports; it must be
// called before any goroutines issue requests.
//
// Passing nil restores the default client (30s timeout + redirect-rejecting
// CheckRedirect policy matching NewClient).
//
// Callers providing a non-nil client are responsible for configuring a safe
// CheckRedirect policy. Without one, the default net/http behavior will follow
// redirects and may forward the Authorization header to untrusted hosts.
func (c *Client) SetHTTPClient(hc *http.Client) {
	if hc == nil {
		hc = &http.Client{
			Timeout:       30 * time.Second,
			CheckRedirect: defaultCheckRedirect,
		}
	}
	c.httpClient = hc
}

// SetRetryBackoff sets the delays between retry attempts.
// This is intended for testing to speed up retry tests.
//
// Note: if an empty non-nil slice is provided, Retry-After delays parsed from
// server responses will be computed and capped but not applied (because
// attempt < len(backoff) is always false). This is acceptable for the
// test-only use case but callers should be aware of this edge case.
func (c *Client) SetRetryBackoff(backoff []time.Duration) {
	c.retryBackoff = backoff
}

// parseRetryAfter parses a Retry-After header value, supporting both integer
// seconds (e.g. "120") and HTTP-date format (e.g. "Thu, 01 Dec 2025 16:00:00 GMT")
// as specified in RFC 7231 §7.1.3.
//
// For integer values, it returns the duration directly.
// For HTTP-date values, it computes the delay as the difference between the
// parsed time and now. If the date is in the past, it returns 0.
//
// Returns (0, false) if the value cannot be parsed as either format.
func (c *Client) parseRetryAfter(value string) (time.Duration, bool) {
	value = strings.TrimSpace(value)

	// Try integer seconds first (most common from GitHub).
	// RFC 7231 allows delta-seconds of 0 to indicate immediate retry.
	if seconds, err := strconv.Atoi(value); err == nil && seconds >= 0 {
		return time.Duration(seconds) * time.Second, true
	}

	// Try HTTP-date format (RFC 7231 §7.1.3).
	// http.ParseTime handles RFC 1123, RFC 850, and ASCTIME formats.
	if retryAt, err := http.ParseTime(value); err == nil {
		delay := retryAt.Sub(c.now())
		if delay < 0 {
			delay = 0
		}
		return delay, true
	}

	return 0, false
}

// redactURL redacts sensitive components from a URL for safe inclusion in error
// messages and log output. It removes userinfo (e.g., user:pass@) and replaces
// query parameters with a placeholder.
func redactURL(rawURL string) string {
	u, err := url.Parse(rawURL)
	if err != nil {
		return "<unparseable URL>"
	}
	u.User = nil

	if u.RawQuery != "" {
		u.RawQuery = "<redacted>"
	}
	return u.String()
}

// doRequest performs an HTTP request with retry on 429 rate limit responses.
// It respects the Retry-After header when present, supporting both integer
// seconds and HTTP-date formats (capped at maxRetryAfter).
func (c *Client) doRequest(ctx context.Context, method, reqURL string, accept string) ([]byte, error) {
	// NOTE: This parses reqURL a second time (http.NewRequestWithContext parses it
	// again internally). Acceptable cost: URL parsing is cheap and threading the
	// parsed *url.URL through would complicate the interface for negligible gain.
	if !c.allowInsecureHTTP {
		parsed, err := url.Parse(reqURL)
		if err != nil {
			return nil, fmt.Errorf("parse request URL: %w", err)
		}
		if strings.EqualFold(parsed.Scheme, "http") {
			return nil, fmt.Errorf("refusing HTTP request to %s: use HTTPS or set AllowInsecureHTTP option", redactURL(reqURL))
		}
	}

	var backoff []time.Duration
	if c.retryBackoff != nil {
		backoff = append([]time.Duration(nil), c.retryBackoff...)
	} else {
		backoff = []time.Duration{1 * time.Second, 2 * time.Second}
	}

	var lastErr error
	for attempt := 0; attempt < maxRetryAttempts; attempt++ {
		if attempt > 0 {
			var delay time.Duration
			if attempt-1 < len(backoff) {
				delay = backoff[attempt-1]
			}
			if delay > 0 {
				timer := time.NewTimer(delay)
				select {
				case <-timer.C:
					timer.Stop() // no-op after fire; kept for symmetry with the ctx.Done case
				case <-ctx.Done():
					timer.Stop()
					return nil, ctx.Err()
				}
			}
		}

		req, err := http.NewRequestWithContext(ctx, method, reqURL, nil)
		if err != nil {
			return nil, fmt.Errorf("create request: %w", err)
		}
		req.Header.Set("Authorization", "Bearer "+c.token)
		if accept != "" {
			req.Header.Set("Accept", accept)
		} else {
			req.Header.Set("Accept", "application/vnd.github+json")
		}

		resp, err := c.httpClient.Do(req)
		if err != nil {
			return nil, fmt.Errorf("do request: %w", err)
		}

		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
			body, err := io.ReadAll(io.LimitReader(resp.Body, maxResponseBodyBytes))
			resp.Body.Close()
			if err != nil {
				return nil, fmt.Errorf("read response body: %w", err)
			}
			return body, nil
		}

		errBody, _ := io.ReadAll(io.LimitReader(resp.Body, maxErrorBodyBytes))
		resp.Body.Close()

		lastErr = &APIError{StatusCode: resp.StatusCode, Body: string(errBody)}

		// Retry on 429 rate limit
		if resp.StatusCode == http.StatusTooManyRequests && attempt < maxRetryAttempts-1 {
			// Check for Retry-After header and override backoff if present.
			// Supports both integer seconds (common) and HTTP-date format (RFC 7231).
			if ra := resp.Header.Get("Retry-After"); ra != "" {
				if delay, ok := c.parseRetryAfter(ra); ok {
					if delay > maxRetryAfter {
						delay = maxRetryAfter
					}
					if attempt < len(backoff) {
						backoff[attempt] = delay
					}
				}
			}
			continue
		}

		// Don't retry other errors
		return nil, lastErr
	}

	return nil, lastErr
}

// doGet is a convenience wrapper for GET requests with the default Accept header.
func (c *Client) doGet(ctx context.Context, url string) ([]byte, error) {
	return c.doRequest(ctx, http.MethodGet, url, "")
}

// DefaultMaxDiffSize is the default maximum diff size in bytes (10 MB).
const DefaultMaxDiffSize = 10 * 1024 * 1024

// ErrDiffTooLarge is returned when a PR diff exceeds the configured MaxDiffSize.
var ErrDiffTooLarge = errors.New("diff size exceeds maximum allowed size")

// PullRequest holds relevant PR metadata.
type PullRequest struct {
	Title string `json:"title"`
	Body  string `json:"body"`
	Head  struct {
		Sha string `json:"sha"`
		Ref string `json:"ref"`
	} `json:"head"`
}

// CommitStatus represents a single CI status entry.
type CommitStatus struct {
	Status      string `json:"state"`
	Context     string `json:"context"`
	Description string `json:"description"`
	TargetURL   string `json:"target_url"`
}

// ChangedFile represents a file modified in a PR.
type ChangedFile struct {
	Filename string `json:"filename"`
	Status   string `json:"status"`
}

// ContentEntry represents a file or directory in a repository.
type ContentEntry struct {
	Name string `json:"name"`
	Path string `json:"path"`
	Type string `json:"type"`
}

// contentResponse is the GitHub API response for a single file's content.
type contentResponse struct {
	Content  string `json:"content"`
	Encoding string `json:"encoding"`
	Type     string `json:"type"`
	Name     string `json:"name"`
	Path     string `json:"path"`
}

// GetPullRequest fetches PR metadata.
func (c *Client) GetPullRequest(ctx context.Context, owner, repo string, number int) (*PullRequest, error) {
	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d",
		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)

	body, err := c.doGet(ctx, reqURL)
	if err != nil {
		return nil, fmt.Errorf("fetch PR: %w", err)
	}
	var pr PullRequest
	if err := json.Unmarshal(body, &pr); err != nil {
		return nil, fmt.Errorf("parse PR response: %w", err)
	}
	return &pr, nil
}



// GetPullRequestFiles fetches the list of files changed in a PR.
func (c *Client) GetPullRequestFiles(ctx context.Context, owner, repo string, number int) ([]ChangedFile, error) {
	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d/files",
		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)

	body, err := c.doGet(ctx, reqURL)
	if err != nil {
		return nil, fmt.Errorf("fetch PR files: %w", err)
	}
	var files []ChangedFile
	if err := json.Unmarshal(body, &files); err != nil {
		return nil, fmt.Errorf("parse PR files response: %w", err)
	}
	return files, nil
}

// GetCommitStatuses fetches CI statuses for a commit SHA.
func (c *Client) GetCommitStatuses(ctx context.Context, owner, repo, sha string) ([]CommitStatus, error) {
	reqURL := fmt.Sprintf("%s/repos/%s/%s/commits/%s/statuses",
		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), url.PathEscape(sha))

	body, err := c.doGet(ctx, reqURL)
	if err != nil {
		return nil, fmt.Errorf("fetch commit statuses: %w", err)
	}
	var statuses []CommitStatus
	if err := json.Unmarshal(body, &statuses); err != nil {
		return nil, fmt.Errorf("parse commit statuses response: %w", err)
	}
	return statuses, nil
}

// decodeFileContent decodes the content from a GitHub contents API response.
// GitHub returns content as base64-encoded string with newlines inserted;
// this function strips the newlines before decoding.
func decodeFileContent(resp contentResponse) (string, error) {
	if resp.Encoding != "base64" {
		return "", fmt.Errorf("unsupported content encoding: %q", resp.Encoding)
	}
	// GitHub inserts newlines every 60 characters; strip them before decoding.
	stripped := strings.ReplaceAll(resp.Content, "\n", "")
	decoded, err := base64.StdEncoding.DecodeString(stripped)
	if err != nil {
		return "", fmt.Errorf("decode base64 content: %w", err)
	}
	return string(decoded), nil
}

// GetFileContent fetches the content of a file at the default branch HEAD.
func (c *Client) GetFileContent(ctx context.Context, owner, repo, filepath string) (string, error) {
	return c.GetFileContentRef(ctx, owner, repo, filepath, "")
}

// GetFileContentRef fetches the content of a file at the given ref (branch, tag, or SHA).
// If ref is empty, the default branch is used.
func (c *Client) GetFileContentRef(ctx context.Context, owner, repo, filepath, ref string) (string, error) {
	reqURL := fmt.Sprintf("%s/repos/%s/%s/contents/%s",
		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), escapePath(filepath))
	if ref != "" {
		reqURL += "?ref=" + url.QueryEscape(ref)
	}

	body, err := c.doGet(ctx, reqURL)
	if err != nil {
		return "", fmt.Errorf("fetch file content %q: %w", filepath, err)
	}
	var resp contentResponse
	if err := json.Unmarshal(body, &resp); err != nil {
		return "", fmt.Errorf("parse file content response: %w", err)
	}
	content, err := decodeFileContent(resp)
	if err != nil {
		return "", fmt.Errorf("decode file content %q: %w", filepath, err)
	}
	return content, nil
}

// ListContents lists the files and directories at the given path.
// If path points to a file instead of a directory, it returns a single-entry slice.
func (c *Client) ListContents(ctx context.Context, owner, repo, path string) ([]ContentEntry, error) {
	reqURL := fmt.Sprintf("%s/repos/%s/%s/contents/%s",
		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), escapePath(path))

	body, err := c.doGet(ctx, reqURL)
	if err != nil {
		return nil, fmt.Errorf("list contents %q: %w", path, err)
	}

	// The GitHub API returns an array for directories and an object for files.
	// Try array first; if it fails, try object and wrap in a slice.
	var entries []ContentEntry
	if err := json.Unmarshal(body, &entries); err == nil {
		return entries, nil
	}

	// Try as a single ContentEntry (file path).
	var single contentResponse
	if err := json.Unmarshal(body, &single); err != nil {
		return nil, fmt.Errorf("parse contents response for %q: %w", path, err)
	}
	return []ContentEntry{{
		Name: single.Name,
		Path: single.Path,
		Type: single.Type,
	}}, nil
}

// doRequestWithBody performs an HTTP request with a JSON request body.
// Unlike doRequest, it does NOT retry — write operations should not be
// retried automatically.
func (c *Client) doRequestWithBody(ctx context.Context, method, reqURL string, data []byte) ([]byte, error) {
	if !c.allowInsecureHTTP {
		parsed, err := url.Parse(reqURL)
		if err != nil {
			return nil, fmt.Errorf("parse request URL: %w", err)
		}
		if strings.EqualFold(parsed.Scheme, "http") {
			return nil, fmt.Errorf("refusing HTTP request to %s: use HTTPS or set AllowInsecureHTTP option", redactURL(reqURL))
		}
	}

	var bodyReader *bytes.Reader
	if data != nil {
		bodyReader = bytes.NewReader(data)
	} else {
		bodyReader = bytes.NewReader(nil)
	}

	req, err := http.NewRequestWithContext(ctx, method, reqURL, bodyReader)
	if err != nil {
		return nil, fmt.Errorf("create request: %w", err)
	}
	req.Header.Set("Authorization", "Bearer "+c.token)
	req.Header.Set("Accept", "application/vnd.github+json")
	if data != nil {
		req.Header.Set("Content-Type", "application/json")
	}

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("do request: %w", err)
	}

	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
		body, err := io.ReadAll(io.LimitReader(resp.Body, maxResponseBodyBytes))
		resp.Body.Close()
		if err != nil {
			return nil, fmt.Errorf("read response body: %w", err)
		}
		return body, nil
	}

	errBody, _ := io.ReadAll(io.LimitReader(resp.Body, maxErrorBodyBytes))
	resp.Body.Close()

	return nil, &APIError{StatusCode: resp.StatusCode, Body: string(errBody)}
}

// escapePath escapes each segment of a file path for use in URL path components.
// Slashes are preserved as separators; individual segments are PathEscaped.
func escapePath(p string) string {
	parts := strings.Split(p, "/")
	for i, part := range parts {
		parts[i] = url.PathEscape(part)
	}
	return strings.Join(parts, "/")
}

// GetPullRequestDiff fetches the unified diff for a PR.
// Returns ErrDiffTooLarge if the response exceeds DefaultMaxDiffSize bytes.
//
// It reads up to DefaultMaxDiffSize+1 bytes and checks for truncation:
// if exactly DefaultMaxDiffSize+1 bytes are available, the diff is too large.
func (c *Client) GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error) {
	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d",
		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)

	if !c.allowInsecureHTTP {
		parsed, err := url.Parse(reqURL)
		if err != nil {
			return "", fmt.Errorf("parse request URL: %w", err)
		}
		if strings.EqualFold(parsed.Scheme, "http") {
			return "", fmt.Errorf("refusing HTTP request to %s: use HTTPS or set AllowInsecureHTTP option", redactURL(reqURL))
		}
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqURL, nil)
	if err != nil {
		return "", fmt.Errorf("create PR diff request: %w", err)
	}
	req.Header.Set("Authorization", "Bearer "+c.token)
	req.Header.Set("Accept", "application/vnd.github.diff")

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return "", fmt.Errorf("fetch PR diff: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		errBody, _ := io.ReadAll(io.LimitReader(resp.Body, maxErrorBodyBytes))
		return "", &APIError{StatusCode: resp.StatusCode, Body: string(errBody)}
	}

	// Read up to DefaultMaxDiffSize+1 bytes. If we get exactly that many,
	// the diff exceeds the limit.
	limit := int64(DefaultMaxDiffSize) + 1
	raw, err := io.ReadAll(io.LimitReader(resp.Body, limit))
	if err != nil {
		return "", fmt.Errorf("read PR diff: %w", err)
	}
	if int64(len(raw)) == limit {
		return "", ErrDiffTooLarge
	}
	return string(raw), nil
}