HomeWork/gitea-mcp
5
0
Fork 0
mirror of https://gitea.com/gitea/gitea-mcp.git synced 2026-08-03 15:49:23 +02:00
Code Issues Packages Projects Releases Wiki Activity

feat(issue): add attachment read downloads (#218)

Browse Source 
- Add a read-only `attachment_read` tool for issue and issue comment attachments.
- Use the existing Gitea SDK attachment metadata APIs for `list` and `get`.
- Add authenticated `/attachments/{uuid}` downloads in the MCP server for `download`, with small image inline results and streamed file downloads for larger content.
- Add `-max-inline-attachment-bytes` / `GITEA_MAX_INLINE_ATTACHMENT_BYTES` to configure inline image limits.
- Update the tool tables in all README variants.

Refs: #209

Reviewed-on: https://gitea.com/gitea/gitea-mcp/pulls/218
Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com>
Co-authored-by: yp05327 <576951401@qq.com>
This commit is contained in:
yp05327
2026-07-26 11:53:02 +00:00
committed by bircni
parent 18fcd663e0
commit c97c38996c
10 changed files with 968 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/gitea/rest.go
+151 -15
View File
@@ -9,6 +9,8 @@ import (
"io"
"net/http"
"net/url"
"os"
"path"
"strings"
"sync"
"time"
@@ -34,6 +36,12 @@ func (e *HTTPError) Error() string {
return fmt.Sprintf("request failed with status %d: %s", e.StatusCode, e.Body)
}
type AttachmentResponse struct {
Body io.ReadCloser
ContentType string
StatusCode int
}
func tokenFromContext(ctx context.Context) string {
if ctx != nil {
if token, ok := ctx.Value(mcpContext.TokenContextKey).(string); ok && token != "" {
@@ -75,6 +83,40 @@ func buildAPIURL(path string, query url.Values) (string, error) {
return u.String(), nil
}
func buildAttachmentURL(attachmentPath string) (string, error) {
host := strings.TrimRight(flag.Host, "/")
if host == "" {
return "", errors.New("gitea host is empty")
}
baseURL, err := url.Parse(host)
if err != nil {
return "", err
}
if attachmentPath == "" {
return "", errors.New("attachment path is empty")
}
if strings.Contains(attachmentPath, "://") {
return "", errors.New("attachment path must not be a URL")
}
if !strings.HasPrefix(attachmentPath, "/attachments/") {
return "", errors.New("attachment path must start with /attachments/")
}
cleanPath := path.Clean(attachmentPath)
if !strings.HasPrefix(cleanPath, "/attachments/") {
return "", errors.New("attachment path must stay within /attachments/")
}
if cleanPath == "/attachments" || cleanPath == "/attachments/" {
return "", errors.New("attachment uuid is required")
}
joinedPath := strings.TrimRight(baseURL.Path, "/") + cleanPath
if joinedPath == "" {
joinedPath = cleanPath
}
baseURL.Path = joinedPath
baseURL.RawPath = joinedPath
return baseURL.String(), nil
}
// DoJSON performs an API request and decodes a JSON response into respOut (if non-nil).
// It returns the HTTP status code.
func DoJSON(ctx context.Context, method, path string, query url.Values, body, respOut any) (int, error) {
@@ -91,45 +133,142 @@ func DoJSON(ctx context.Context, method, path string, query url.Values, body, re
if err != nil {
return 0, err
}
req, err := http.NewRequestWithContext(ctx, method, u, bodyReader)
if err != nil {
return 0, fmt.Errorf("create request: %w", err)
}
token := tokenFromContext(ctx)
if token != "" {
req.Header.Set("Authorization", "token "+token)
}
req.Header.Set("Accept", "application/json")
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
if respOut != nil {
req.Header.Set("Accept", "application/json")
}
client := restHTTPClient()
resp, err := client.Do(req)
resp, err := restHTTPClient().Do(req)
if err != nil {
return 0, fmt.Errorf("do request: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
bodySnippet, _ := io.ReadAll(io.LimitReader(resp.Body, errBodySnippetSize))
bodySnippet, err := io.ReadAll(io.LimitReader(resp.Body, errBodySnippetSize+1))
if err != nil {
return resp.StatusCode, fmt.Errorf("read response: %w", err)
}
if len(bodySnippet) > errBodySnippetSize {
bodySnippet = bodySnippet[:errBodySnippetSize]
}
return resp.StatusCode, &HTTPError{StatusCode: resp.StatusCode, Body: strings.TrimSpace(string(bodySnippet))}
}
if respOut == nil {
_, _ = io.Copy(io.Discard, resp.Body) // best-effort
_, _ = io.Copy(io.Discard, resp.Body)
return resp.StatusCode, nil
}
if err := json.NewDecoder(resp.Body).Decode(respOut); err != nil {
return resp.StatusCode, fmt.Errorf("decode response: %w", err)
}
return resp.StatusCode, nil
}
func attachmentHTTPClient(origin *url.URL) *http.Client {
return &http.Client{
Transport: sharedTransport(),
CheckRedirect: func(req *http.Request, via []*http.Request) error {
if err := checkRedirect(req, via); err != nil {
return err
}
if req.URL.Scheme != origin.Scheme || req.URL.Host != origin.Host {
return errors.New("attachment redirect changed origin")
}
return nil
},
}
}
func OpenAttachment(ctx context.Context, attachmentPath, accept string) (*AttachmentResponse, error) {
u, err := buildAttachmentURL(attachmentPath)
if err != nil {
return nil, err
}
origin, err := url.Parse(u)
if err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
if err != nil {
return nil, fmt.Errorf("create request: %w", err)
}
token := tokenFromContext(ctx)
if token != "" {
req.Header.Set("Authorization", "token "+token)
}
if accept != "" {
req.Header.Set("Accept", accept)
}
resp, err := attachmentHTTPClient(origin).Do(req)
if err != nil {
return nil, fmt.Errorf("do request: %w", err)
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
defer resp.Body.Close()
bodySnippet, readErr := io.ReadAll(io.LimitReader(resp.Body, errBodySnippetSize+1))
if readErr != nil {
return nil, fmt.Errorf("read response: %w", readErr)
}
if len(bodySnippet) > errBodySnippetSize {
bodySnippet = bodySnippet[:errBodySnippetSize]
}
return nil, &HTTPError{StatusCode: resp.StatusCode, Body: strings.TrimSpace(string(bodySnippet))}
}
return &AttachmentResponse{Body: resp.Body, ContentType: resp.Header.Get("Content-Type"), StatusCode: resp.StatusCode}, nil
}
// DownloadAttachment downloads attachment bytes from a same-host attachment path.
func DownloadAttachment(ctx context.Context, attachmentPath, accept string) ([]byte, string, int, error) {
resp, err := OpenAttachment(ctx, attachmentPath, accept)
if err != nil {
var httpErr *HTTPError
if errors.As(err, &httpErr) {
return nil, "", httpErr.StatusCode, err
}
return nil, "", 0, err
}
defer resp.Body.Close()
respBytes, err := io.ReadAll(resp.Body)
if err != nil {
return nil, "", resp.StatusCode, fmt.Errorf("read response: %w", err)
}
return respBytes, resp.ContentType, resp.StatusCode, nil
}
func WriteAttachment(body io.Reader, outputPath string) (int64, error) {
file, err := os.OpenFile(outputPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
if err != nil {
return 0, err
}
defer file.Close()
if err := file.Chmod(0o600); err != nil {
return 0, err
}
written, err := io.Copy(file, body)
if err != nil {
return written, err
}
return written, file.Close()
}
// DoBytes performs an API request and returns the raw response bytes.
// It returns the HTTP status code.
func DoBytes(ctx context.Context, method, path string, query url.Values, body any, accept string) ([]byte, int, error) {
var bodyReader io.Reader
if body != nil {
@@ -144,24 +283,23 @@ func DoBytes(ctx context.Context, method, path string, query url.Values, body an
if err != nil {
return nil, 0, err
}
req, err := http.NewRequestWithContext(ctx, method, u, bodyReader)
if err != nil {
return nil, 0, fmt.Errorf("create request: %w", err)
}
token := tokenFromContext(ctx)
if token != "" {
req.Header.Set("Authorization", "token "+token)
}
if accept != "" {
req.Header.Set("Accept", accept)
}
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
if accept != "" {
req.Header.Set("Accept", accept)
}
client := restHTTPClient()
resp, err := client.Do(req)
resp, err := restHTTPClient().Do(req)
if err != nil {
return nil, 0, fmt.Errorf("do request: %w", err)
}
@@ -171,7 +309,6 @@ func DoBytes(ctx context.Context, method, path string, query url.Values, body an
if err != nil {
return nil, resp.StatusCode, fmt.Errorf("read response: %w", err)
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
bodySnippet := respBytes
if len(bodySnippet) > errBodySnippetSize {
@@ -179,6 +316,5 @@ func DoBytes(ctx context.Context, method, path string, query url.Values, body an
}
return nil, resp.StatusCode, &HTTPError{StatusCode: resp.StatusCode, Body: strings.TrimSpace(string(bodySnippet))}
}
return respBytes, resp.StatusCode, nil
}