feat(params): add structured argument binding helper

Add params.Bind, which unmarshals a tool call's map[string]any args into a
typed struct via JSON round-trip so JSON numbers land in the correct Go
numeric field types, and enforces `required:"true"` struct tags with clear
errors. Migrate the branch, tree, and file repo handlers to use it instead
of repeated args["x"].(string)/!ok extraction, preserving existing
validation behavior for each field.

Co-Authored-By: Codet <codet@commitgo.dev> (GPT-5-Codex)

README.md

@@ -20,14 +20,6 @@ make install
 
 Pass the Gitea host and access token as command-line flags or environment variables, flags take precedence. Run `gitea-mcp --help` for the full list of flags and environment variables. Logs are written to `$HOME/.gitea-mcp/gitea-mcp.log`, add `-d` for debug logging.
 
-Set `GITEA_EXTRA_HEADERS` to a JSON object of header name/value pairs to send with every outbound request to Gitea, for example when Gitea sits behind Cloudflare Access:
-
-```bash
-export GITEA_EXTRA_HEADERS='{"CF-Access-Client-Id":"id","CF-Access-Client-Secret":"secret"}'
-```
-
-These headers never override `Authorization`, `Content-Type`, or `Accept` set by `gitea-mcp` itself.
-
 ### MCP protocol and HTTP transport
 
 The server supports MCP up to `2026-07-28` and negotiates down to the client's version, advertising only the `tools` capability. Tool and Gitea failures return a `tools/call` result with `result.isError: true`, while malformed requests and server faults stay JSON-RPC errors.

cmd/cmd.go

@@ -2,11 +2,9 @@ package cmd
 
 import (
 	"context"
-	"encoding/json"
 	"flag"
 	"fmt"
 	"io"
-	"net/http"
 	"os"
 	"strconv"
 	"strings"
@@ -88,7 +86,6 @@ func initFlagSet(fs *flag.FlagSet, args []string, getenv func(string) string, re
 		fmt.Fprintf(w, "  GITEA_ACCESS_TOKEN\tProvide access token\n")
 		fmt.Fprintf(w, "  GITEA_ACCESS_TOKEN_FILE\tPath to a file containing the access token (e.g. a Docker secret)\n")
 		fmt.Fprintf(w, "  GITEA_DEBUG\tSet to 'true' for debug mode\n")
-		fmt.Fprintf(w, "  GITEA_EXTRA_HEADERS\tJSON object of extra HTTP headers to send with Gitea API requests\n")
 		fmt.Fprintf(w, "  GITEA_HOST\tOverride Gitea host URL\n")
 		fmt.Fprintf(w, "  GITEA_INSECURE\tSet to 'true' to ignore TLS errors\n")
 		fmt.Fprintf(w, "  GITEA_MAX_INLINE_ATTACHMENT_BYTES\tOverride inline image attachment size limit in bytes\n")
@@ -167,18 +164,6 @@ func initFlagSet(fs *flag.FlagSet, args []string, getenv func(string) string, re
 			flagPkg.MaxInlineAttachmentBytes = parsed
 		}
 	}
-	if val := getenv("GITEA_EXTRA_HEADERS"); val != "" {
-		var headers map[string]string
-		if err := json.Unmarshal([]byte(val), &headers); err != nil {
-			fmt.Fprintf(stderr, "invalid GITEA_EXTRA_HEADERS: %v\n", err)
-			osExit(1)
-		}
-		extraHeaders := make(http.Header, len(headers))
-		for name, value := range headers {
-			extraHeaders.Set(name, value)
-		}
-		flagPkg.ExtraHeaders = extraHeaders
-	}
 }
 
 // normalizeScope trims whitespace, lowercases, and converts internal spaces

cmd/cmd_test.go

@@ -5,7 +5,6 @@ import (
 	"flag"
 	"maps"
 	"slices"
-	"strings"
 	"testing"
 
 	flagPkg "gitea.com/gitea/gitea-mcp/pkg/flag"
@@ -96,54 +95,3 @@ func TestInitFlagSetScopes(t *testing.T) {
 		})
 	}
 }
-
-func TestInitFlagSetExtraHeaders(t *testing.T) {
-	t.Cleanup(func() { flagPkg.ExtraHeaders = nil })
-
-	getenv := func(key string) string {
-		if key == "GITEA_EXTRA_HEADERS" {
-			return `{"CF-Access-Client-Id":"id","CF-Access-Client-Secret":"secret"}`
-		}
-		return ""
-	}
-	readFile := func(string) ([]byte, error) { return nil, nil }
-	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	var stderr bytes.Buffer
-
-	initFlagSet(fs, []string{}, getenv, readFile, &stderr)
-
-	if got := flagPkg.ExtraHeaders.Get("CF-Access-Client-Id"); got != "id" {
-		t.Errorf("ExtraHeaders[CF-Access-Client-Id] = %q, want %q", got, "id")
-	}
-	if got := flagPkg.ExtraHeaders.Get("CF-Access-Client-Secret"); got != "secret" {
-		t.Errorf("ExtraHeaders[CF-Access-Client-Secret] = %q, want %q", got, "secret")
-	}
-}
-
-func TestInitFlagSetExtraHeadersInvalidJSON(t *testing.T) {
-	t.Cleanup(func() { flagPkg.ExtraHeaders = nil })
-
-	origOsExit := osExit
-	var exitCode int
-	osExit = func(code int) { exitCode = code }
-	t.Cleanup(func() { osExit = origOsExit })
-
-	getenv := func(key string) string {
-		if key == "GITEA_EXTRA_HEADERS" {
-			return `not-json`
-		}
-		return ""
-	}
-	readFile := func(string) ([]byte, error) { return nil, nil }
-	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	var stderr bytes.Buffer
-
-	initFlagSet(fs, []string{}, getenv, readFile, &stderr)
-
-	if exitCode != 1 {
-		t.Errorf("exitCode = %d, want 1", exitCode)
-	}
-	if !strings.Contains(stderr.String(), "GITEA_EXTRA_HEADERS") {
-		t.Errorf("stderr = %q, want mention of GITEA_EXTRA_HEADERS", stderr.String())
-	}
-}

operation/repo/branch.go

@@ -69,28 +69,26 @@ func init() {
 	})
 }
 
+type createBranchArgs struct {
+	Owner     string `json:"owner" required:"true"`
+	Repo      string `json:"repo" required:"true"`
+	Branch    string `json:"branch" required:"true"`
+	OldBranch string `json:"old_branch"`
+}
+
 func CreateBranchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	owner, err := params.GetString(args, "owner")
+	var in createBranchArgs
-	if err != nil {
+	if err := params.Bind(args, &in); err != nil {
 		return to.ErrorResult(err)
 	}
-	repo, err := params.GetString(args, "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	branch, err := params.GetString(args, "branch")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	oldBranch, _ := args["old_branch"].(string)
 
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	_, _, err = client.Repositories.CreateBranch(ctx, owner, repo, gitea_sdk.CreateBranchOption{
+	_, _, err = client.Repositories.CreateBranch(ctx, in.Owner, in.Repo, gitea_sdk.CreateBranchOption{
-		BranchName:    branch,
+		BranchName:    in.Branch,
-		OldBranchName: oldBranch,
+		OldBranchName: in.OldBranch,
 	})
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("create branch error: %v", err))
@@ -99,24 +97,22 @@ func CreateBranchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResu
 	return to.TextResult("Branch Created")
 }
 
+type deleteBranchArgs struct {
+	Owner  string `json:"owner" required:"true"`
+	Repo   string `json:"repo" required:"true"`
+	Branch string `json:"branch" required:"true"`
+}
+
 func DeleteBranchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	owner, err := params.GetString(args, "owner")
+	var in deleteBranchArgs
-	if err != nil {
+	if err := params.Bind(args, &in); err != nil {
-		return to.ErrorResult(err)
-	}
-	repo, err := params.GetString(args, "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	branch, err := params.GetString(args, "branch")
-	if err != nil {
 		return to.ErrorResult(err)
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	_, _, err = client.Repositories.DeleteRepoBranch(ctx, owner, repo, branch)
+	_, _, err = client.Repositories.DeleteRepoBranch(ctx, in.Owner, in.Repo, in.Branch)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("delete branch error: %v", err))
 	}
@@ -124,13 +120,14 @@ func DeleteBranchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResu
 	return to.TextResult("Branch Deleted")
 }
 
-func ListBranchesFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+type listBranchesArgs struct {
-	owner, err := params.GetString(args, "owner")
+	Owner string `json:"owner" required:"true"`
-	if err != nil {
+	Repo  string `json:"repo" required:"true"`
-		return to.ErrorResult(err)
 }
-	repo, err := params.GetString(args, "repo")
+
-	if err != nil {
+func ListBranchesFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	var in listBranchesArgs
+	if err := params.Bind(args, &in); err != nil {
 		return to.ErrorResult(err)
 	}
 	page, pageSize := params.GetPagination(args, 30)
@@ -144,7 +141,7 @@ func ListBranchesFn(ctx context.Context, args map[string]any) (*mcp.CallToolResu
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	branches, _, err := client.Repositories.ListRepoBranches(ctx, owner, repo, opt)
+	branches, _, err := client.Repositories.ListRepoBranches(ctx, in.Owner, in.Repo, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("list branches error: %v", err))
 	}

operation/repo/file.go

@@ -102,30 +102,28 @@ type ContentLine struct {
 	Content    string `json:"content"`
 }
 
+type getFileContentArgs struct {
+	Owner     string `json:"owner" required:"true"`
+	Repo      string `json:"repo" required:"true"`
+	Ref       string `json:"ref"`
+	Path      string `json:"path" required:"true"`
+	WithLines bool   `json:"withLines"`
+}
+
 func GetFileContentFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	owner, err := params.GetString(args, "owner")
+	var in getFileContentArgs
-	if err != nil {
+	if err := params.Bind(args, &in); err != nil {
-		return to.ErrorResult(err)
-	}
-	repo, err := params.GetString(args, "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	ref, _ := args["ref"].(string)
-	filePath, err := params.GetString(args, "path")
-	if err != nil {
 		return to.ErrorResult(err)
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	content, _, err := client.Repositories.GetContents(ctx, owner, repo, ref, filePath)
+	content, _, err := client.Repositories.GetContents(ctx, in.Owner, in.Repo, in.Ref, in.Path)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get file err: %v", err))
 	}
-	withLines, _ := args["withLines"].(bool)
+	if in.WithLines {
-	if withLines {
 		rawContent, err := base64.StdEncoding.DecodeString(*content.Content)
 		if err != nil {
 			return to.ErrorResult(fmt.Errorf("decode base64 content err: %v", err))
@@ -164,49 +162,45 @@ func GetFileContentFn(ctx context.Context, args map[string]any) (*mcp.CallToolRe
 	return to.TextResult(slimContents(content))
 }
 
+type getDirContentArgs struct {
+	Owner string `json:"owner" required:"true"`
+	Repo  string `json:"repo" required:"true"`
+	Ref   string `json:"ref"`
+	Path  string `json:"path" required:"true"`
+}
+
 func GetDirContentFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	owner, err := params.GetString(args, "owner")
+	var in getDirContentArgs
-	if err != nil {
+	if err := params.Bind(args, &in); err != nil {
-		return to.ErrorResult(err)
-	}
-	repo, err := params.GetString(args, "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	ref, _ := args["ref"].(string)
-	filePath, err := params.GetString(args, "path")
-	if err != nil {
 		return to.ErrorResult(err)
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	content, _, err := client.Repositories.ListContents(ctx, owner, repo, ref, filePath)
+	content, _, err := client.Repositories.ListContents(ctx, in.Owner, in.Repo, in.Ref, in.Path)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get dir content err: %v", err))
 	}
 	return to.TextResult(slimDirEntries(content))
 }
 
+type createOrUpdateFileArgs struct {
+	Owner         string `json:"owner" required:"true"`
+	Repo          string `json:"repo" required:"true"`
+	Path          string `json:"path" required:"true"`
+	Content       string `json:"content"`
+	Message       string `json:"message"`
+	BranchName    string `json:"branch_name"`
+	NewBranchName string `json:"new_branch_name"`
+	SHA           string `json:"sha"`
+}
+
 func CreateOrUpdateFileFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	owner, err := params.GetString(args, "owner")
+	var in createOrUpdateFileArgs
-	if err != nil {
+	if err := params.Bind(args, &in); err != nil {
 		return to.ErrorResult(err)
 	}
-	repo, err := params.GetString(args, "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	filePath, err := params.GetString(args, "path")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	content, _ := args["content"].(string)
-	message, _ := args["message"].(string)
-	branchName, _ := args["branch_name"].(string)
-	newBranchName, _ := args["new_branch_name"].(string)
-	sha, _ := args["sha"].(string)
 
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
@@ -214,20 +208,20 @@ func CreateOrUpdateFileFn(ctx context.Context, args map[string]any) (*mcp.CallTo
 	}
 
 	fileOpt := gitea_sdk.FileOptions{
-		Message:       message,
+		Message:       in.Message,
-		BranchName:    branchName,
+		BranchName:    in.BranchName,
-		NewBranchName: newBranchName,
+		NewBranchName: in.NewBranchName,
 	}
-	targetBranch := cmp.Or(newBranchName, branchName)
+	targetBranch := cmp.Or(in.NewBranchName, in.BranchName)
 
-	if sha != "" {
+	if in.SHA != "" {
 		// Update existing file
 		opt := gitea_sdk.UpdateFileOptions{
-			SHA:         sha,
+			SHA:         in.SHA,
-			Content:     base64.StdEncoding.EncodeToString([]byte(content)),
+			Content:     base64.StdEncoding.EncodeToString([]byte(in.Content)),
 			FileOptions: fileOpt,
 		}
-		_, _, err = client.Repositories.UpdateFile(ctx, owner, repo, filePath, opt)
+		_, _, err = client.Repositories.UpdateFile(ctx, in.Owner, in.Repo, in.Path, opt)
 		if err != nil {
 			return to.ErrorResult(fmt.Errorf("update file err: %v", err))
 		}
@@ -236,47 +230,42 @@ func CreateOrUpdateFileFn(ctx context.Context, args map[string]any) (*mcp.CallTo
 
 	// Create new file
 	opt := gitea_sdk.CreateFileOptions{
-		Content:     base64.StdEncoding.EncodeToString([]byte(content)),
+		Content:     base64.StdEncoding.EncodeToString([]byte(in.Content)),
 		FileOptions: fileOpt,
 	}
-	_, _, err = client.Repositories.CreateFile(ctx, owner, repo, filePath, opt)
+	_, _, err = client.Repositories.CreateFile(ctx, in.Owner, in.Repo, in.Path, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("create file err: %v", err))
 	}
 	return to.TextResult("Create file success on branch " + targetBranch)
 }
 
+type deleteFileArgs struct {
+	Owner      string `json:"owner" required:"true"`
+	Repo       string `json:"repo" required:"true"`
+	Path       string `json:"path" required:"true"`
+	Message    string `json:"message"`
+	BranchName string `json:"branch_name"`
+	SHA        string `json:"sha" required:"true"`
+}
+
 func DeleteFileFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	owner, err := params.GetString(args, "owner")
+	var in deleteFileArgs
-	if err != nil {
+	if err := params.Bind(args, &in); err != nil {
-		return to.ErrorResult(err)
-	}
-	repo, err := params.GetString(args, "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	filePath, err := params.GetString(args, "path")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	message, _ := args["message"].(string)
-	branchName, _ := args["branch_name"].(string)
-	sha, err := params.GetString(args, "sha")
-	if err != nil {
 		return to.ErrorResult(err)
 	}
 	opt := gitea_sdk.DeleteFileOptions{
 		FileOptions: gitea_sdk.FileOptions{
-			Message:    message,
+			Message:    in.Message,
-			BranchName: branchName,
+			BranchName: in.BranchName,
 		},
-		SHA: sha,
+		SHA: in.SHA,
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	_, err = client.Repositories.DeleteFile(ctx, owner, repo, filePath, opt)
+	_, err = client.Repositories.DeleteFile(ctx, in.Owner, in.Repo, in.Path, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("delete file err: %v", err))
 	}

operation/repo/tree.go

@@ -37,20 +37,18 @@ func init() {
 	})
 }
 
+type getRepoTreeArgs struct {
+	Owner     string `json:"owner" required:"true"`
+	Repo      string `json:"repo" required:"true"`
+	TreeSHA   string `json:"tree_sha" required:"true"`
+	Recursive bool   `json:"recursive"`
+}
+
 func GetRepoTreeFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	owner, err := params.GetString(args, "owner")
+	var in getRepoTreeArgs
-	if err != nil {
+	if err := params.Bind(args, &in); err != nil {
 		return to.ErrorResult(err)
 	}
-	repo, err := params.GetString(args, "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	treeSHA, err := params.GetString(args, "tree_sha")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	recursive, _ := args["recursive"].(bool)
 	page, pageSize := params.GetPagination(args, 30)
 
 	opt := gitea_sdk.ListTreeOptions{
@@ -58,14 +56,14 @@ func GetRepoTreeFn(ctx context.Context, args map[string]any) (*mcp.CallToolResul
 			Page:     page,
 			PageSize: pageSize,
 		},
-		Ref:       treeSHA,
+		Ref:       in.TreeSHA,
-		Recursive: recursive,
+		Recursive: in.Recursive,
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	tree, _, err := client.Git.GetTrees(ctx, owner, repo, opt)
+	tree, _, err := client.Git.GetTrees(ctx, in.Owner, in.Repo, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get repository tree err: %v", err))
 	}

pkg/flag/flag.go

@@ -1,7 +1,5 @@
 package flag
 
-import "net/http"
-
 var (
 	Host    string
 	Bind    string
@@ -17,5 +15,4 @@ var (
 	Debug         bool
 	AllowedTools  map[string]struct{}
 	AllowedScopes map[string]struct{}
-	ExtraHeaders  http.Header
 )

pkg/gitea/gitea.go

@@ -30,32 +30,6 @@ func sharedTransport() *http.Transport {
 	return sharedTrans
 }
 
-// extraHeaderTransport injects flag.ExtraHeaders into every request, without
-// overriding headers the caller already set (e.g. Authorization, Content-Type,
-// Accept). It reads flag.ExtraHeaders on each round trip rather than caching
-// it, so tests can change it between requests.
-type extraHeaderTransport struct {
-	base http.RoundTripper
-}
-
-func (t *extraHeaderTransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	headers := flag.ExtraHeaders
-	if len(headers) == 0 {
-		return t.base.RoundTrip(req)
-	}
-	cloned := req.Clone(req.Context())
-	for name, values := range headers {
-		if cloned.Header.Get(name) == "" {
-			cloned.Header[name] = values
-		}
-	}
-	return t.base.RoundTrip(cloned)
-}
-
-func giteaTransport() http.RoundTripper {
-	return &extraHeaderTransport{base: sharedTransport()}
-}
-
 // NewClient returns a cached *gitea.Client keyed by host+token. The SDK's per-client
 // version cache and the shared transport let us reuse keep-alive connections
 // and avoid the SDK's /api/v1/version preflight on every tool call.
@@ -66,7 +40,7 @@ func NewClient(token string) (*gitea.Client, error) {
 	}
 
 	httpClient := &http.Client{
-		Transport:     giteaTransport(),
+		Transport:     sharedTransport(),
 		CheckRedirect: checkRedirect,
 	}
 	opts := []gitea.ClientOption{

pkg/gitea/gitea_test.go

@@ -1,49 +0,0 @@
-package gitea
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"gitea.com/gitea/gitea-mcp/pkg/flag"
-)
-
-func TestNewClient_SendsExtraHeaders(t *testing.T) {
-	var gotClientID, gotAuthorization string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotClientID = r.Header.Get("CF-Access-Client-Id")
-		gotAuthorization = r.Header.Get("Authorization")
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"login":"octocat"}`))
-	}))
-	defer srv.Close()
-
-	origHost := flag.Host
-	origExtraHeaders := flag.ExtraHeaders
-	defer func() {
-		flag.Host = origHost
-		flag.ExtraHeaders = origExtraHeaders
-	}()
-	flag.Host = srv.URL
-	flag.ExtraHeaders = http.Header{
-		"Cf-Access-Client-Id": []string{"client-id"},
-		"Authorization":       []string{"should-not-override"},
-	}
-
-	client, err := NewClient("the-token")
-	if err != nil {
-		t.Fatalf("NewClient returned error: %v", err)
-	}
-	if _, _, err := client.Users.GetMyUserInfo(context.Background()); err != nil {
-		t.Fatalf("GetMyUserInfo returned error: %v", err)
-	}
-
-	if gotClientID != "client-id" {
-		t.Fatalf("CF-Access-Client-Id header = %q, want %q", gotClientID, "client-id")
-	}
-	if gotAuthorization != "token the-token" {
-		t.Fatalf("Authorization header = %q, want %q", gotAuthorization, "token the-token")
-	}
-}

pkg/gitea/rest.go

@@ -59,7 +59,7 @@ var (
 func restHTTPClient() *http.Client {
 	restClientOnce.Do(func() {
 		restClient = &http.Client{
-			Transport:     giteaTransport(),
+			Transport:     sharedTransport(),
 			Timeout:       httpClientTimeout,
 			CheckRedirect: checkRedirect,
 		}
@@ -180,7 +180,7 @@ func DoJSON(ctx context.Context, method, path string, query url.Values, body, re
 
 func attachmentHTTPClient(origin *url.URL) *http.Client {
 	return &http.Client{
-		Transport: giteaTransport(),
+		Transport: sharedTransport(),
 		CheckRedirect: func(req *http.Request, via []*http.Request) error {
 			if err := checkRedirect(req, via); err != nil {
 				return err

pkg/gitea/rest_test.go

@@ -62,44 +62,3 @@ func TestDoJSON_LimitsErrorResponseBody(t *testing.T) {
 		t.Fatalf("expected body length %d, got %d", errBodySnippetSize, len(httpErr.Body))
 	}
 }
-
-func TestDoJSON_SendsExtraHeaders(t *testing.T) {
-	var gotClientID, gotAuthorization string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotClientID = r.Header.Get("CF-Access-Client-Id")
-		gotAuthorization = r.Header.Get("Authorization")
-		w.WriteHeader(http.StatusOK)
-		_, _ = io.WriteString(w, "{}")
-	}))
-	defer srv.Close()
-
-	origHost := flag.Host
-	origToken := flag.Token
-	origExtraHeaders := flag.ExtraHeaders
-	defer func() {
-		flag.Host = origHost
-		flag.Token = origToken
-		flag.ExtraHeaders = origExtraHeaders
-	}()
-	flag.Host = srv.URL
-	flag.Token = "the-token"
-	flag.ExtraHeaders = http.Header{
-		"Cf-Access-Client-Id": []string{"client-id"},
-		"Authorization":       []string{"should-not-override"},
-	}
-
-	var out map[string]any
-	status, err := DoJSON(context.Background(), http.MethodGet, "repos/owner/repo", nil, nil, &out)
-	if err != nil {
-		t.Fatalf("DoJSON returned error: %v", err)
-	}
-	if status != http.StatusOK {
-		t.Fatalf("expected status %d, got %d", http.StatusOK, status)
-	}
-	if gotClientID != "client-id" {
-		t.Fatalf("CF-Access-Client-Id header = %q, want %q", gotClientID, "client-id")
-	}
-	if gotAuthorization != "token the-token" {
-		t.Fatalf("Authorization header = %q, want %q", gotAuthorization, "token the-token")
-	}
-}

pkg/params/bind.go

@@ -0,0 +1,55 @@
+package params
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// Bind decodes args into out, a pointer to a struct, replacing the repeated
+// args["x"].(string)/!ok extraction pattern. It round-trips args through JSON
+// so JSON numbers land in the correct Go numeric field types.
+//
+// Struct fields tagged `required:"true"` must be present in args; a missing
+// key, or an empty string value for a string field, returns an error naming
+// the field's json tag.
+func Bind(args map[string]any, out any) error {
+	v := reflect.ValueOf(out)
+	if v.Kind() != reflect.Pointer || v.Elem().Kind() != reflect.Struct {
+		return fmt.Errorf("params.Bind: out must be a pointer to a struct, got %T", out)
+	}
+
+	if err := checkRequiredFields(args, v.Elem().Type()); err != nil {
+		return err
+	}
+
+	data, err := json.Marshal(args)
+	if err != nil {
+		return fmt.Errorf("params.Bind: marshal args: %w", err)
+	}
+	if err := json.Unmarshal(data, out); err != nil {
+		return fmt.Errorf("params.Bind: %w", err)
+	}
+	return nil
+}
+
+func checkRequiredFields(args map[string]any, t reflect.Type) error {
+	for field := range t.Fields() {
+		if field.Tag.Get("required") != "true" {
+			continue
+		}
+		name, _, _ := strings.Cut(field.Tag.Get("json"), ",")
+		if name == "" || name == "-" {
+			continue
+		}
+		val, ok := args[name]
+		if !ok {
+			return fmt.Errorf("%s is required", name)
+		}
+		if s, isString := val.(string); isString && s == "" {
+			return fmt.Errorf("%s is required", name)
+		}
+	}
+	return nil
+}

pkg/params/bind_test.go

@@ -0,0 +1,132 @@
+package params
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestBind_RequiredFieldsPresent(t *testing.T) {
+	type args struct {
+		Owner string `json:"owner" required:"true"`
+		Repo  string `json:"repo" required:"true"`
+	}
+	var out args
+	err := Bind(map[string]any{"owner": "gitea", "repo": "gitea-mcp"}, &out)
+	if err != nil {
+		t.Fatalf("Bind() unexpected error = %v", err)
+	}
+	if out.Owner != "gitea" || out.Repo != "gitea-mcp" {
+		t.Errorf("Bind() = %+v, want Owner=gitea Repo=gitea-mcp", out)
+	}
+}
+
+func TestBind_RequiredFieldMissing(t *testing.T) {
+	type args struct {
+		Owner string `json:"owner" required:"true"`
+	}
+	var out args
+	err := Bind(map[string]any{}, &out)
+	if err == nil {
+		t.Fatal("Bind() expected error, got nil")
+	}
+	if !strings.Contains(err.Error(), "owner") {
+		t.Errorf("Bind() error = %v, want mentioning %q", err, "owner")
+	}
+}
+
+func TestBind_RequiredStringFieldEmpty(t *testing.T) {
+	type args struct {
+		Owner string `json:"owner" required:"true"`
+	}
+	var out args
+	err := Bind(map[string]any{"owner": ""}, &out)
+	if err == nil {
+		t.Fatal("Bind() expected error for empty required string, got nil")
+	}
+}
+
+func TestBind_OptionalFieldDefaultsToZeroValue(t *testing.T) {
+	type args struct {
+		Owner     string `json:"owner" required:"true"`
+		OldBranch string `json:"old_branch"`
+	}
+	var out args
+	err := Bind(map[string]any{"owner": "gitea"}, &out)
+	if err != nil {
+		t.Fatalf("Bind() unexpected error = %v", err)
+	}
+	if out.OldBranch != "" {
+		t.Errorf("Bind() OldBranch = %q, want empty", out.OldBranch)
+	}
+}
+
+func TestBind_NumericConversion(t *testing.T) {
+	type args struct {
+		Page    int   `json:"page"`
+		PerPage int64 `json:"per_page"`
+	}
+	var out args
+	err := Bind(map[string]any{"page": float64(2), "per_page": float64(40)}, &out)
+	if err != nil {
+		t.Fatalf("Bind() unexpected error = %v", err)
+	}
+	if out.Page != 2 || out.PerPage != 40 {
+		t.Errorf("Bind() = %+v, want Page=2 PerPage=40", out)
+	}
+}
+
+func TestBind_Boolean(t *testing.T) {
+	type args struct {
+		Recursive bool `json:"recursive"`
+	}
+	var out args
+	err := Bind(map[string]any{"recursive": true}, &out)
+	if err != nil {
+		t.Fatalf("Bind() unexpected error = %v", err)
+	}
+	if !out.Recursive {
+		t.Errorf("Bind() Recursive = false, want true")
+	}
+}
+
+func TestBind_Array(t *testing.T) {
+	type args struct {
+		Labels []string `json:"labels"`
+		IDs    []int64  `json:"ids"`
+	}
+	var out args
+	err := Bind(map[string]any{
+		"labels": []any{"bug", "help wanted"},
+		"ids":    []any{float64(1), float64(2)},
+	}, &out)
+	if err != nil {
+		t.Fatalf("Bind() unexpected error = %v", err)
+	}
+	if len(out.Labels) != 2 || out.Labels[0] != "bug" || out.Labels[1] != "help wanted" {
+		t.Errorf("Bind() Labels = %v, want [bug help wanted]", out.Labels)
+	}
+	if len(out.IDs) != 2 || out.IDs[0] != 1 || out.IDs[1] != 2 {
+		t.Errorf("Bind() IDs = %v, want [1 2]", out.IDs)
+	}
+}
+
+func TestBind_InvalidFieldType(t *testing.T) {
+	type args struct {
+		Page int `json:"page"`
+	}
+	var out args
+	err := Bind(map[string]any{"page": "not-a-number"}, &out)
+	if err == nil {
+		t.Fatal("Bind() expected error for invalid numeric field, got nil")
+	}
+}
+
+func TestBind_NonPointerRejected(t *testing.T) {
+	type args struct {
+		Owner string `json:"owner"`
+	}
+	err := Bind(map[string]any{}, args{})
+	if err == nil {
+		t.Fatal("Bind() expected error for non-pointer out, got nil")
+	}
+}