wehub-resource-sync
312 lines
11 KiB
Go
312 lines
11 KiB
Go
package github
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"mime"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/github/github-mcp-server/pkg/inventory"
|
|
"github.com/github/github-mcp-server/pkg/octicons"
|
|
"github.com/github/github-mcp-server/pkg/raw"
|
|
"github.com/github/github-mcp-server/pkg/translations"
|
|
"github.com/google/go-github/v89/github"
|
|
"github.com/modelcontextprotocol/go-sdk/mcp"
|
|
"github.com/yosida95/uritemplate/v3"
|
|
)
|
|
|
|
var (
|
|
repositoryResourceContentURITemplate = uritemplate.MustNew("repo://{owner}/{repo}/contents{/path*}")
|
|
repositoryResourceBranchContentURITemplate = uritemplate.MustNew("repo://{owner}/{repo}/refs/heads/{branch}/contents{/path*}")
|
|
repositoryResourceCommitContentURITemplate = uritemplate.MustNew("repo://{owner}/{repo}/sha/{sha}/contents{/path*}")
|
|
repositoryResourceTagContentURITemplate = uritemplate.MustNew("repo://{owner}/{repo}/refs/tags/{tag}/contents{/path*}")
|
|
repositoryResourcePrContentURITemplate = uritemplate.MustNew("repo://{owner}/{repo}/refs/pull/{prNumber}/head/contents{/path*}")
|
|
)
|
|
|
|
// GetRepositoryResourceContent defines the resource template for getting repository content.
|
|
func GetRepositoryResourceContent(t translations.TranslationHelperFunc) inventory.ServerResourceTemplate {
|
|
return inventory.NewServerResourceTemplate(
|
|
ToolsetMetadataRepos,
|
|
mcp.ResourceTemplate{
|
|
Name: "repository_content",
|
|
URITemplate: repositoryResourceContentURITemplate.Raw(),
|
|
Description: t("RESOURCE_REPOSITORY_CONTENT_DESCRIPTION", "Repository Content"),
|
|
Icons: octicons.Icons("repo"),
|
|
},
|
|
repositoryResourceContentsHandlerFunc(repositoryResourceContentURITemplate),
|
|
)
|
|
}
|
|
|
|
// GetRepositoryResourceBranchContent defines the resource template for getting repository content for a branch.
|
|
func GetRepositoryResourceBranchContent(t translations.TranslationHelperFunc) inventory.ServerResourceTemplate {
|
|
return inventory.NewServerResourceTemplate(
|
|
ToolsetMetadataRepos,
|
|
mcp.ResourceTemplate{
|
|
Name: "repository_content_branch",
|
|
URITemplate: repositoryResourceBranchContentURITemplate.Raw(),
|
|
Description: t("RESOURCE_REPOSITORY_CONTENT_BRANCH_DESCRIPTION", "Repository Content for specific branch"),
|
|
Icons: octicons.Icons("git-branch"),
|
|
},
|
|
repositoryResourceContentsHandlerFunc(repositoryResourceBranchContentURITemplate),
|
|
)
|
|
}
|
|
|
|
// GetRepositoryResourceCommitContent defines the resource template for getting repository content for a commit.
|
|
func GetRepositoryResourceCommitContent(t translations.TranslationHelperFunc) inventory.ServerResourceTemplate {
|
|
return inventory.NewServerResourceTemplate(
|
|
ToolsetMetadataRepos,
|
|
mcp.ResourceTemplate{
|
|
Name: "repository_content_commit",
|
|
URITemplate: repositoryResourceCommitContentURITemplate.Raw(),
|
|
Description: t("RESOURCE_REPOSITORY_CONTENT_COMMIT_DESCRIPTION", "Repository Content for specific commit"),
|
|
Icons: octicons.Icons("git-commit"),
|
|
},
|
|
repositoryResourceContentsHandlerFunc(repositoryResourceCommitContentURITemplate),
|
|
)
|
|
}
|
|
|
|
// GetRepositoryResourceTagContent defines the resource template for getting repository content for a tag.
|
|
func GetRepositoryResourceTagContent(t translations.TranslationHelperFunc) inventory.ServerResourceTemplate {
|
|
return inventory.NewServerResourceTemplate(
|
|
ToolsetMetadataRepos,
|
|
mcp.ResourceTemplate{
|
|
Name: "repository_content_tag",
|
|
URITemplate: repositoryResourceTagContentURITemplate.Raw(),
|
|
Description: t("RESOURCE_REPOSITORY_CONTENT_TAG_DESCRIPTION", "Repository Content for specific tag"),
|
|
Icons: octicons.Icons("tag"),
|
|
},
|
|
repositoryResourceContentsHandlerFunc(repositoryResourceTagContentURITemplate),
|
|
)
|
|
}
|
|
|
|
// GetRepositoryResourcePrContent defines the resource template for getting repository content for a pull request.
|
|
func GetRepositoryResourcePrContent(t translations.TranslationHelperFunc) inventory.ServerResourceTemplate {
|
|
return inventory.NewServerResourceTemplate(
|
|
ToolsetMetadataRepos,
|
|
mcp.ResourceTemplate{
|
|
Name: "repository_content_pr",
|
|
URITemplate: repositoryResourcePrContentURITemplate.Raw(),
|
|
Description: t("RESOURCE_REPOSITORY_CONTENT_PR_DESCRIPTION", "Repository Content for specific pull request"),
|
|
Icons: octicons.Icons("git-pull-request"),
|
|
},
|
|
repositoryResourceContentsHandlerFunc(repositoryResourcePrContentURITemplate),
|
|
)
|
|
}
|
|
|
|
// repositoryResourceContentsHandlerFunc returns a ResourceHandlerFunc that creates handlers on-demand.
|
|
func repositoryResourceContentsHandlerFunc(resourceURITemplate *uritemplate.Template) inventory.ResourceHandlerFunc {
|
|
return func(_ any) mcp.ResourceHandler {
|
|
return RepositoryResourceContentsHandler(resourceURITemplate)
|
|
}
|
|
}
|
|
|
|
// RepositoryResourceContentsHandler returns a handler function for repository content requests.
|
|
// It retrieves ToolDependencies from the context at call time via MustDepsFromContext.
|
|
func RepositoryResourceContentsHandler(resourceURITemplate *uritemplate.Template) mcp.ResourceHandler {
|
|
return func(ctx context.Context, request *mcp.ReadResourceRequest) (*mcp.ReadResourceResult, error) {
|
|
deps := MustDepsFromContext(ctx)
|
|
// Match the URI to extract parameters
|
|
uriValues := resourceURITemplate.Match(request.Params.URI)
|
|
if uriValues == nil {
|
|
return nil, fmt.Errorf("failed to match URI: %s", request.Params.URI)
|
|
}
|
|
|
|
// Extract required vars
|
|
owner := uriValues.Get("owner").String()
|
|
repo := uriValues.Get("repo").String()
|
|
|
|
if owner == "" {
|
|
return nil, errors.New("owner is required")
|
|
}
|
|
|
|
if repo == "" {
|
|
return nil, errors.New("repo is required")
|
|
}
|
|
|
|
pathValue := uriValues.Get("path")
|
|
pathComponents := pathValue.List()
|
|
var path string
|
|
|
|
if len(pathComponents) == 0 {
|
|
path = pathValue.String()
|
|
} else {
|
|
path = strings.Join(pathComponents, "/")
|
|
}
|
|
|
|
opts := &github.RepositoryContentGetOptions{}
|
|
rawOpts := &raw.ContentOpts{}
|
|
|
|
sha := uriValues.Get("sha").String()
|
|
if sha != "" {
|
|
opts.Ref = sha
|
|
rawOpts.SHA = sha
|
|
}
|
|
|
|
branch := uriValues.Get("branch").String()
|
|
if branch != "" {
|
|
opts.Ref = "refs/heads/" + branch
|
|
rawOpts.Ref = "refs/heads/" + branch
|
|
}
|
|
|
|
tag := uriValues.Get("tag").String()
|
|
if tag != "" {
|
|
opts.Ref = "refs/tags/" + tag
|
|
rawOpts.Ref = "refs/tags/" + tag
|
|
}
|
|
|
|
prNumber := uriValues.Get("prNumber").String()
|
|
if prNumber != "" {
|
|
// fetch the PR from the API to get the latest commit and use SHA
|
|
githubClient, err := deps.GetClient(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get GitHub client: %w", err)
|
|
}
|
|
prNum, err := strconv.Atoi(prNumber)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid pull request number: %w", err)
|
|
}
|
|
pr, _, err := githubClient.PullRequests.Get(ctx, owner, repo, prNum)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get pull request: %w", err)
|
|
}
|
|
sha := pr.GetHead().GetSHA()
|
|
rawOpts.SHA = sha
|
|
opts.Ref = sha
|
|
}
|
|
// if it's a directory
|
|
if path == "" || strings.HasSuffix(path, "/") {
|
|
return nil, fmt.Errorf("directories are not supported: %s", path)
|
|
}
|
|
rawClient, err := deps.GetRawClient(ctx)
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get GitHub raw content client: %w", err)
|
|
}
|
|
|
|
resp, err := rawClient.GetRawContent(ctx, owner, repo, path, rawOpts)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get raw content: %w", err)
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
// If the raw content is not found, we will fall back to the GitHub API (in case it is a directory)
|
|
switch {
|
|
case resp.StatusCode == http.StatusOK:
|
|
ext := filepath.Ext(path)
|
|
mimeType := resp.Header.Get("Content-Type")
|
|
if ext == ".md" {
|
|
mimeType = "text/markdown"
|
|
} else if mimeType == "" {
|
|
mimeType = mime.TypeByExtension(ext)
|
|
}
|
|
|
|
content, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read file content: %w", err)
|
|
}
|
|
|
|
switch {
|
|
case strings.HasPrefix(mimeType, "text"), strings.HasPrefix(mimeType, "application"):
|
|
return &mcp.ReadResourceResult{
|
|
Contents: []*mcp.ResourceContents{
|
|
{
|
|
URI: request.Params.URI,
|
|
MIMEType: mimeType,
|
|
Text: string(content),
|
|
},
|
|
},
|
|
}, nil
|
|
default:
|
|
var buf bytes.Buffer
|
|
base64Encoder := base64.NewEncoder(base64.StdEncoding, &buf)
|
|
_, err := base64Encoder.Write(content)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to base64 encode content: %w", err)
|
|
}
|
|
if err := base64Encoder.Close(); err != nil {
|
|
return nil, fmt.Errorf("failed to close base64 encoder: %w", err)
|
|
}
|
|
|
|
return &mcp.ReadResourceResult{
|
|
Contents: []*mcp.ResourceContents{
|
|
{
|
|
URI: request.Params.URI,
|
|
MIMEType: mimeType,
|
|
Blob: buf.Bytes(),
|
|
},
|
|
},
|
|
}, nil
|
|
}
|
|
case resp.StatusCode != http.StatusNotFound:
|
|
// If we got a response but it is not 200 OK, we return an error
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response body: %w", err)
|
|
}
|
|
return nil, fmt.Errorf("failed to fetch raw content: %s", string(body))
|
|
default:
|
|
// This should be unreachable because GetContents should return an error if neither file nor directory content is found.
|
|
return nil, errors.New("404 Not Found")
|
|
}
|
|
}
|
|
}
|
|
|
|
// expandRepoResourceURI builds a resource URI using the appropriate URI template
|
|
// based on the provided parameters (sha, ref, or default).
|
|
func expandRepoResourceURI(owner, repo, sha, ref string, pathParts []string) (string, error) {
|
|
baseValues := uritemplate.Values{
|
|
"owner": uritemplate.String(owner),
|
|
"repo": uritemplate.String(repo),
|
|
"path": uritemplate.List(pathParts...),
|
|
}
|
|
|
|
switch {
|
|
case sha != "":
|
|
baseValues["sha"] = uritemplate.String(sha)
|
|
return repositoryResourceCommitContentURITemplate.Expand(baseValues)
|
|
|
|
case ref != "":
|
|
// Parse ref to determine which template to use
|
|
switch {
|
|
case strings.HasPrefix(ref, "refs/heads/"):
|
|
branch := strings.TrimPrefix(ref, "refs/heads/")
|
|
baseValues["branch"] = uritemplate.String(branch)
|
|
return repositoryResourceBranchContentURITemplate.Expand(baseValues)
|
|
|
|
case strings.HasPrefix(ref, "refs/tags/"):
|
|
tag := strings.TrimPrefix(ref, "refs/tags/")
|
|
baseValues["tag"] = uritemplate.String(tag)
|
|
return repositoryResourceTagContentURITemplate.Expand(baseValues)
|
|
|
|
case strings.HasPrefix(ref, "refs/pull/") && strings.HasSuffix(ref, "/head"):
|
|
// Extract PR number from "refs/pull/{number}/head"
|
|
prPart := strings.TrimPrefix(ref, "refs/pull/")
|
|
prNumber := strings.TrimSuffix(prPart, "/head")
|
|
baseValues["prNumber"] = uritemplate.String(prNumber)
|
|
return repositoryResourcePrContentURITemplate.Expand(baseValues)
|
|
|
|
case looksLikeSHA(ref):
|
|
// ref is actually a SHA (e.g., from resolveGitReference)
|
|
baseValues["sha"] = uritemplate.String(ref)
|
|
return repositoryResourceCommitContentURITemplate.Expand(baseValues)
|
|
|
|
default:
|
|
// For other refs (like a branch name without refs/heads/ prefix),
|
|
// treat it as a branch
|
|
baseValues["branch"] = uritemplate.String(ref)
|
|
return repositoryResourceBranchContentURITemplate.Expand(baseValues)
|
|
}
|
|
|
|
default:
|
|
return repositoryResourceContentURITemplate.Expand(baseValues)
|
|
}
|
|
}
|