Consolidate tools from 110 to 45 using method dispatch (#143)

Consolidate 110 individual MCP tools down to 45 using a method dispatch pattern, aligning tool names with the GitHub MCP server conventions.

**Motivation:** LLMs work better with fewer, well-organized tools. The method dispatch pattern (used by GitHub's MCP server) groups related operations under read/write tools with a `method` parameter.

**Changes:**
- Group related tools into `_read`/`_write` pairs with method dispatch (e.g. `issue_read`, `issue_write`, `pull_request_read`, `pull_request_write`)
- Rename tools to match GitHub MCP naming (`get_file_contents`, `create_or_update_file`, `list_issues`, `list_pull_requests`, etc.)
- Rename `pageSize` to `perPage` for GitHub MCP compat
- Move issue label ops (`add_labels`, `remove_label`, etc.) into `issue_write`
- Merge `create_file`/`update_file` into `create_or_update_file` with optional `sha`
- Make `delete_file` require `sha`
- Add `get_labels` method to `issue_read`
- Add shared helpers: `GetInt64Slice`, `GetStringSlice`, `GetPagination` in params package
- Unexport all dispatch handler functions
- Fix: pass assignees/milestone in `CreateIssue`, bounds check in `GetFileContent`

Reviewed-on: https://gitea.com/gitea/gitea-mcp/pulls/143
Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com>
Co-authored-by: silverwind <me@silverwind.io>
Co-committed-by: silverwind <me@silverwind.io>

operation/actions/config.go

@@ -0,0 +1,555 @@
+package actions
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+	"strconv"
+	"time"
+
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/log"
+	"gitea.com/gitea/gitea-mcp/pkg/params"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+
+	gitea_sdk "code.gitea.io/sdk/gitea"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+const (
+	ActionsConfigReadToolName  = "actions_config_read"
+	ActionsConfigWriteToolName = "actions_config_write"
+)
+
+type secretMeta struct {
+	Name        string    `json:"name"`
+	Description string    `json:"description,omitempty"`
+	CreatedAt   time.Time `json:"created_at,omitzero"`
+}
+
+func toSecretMetas(secrets []*gitea_sdk.Secret) []secretMeta {
+	metas := make([]secretMeta, 0, len(secrets))
+	for _, s := range secrets {
+		if s == nil {
+			continue
+		}
+		metas = append(metas, secretMeta{
+			Name:        s.Name,
+			Description: s.Description,
+			CreatedAt:   s.Created,
+		})
+	}
+	return metas
+}
+
+var (
+	ActionsConfigReadTool = mcp.NewTool(
+		ActionsConfigReadToolName,
+		mcp.WithDescription("Read Actions secrets and variables configuration."),
+		mcp.WithString("method", mcp.Required(), mcp.Description("operation to perform"), mcp.Enum("list_repo_secrets", "list_org_secrets", "list_repo_variables", "get_repo_variable", "list_org_variables", "get_org_variable")),
+		mcp.WithString("owner", mcp.Description("repository owner (required for repo methods)")),
+		mcp.WithString("repo", mcp.Description("repository name (required for repo methods)")),
+		mcp.WithString("org", mcp.Description("organization name (required for org methods)")),
+		mcp.WithString("name", mcp.Description("variable name (required for get methods)")),
+		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
+		mcp.WithNumber("perPage", mcp.Description("results per page"), mcp.DefaultNumber(30), mcp.Min(1)),
+	)
+
+	ActionsConfigWriteTool = mcp.NewTool(
+		ActionsConfigWriteToolName,
+		mcp.WithDescription("Manage Actions secrets and variables: create, update, or delete."),
+		mcp.WithString("method", mcp.Required(), mcp.Description("operation to perform"), mcp.Enum("upsert_repo_secret", "delete_repo_secret", "upsert_org_secret", "delete_org_secret", "create_repo_variable", "update_repo_variable", "delete_repo_variable", "create_org_variable", "update_org_variable", "delete_org_variable")),
+		mcp.WithString("owner", mcp.Description("repository owner (required for repo methods)")),
+		mcp.WithString("repo", mcp.Description("repository name (required for repo methods)")),
+		mcp.WithString("org", mcp.Description("organization name (required for org methods)")),
+		mcp.WithString("name", mcp.Description("secret or variable name (required for most methods)")),
+		mcp.WithString("data", mcp.Description("secret value (required for upsert secret methods)")),
+		mcp.WithString("value", mcp.Description("variable value (required for create/update variable methods)")),
+		mcp.WithString("description", mcp.Description("description for secret or variable")),
+	)
+)
+
+func init() {
+	Tool.RegisterRead(server.ServerTool{Tool: ActionsConfigReadTool, Handler: configReadFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: ActionsConfigWriteTool, Handler: configWriteFn})
+}
+
+func configReadFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	method, err := params.GetString(req.GetArguments(), "method")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	switch method {
+	case "list_repo_secrets":
+		return listRepoActionSecretsFn(ctx, req)
+	case "list_org_secrets":
+		return listOrgActionSecretsFn(ctx, req)
+	case "list_repo_variables":
+		return listRepoActionVariablesFn(ctx, req)
+	case "get_repo_variable":
+		return getRepoActionVariableFn(ctx, req)
+	case "list_org_variables":
+		return listOrgActionVariablesFn(ctx, req)
+	case "get_org_variable":
+		return getOrgActionVariableFn(ctx, req)
+	default:
+		return to.ErrorResult(fmt.Errorf("unknown method: %s", method))
+	}
+}
+
+func configWriteFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	method, err := params.GetString(req.GetArguments(), "method")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	switch method {
+	case "upsert_repo_secret":
+		return upsertRepoActionSecretFn(ctx, req)
+	case "delete_repo_secret":
+		return deleteRepoActionSecretFn(ctx, req)
+	case "upsert_org_secret":
+		return upsertOrgActionSecretFn(ctx, req)
+	case "delete_org_secret":
+		return deleteOrgActionSecretFn(ctx, req)
+	case "create_repo_variable":
+		return createRepoActionVariableFn(ctx, req)
+	case "update_repo_variable":
+		return updateRepoActionVariableFn(ctx, req)
+	case "delete_repo_variable":
+		return deleteRepoActionVariableFn(ctx, req)
+	case "create_org_variable":
+		return createOrgActionVariableFn(ctx, req)
+	case "update_org_variable":
+		return updateOrgActionVariableFn(ctx, req)
+	case "delete_org_variable":
+		return deleteOrgActionVariableFn(ctx, req)
+	default:
+		return to.ErrorResult(fmt.Errorf("unknown method: %s", method))
+	}
+}
+
+// Secret functions
+
+func listRepoActionSecretsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called listRepoActionSecretsFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil || owner == "" {
+		return to.ErrorResult(errors.New("owner is required"))
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil || repo == "" {
+		return to.ErrorResult(errors.New("repo is required"))
+	}
+	page, pageSize := params.GetPagination(req.GetArguments(), 30)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+
+	secrets, _, err := client.ListRepoActionSecret(owner, repo, gitea_sdk.ListRepoActionSecretOption{
+		ListOptions: gitea_sdk.ListOptions{Page: page, PageSize: pageSize},
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list repo action secrets err: %v", err))
+	}
+
+	return to.TextResult(toSecretMetas(secrets))
+}
+
+func upsertRepoActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called upsertRepoActionSecretFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil || owner == "" {
+		return to.ErrorResult(errors.New("owner is required"))
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil || repo == "" {
+		return to.ErrorResult(errors.New("repo is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+	data, err := params.GetString(req.GetArguments(), "data")
+	if err != nil || data == "" {
+		return to.ErrorResult(errors.New("data is required"))
+	}
+	description, _ := req.GetArguments()["description"].(string)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.CreateRepoActionSecret(owner, repo, gitea_sdk.CreateSecretOption{
+		Name:        name,
+		Data:        data,
+		Description: description,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("upsert repo action secret err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "secret upserted", "status": resp.StatusCode})
+}
+
+func deleteRepoActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called deleteRepoActionSecretFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil || owner == "" {
+		return to.ErrorResult(errors.New("owner is required"))
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil || repo == "" {
+		return to.ErrorResult(errors.New("repo is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.DeleteRepoActionSecret(owner, repo, name)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete repo action secret err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "secret deleted", "status": resp.StatusCode})
+}
+
+func listOrgActionSecretsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called listOrgActionSecretsFn")
+	org, err := params.GetString(req.GetArguments(), "org")
+	if err != nil || org == "" {
+		return to.ErrorResult(errors.New("org is required"))
+	}
+	page, pageSize := params.GetPagination(req.GetArguments(), 30)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+
+	secrets, _, err := client.ListOrgActionSecret(org, gitea_sdk.ListOrgActionSecretOption{
+		ListOptions: gitea_sdk.ListOptions{Page: page, PageSize: pageSize},
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list org action secrets err: %v", err))
+	}
+
+	return to.TextResult(toSecretMetas(secrets))
+}
+
+func upsertOrgActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called upsertOrgActionSecretFn")
+	org, err := params.GetString(req.GetArguments(), "org")
+	if err != nil || org == "" {
+		return to.ErrorResult(errors.New("org is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+	data, err := params.GetString(req.GetArguments(), "data")
+	if err != nil || data == "" {
+		return to.ErrorResult(errors.New("data is required"))
+	}
+	description, _ := req.GetArguments()["description"].(string)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.CreateOrgActionSecret(org, gitea_sdk.CreateSecretOption{
+		Name:        name,
+		Data:        data,
+		Description: description,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("upsert org action secret err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "secret upserted", "status": resp.StatusCode})
+}
+
+func deleteOrgActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called deleteOrgActionSecretFn")
+	org, err := params.GetString(req.GetArguments(), "org")
+	if err != nil || org == "" {
+		return to.ErrorResult(errors.New("org is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+
+	escapedOrg := url.PathEscape(org)
+	escapedSecret := url.PathEscape(name)
+	_, err = gitea.DoJSON(ctx, "DELETE", fmt.Sprintf("orgs/%s/actions/secrets/%s", escapedOrg, escapedSecret), nil, nil, nil)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete org action secret err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "secret deleted"})
+}
+
+// Variable functions
+
+func listRepoActionVariablesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called listRepoActionVariablesFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil || owner == "" {
+		return to.ErrorResult(errors.New("owner is required"))
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil || repo == "" {
+		return to.ErrorResult(errors.New("repo is required"))
+	}
+	page, pageSize := params.GetPagination(req.GetArguments(), 30)
+
+	query := url.Values{}
+	query.Set("page", strconv.Itoa(page))
+	query.Set("limit", strconv.Itoa(pageSize))
+
+	var result any
+	_, err = gitea.DoJSON(ctx, "GET", fmt.Sprintf("repos/%s/%s/actions/variables", url.PathEscape(owner), url.PathEscape(repo)), query, nil, &result)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list repo action variables err: %v", err))
+	}
+	return to.TextResult(result)
+}
+
+func getRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called getRepoActionVariableFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil || owner == "" {
+		return to.ErrorResult(errors.New("owner is required"))
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil || repo == "" {
+		return to.ErrorResult(errors.New("repo is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	variable, _, err := client.GetRepoActionVariable(owner, repo, name)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get repo action variable err: %v", err))
+	}
+	return to.TextResult(variable)
+}
+
+func createRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called createRepoActionVariableFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil || owner == "" {
+		return to.ErrorResult(errors.New("owner is required"))
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil || repo == "" {
+		return to.ErrorResult(errors.New("repo is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+	value, err := params.GetString(req.GetArguments(), "value")
+	if err != nil || value == "" {
+		return to.ErrorResult(errors.New("value is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.CreateRepoActionVariable(owner, repo, name, value)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create repo action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable created", "status": resp.StatusCode})
+}
+
+func updateRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called updateRepoActionVariableFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil || owner == "" {
+		return to.ErrorResult(errors.New("owner is required"))
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil || repo == "" {
+		return to.ErrorResult(errors.New("repo is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+	value, err := params.GetString(req.GetArguments(), "value")
+	if err != nil || value == "" {
+		return to.ErrorResult(errors.New("value is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.UpdateRepoActionVariable(owner, repo, name, value)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("update repo action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable updated", "status": resp.StatusCode})
+}
+
+func deleteRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called deleteRepoActionVariableFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil || owner == "" {
+		return to.ErrorResult(errors.New("owner is required"))
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil || repo == "" {
+		return to.ErrorResult(errors.New("repo is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.DeleteRepoActionVariable(owner, repo, name)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete repo action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable deleted", "status": resp.StatusCode})
+}
+
+func listOrgActionVariablesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called listOrgActionVariablesFn")
+	org, err := params.GetString(req.GetArguments(), "org")
+	if err != nil || org == "" {
+		return to.ErrorResult(errors.New("org is required"))
+	}
+	page, pageSize := params.GetPagination(req.GetArguments(), 30)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	variables, _, err := client.ListOrgActionVariable(org, gitea_sdk.ListOrgActionVariableOption{
+		ListOptions: gitea_sdk.ListOptions{Page: page, PageSize: pageSize},
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("list org action variables err: %v", err))
+	}
+	return to.TextResult(variables)
+}
+
+func getOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called getOrgActionVariableFn")
+	org, err := params.GetString(req.GetArguments(), "org")
+	if err != nil || org == "" {
+		return to.ErrorResult(errors.New("org is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	variable, _, err := client.GetOrgActionVariable(org, name)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get org action variable err: %v", err))
+	}
+	return to.TextResult(variable)
+}
+
+func createOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called createOrgActionVariableFn")
+	org, err := params.GetString(req.GetArguments(), "org")
+	if err != nil || org == "" {
+		return to.ErrorResult(errors.New("org is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+	value, err := params.GetString(req.GetArguments(), "value")
+	if err != nil || value == "" {
+		return to.ErrorResult(errors.New("value is required"))
+	}
+	description, _ := req.GetArguments()["description"].(string)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.CreateOrgActionVariable(org, gitea_sdk.CreateOrgActionVariableOption{
+		Name:        name,
+		Value:       value,
+		Description: description,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("create org action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable created", "status": resp.StatusCode})
+}
+
+func updateOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called updateOrgActionVariableFn")
+	org, err := params.GetString(req.GetArguments(), "org")
+	if err != nil || org == "" {
+		return to.ErrorResult(errors.New("org is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+	value, err := params.GetString(req.GetArguments(), "value")
+	if err != nil || value == "" {
+		return to.ErrorResult(errors.New("value is required"))
+	}
+	description, _ := req.GetArguments()["description"].(string)
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	resp, err := client.UpdateOrgActionVariable(org, name, gitea_sdk.UpdateOrgActionVariableOption{
+		Value:       value,
+		Description: description,
+	})
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("update org action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable updated", "status": resp.StatusCode})
+}
+
+func deleteOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called deleteOrgActionVariableFn")
+	org, err := params.GetString(req.GetArguments(), "org")
+	if err != nil || org == "" {
+		return to.ErrorResult(errors.New("org is required"))
+	}
+	name, err := params.GetString(req.GetArguments(), "name")
+	if err != nil || name == "" {
+		return to.ErrorResult(errors.New("name is required"))
+	}
+
+	_, err = gitea.DoJSON(ctx, "DELETE", fmt.Sprintf("orgs/%s/actions/variables/%s", url.PathEscape(org), url.PathEscape(name)), nil, nil, nil)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("delete org action variable err: %v", err))
+	}
+	return to.TextResult(map[string]any{"message": "variable deleted"})
+}

operation/actions/logs.go

@@ -1,187 +0,0 @@
-package actions
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-
-	"gitea.com/gitea/gitea-mcp/pkg/gitea"
-	"gitea.com/gitea/gitea-mcp/pkg/log"
-	"gitea.com/gitea/gitea-mcp/pkg/params"
-	"gitea.com/gitea/gitea-mcp/pkg/to"
-
-	"github.com/mark3labs/mcp-go/mcp"
-	"github.com/mark3labs/mcp-go/server"
-)
-
-const (
-	GetRepoActionJobLogPreviewToolName = "get_repo_action_job_log_preview"
-	DownloadRepoActionJobLogToolName   = "download_repo_action_job_log"
-)
-
-var (
-	GetRepoActionJobLogPreviewTool = mcp.NewTool(
-		GetRepoActionJobLogPreviewToolName,
-		mcp.WithDescription("Get a repository Actions job log preview (tail/limited for chat-friendly output)"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("job_id", mcp.Required(), mcp.Description("job ID")),
-		mcp.WithNumber("tail_lines", mcp.Description("number of lines from the end of the log"), mcp.DefaultNumber(200), mcp.Min(1)),
-		mcp.WithNumber("max_bytes", mcp.Description("max bytes to return"), mcp.DefaultNumber(65536), mcp.Min(1024)),
-	)
-
-	DownloadRepoActionJobLogTool = mcp.NewTool(
-		DownloadRepoActionJobLogToolName,
-		mcp.WithDescription("Download a repository Actions job log to a file on the MCP server filesystem"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("job_id", mcp.Required(), mcp.Description("job ID")),
-		mcp.WithString("output_path", mcp.Description("optional output file path; if omitted, uses ~/.gitea-mcp/artifacts/actions-logs/...")),
-	)
-)
-
-func init() {
-	Tool.RegisterRead(server.ServerTool{Tool: GetRepoActionJobLogPreviewTool, Handler: GetRepoActionJobLogPreviewFn})
-	Tool.RegisterRead(server.ServerTool{Tool: DownloadRepoActionJobLogTool, Handler: DownloadRepoActionJobLogFn})
-}
-
-func logPaths(owner, repo string, jobID int64) []string {
-	// Primary candidate endpoints, plus a few commonly-seen variants across versions.
-	// We try these in order; 404/405 falls through.
-	return []string{
-		fmt.Sprintf("repos/%s/%s/actions/jobs/%d/logs", url.PathEscape(owner), url.PathEscape(repo), jobID),
-		fmt.Sprintf("repos/%s/%s/actions/jobs/%d/log", url.PathEscape(owner), url.PathEscape(repo), jobID),
-		fmt.Sprintf("repos/%s/%s/actions/tasks/%d/log", url.PathEscape(owner), url.PathEscape(repo), jobID),
-		fmt.Sprintf("repos/%s/%s/actions/task/%d/log", url.PathEscape(owner), url.PathEscape(repo), jobID),
-	}
-}
-
-func fetchJobLogBytes(ctx context.Context, owner, repo string, jobID int64) ([]byte, string, error) {
-	var lastErr error
-	for _, p := range logPaths(owner, repo, jobID) {
-		b, _, err := gitea.DoBytes(ctx, "GET", p, nil, nil, "text/plain")
-		if err == nil {
-			return b, p, nil
-		}
-		lastErr = err
-		var httpErr *gitea.HTTPError
-		if errors.As(err, &httpErr) && (httpErr.StatusCode == http.StatusNotFound || httpErr.StatusCode == http.StatusMethodNotAllowed) {
-			continue
-		}
-		return nil, p, err
-	}
-	return nil, "", lastErr
-}
-
-func tailByLines(data []byte, tailLines int) []byte {
-	if tailLines <= 0 || len(data) == 0 {
-		return data
-	}
-	// Find the start index of the last N lines by scanning backwards.
-	lines := 0
-	i := len(data) - 1
-	for i >= 0 {
-		if data[i] == '\n' {
-			lines++
-			if lines > tailLines {
-				return data[i+1:]
-			}
-		}
-		i--
-	}
-	return data
-}
-
-func limitBytes(data []byte, maxBytes int) ([]byte, bool) {
-	if maxBytes <= 0 {
-		return data, false
-	}
-	if len(data) <= maxBytes {
-		return data, false
-	}
-	// Keep the tail so the most recent log content is preserved.
-	return data[len(data)-maxBytes:], true
-}
-
-func GetRepoActionJobLogPreviewFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called GetRepoActionJobLogPreviewFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	jobID, err := params.GetIndex(req.GetArguments(), "job_id")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	tailLines := int(params.GetOptionalInt(req.GetArguments(), "tail_lines", 200))
-	maxBytes := int(params.GetOptionalInt(req.GetArguments(), "max_bytes", 65536))
-	raw, usedPath, err := fetchJobLogBytes(ctx, owner, repo, jobID)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get job log err: %v", err))
-	}
-
-	tailed := tailByLines(raw, tailLines)
-	limited, truncated := limitBytes(tailed, maxBytes)
-
-	return to.TextResult(map[string]any{
-		"endpoint":   usedPath,
-		"job_id":     jobID,
-		"bytes":      len(raw),
-		"tail_lines": tailLines,
-		"max_bytes":  maxBytes,
-		"truncated":  truncated,
-		"log":        string(limited),
-	})
-}
-
-func DownloadRepoActionJobLogFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called DownloadRepoActionJobLogFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	jobID, err := params.GetIndex(req.GetArguments(), "job_id")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	outputPath, _ := req.GetArguments()["output_path"].(string)
-
-	raw, usedPath, err := fetchJobLogBytes(ctx, owner, repo, jobID)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("download job log err: %v", err))
-	}
-
-	if outputPath == "" {
-		home, _ := os.UserHomeDir()
-		if home == "" {
-			home = os.TempDir()
-		}
-		outputPath = filepath.Join(home, ".gitea-mcp", "artifacts", "actions-logs", owner, repo, fmt.Sprintf("%d.log", jobID))
-	}
-
-	if err := os.MkdirAll(filepath.Dir(outputPath), 0o700); err != nil {
-		return to.ErrorResult(fmt.Errorf("create output dir err: %v", err))
-	}
-	if err := os.WriteFile(outputPath, raw, 0o600); err != nil {
-		return to.ErrorResult(fmt.Errorf("write log file err: %v", err))
-	}
-
-	return to.TextResult(map[string]any{
-		"endpoint": usedPath,
-		"job_id":   jobID,
-		"path":     outputPath,
-		"bytes":    len(raw),
-	})
-}

operation/actions/runs.go

@@ -4,9 +4,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"maps"
 	"net/http"
 	"net/url"
+	"os"
+	"path/filepath"
 	"strconv"
 
 	"gitea.com/gitea/gitea-mcp/pkg/gitea"
@@ -19,114 +20,88 @@ import (
 )
 
 const (
-	ListRepoActionWorkflowsToolName    = "list_repo_action_workflows"
-	GetRepoActionWorkflowToolName      = "get_repo_action_workflow"
-	DispatchRepoActionWorkflowToolName = "dispatch_repo_action_workflow"
-
-	ListRepoActionRunsToolName  = "list_repo_action_runs"
-	GetRepoActionRunToolName    = "get_repo_action_run"
-	CancelRepoActionRunToolName = "cancel_repo_action_run"
-	RerunRepoActionRunToolName  = "rerun_repo_action_run"
-
-	ListRepoActionJobsToolName    = "list_repo_action_jobs"
-	ListRepoActionRunJobsToolName = "list_repo_action_run_jobs"
+	ActionsRunReadToolName  = "actions_run_read"
+	ActionsRunWriteToolName = "actions_run_write"
 )
 
 var (
-	ListRepoActionWorkflowsTool = mcp.NewTool(
-		ListRepoActionWorkflowsToolName,
-		mcp.WithDescription("List repository Actions workflows"),
+	ActionsRunReadTool = mcp.NewTool(
+		ActionsRunReadToolName,
+		mcp.WithDescription("Read Actions workflow, run, and job data. Use method 'list_workflows'/'get_workflow' for workflows, 'list_runs'/'get_run' for runs, 'list_jobs'/'list_run_jobs' for jobs, 'get_job_log_preview'/'download_job_log' for logs."),
+		mcp.WithString("method", mcp.Required(), mcp.Description("operation to perform"), mcp.Enum("list_workflows", "get_workflow", "list_runs", "get_run", "list_jobs", "list_run_jobs", "get_job_log_preview", "download_job_log")),
 		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
 		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
+		mcp.WithString("workflow_id", mcp.Description("workflow ID or filename (required for 'get_workflow')")),
+		mcp.WithNumber("run_id", mcp.Description("run ID (required for 'get_run', 'list_run_jobs')")),
+		mcp.WithNumber("job_id", mcp.Description("job ID (required for 'get_job_log_preview', 'download_job_log')")),
+		mcp.WithString("status", mcp.Description("optional status filter (for 'list_runs', 'list_jobs')")),
+		mcp.WithNumber("tail_lines", mcp.Description("number of lines from end of log (for 'get_job_log_preview')"), mcp.DefaultNumber(200), mcp.Min(1)),
+		mcp.WithNumber("max_bytes", mcp.Description("max bytes to return (for 'get_job_log_preview')"), mcp.DefaultNumber(65536), mcp.Min(1024)),
+		mcp.WithString("output_path", mcp.Description("output file path (for 'download_job_log')")),
 		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
-		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(30), mcp.Min(1)),
+		mcp.WithNumber("perPage", mcp.Description("results per page"), mcp.DefaultNumber(30), mcp.Min(1)),
 	)
 
-	GetRepoActionWorkflowTool = mcp.NewTool(
-		GetRepoActionWorkflowToolName,
-		mcp.WithDescription("Get a repository Actions workflow by ID"),
+	ActionsRunWriteTool = mcp.NewTool(
+		ActionsRunWriteToolName,
+		mcp.WithDescription("Trigger, cancel, or rerun Actions workflows."),
+		mcp.WithString("method", mcp.Required(), mcp.Description("operation to perform"), mcp.Enum("dispatch_workflow", "cancel_run", "rerun_run")),
 		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
 		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithString("workflow_id", mcp.Required(), mcp.Description("workflow ID or filename (e.g. 'my-workflow.yml')")),
-	)
-
-	DispatchRepoActionWorkflowTool = mcp.NewTool(
-		DispatchRepoActionWorkflowToolName,
-		mcp.WithDescription("Trigger (dispatch) a repository Actions workflow"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithString("workflow_id", mcp.Required(), mcp.Description("workflow ID or filename (e.g. 'my-workflow.yml')")),
-		mcp.WithString("ref", mcp.Required(), mcp.Description("git ref (branch or tag)")),
-		mcp.WithObject("inputs", mcp.Description("workflow inputs object")),
-	)
-
-	ListRepoActionRunsTool = mcp.NewTool(
-		ListRepoActionRunsToolName,
-		mcp.WithDescription("List repository Actions workflow runs"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
-		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(30), mcp.Min(1)),
-		mcp.WithString("status", mcp.Description("optional status filter")),
-	)
-
-	GetRepoActionRunTool = mcp.NewTool(
-		GetRepoActionRunToolName,
-		mcp.WithDescription("Get a repository Actions run by ID"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("run_id", mcp.Required(), mcp.Description("run ID")),
-	)
-
-	CancelRepoActionRunTool = mcp.NewTool(
-		CancelRepoActionRunToolName,
-		mcp.WithDescription("Cancel a repository Actions run"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("run_id", mcp.Required(), mcp.Description("run ID")),
-	)
-
-	RerunRepoActionRunTool = mcp.NewTool(
-		RerunRepoActionRunToolName,
-		mcp.WithDescription("Rerun a repository Actions run"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("run_id", mcp.Required(), mcp.Description("run ID")),
-	)
-
-	ListRepoActionJobsTool = mcp.NewTool(
-		ListRepoActionJobsToolName,
-		mcp.WithDescription("List repository Actions jobs"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
-		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(30), mcp.Min(1)),
-		mcp.WithString("status", mcp.Description("optional status filter")),
-	)
-
-	ListRepoActionRunJobsTool = mcp.NewTool(
-		ListRepoActionRunJobsToolName,
-		mcp.WithDescription("List Actions jobs for a specific run"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("run_id", mcp.Required(), mcp.Description("run ID")),
-		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
-		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(30), mcp.Min(1)),
+		mcp.WithString("workflow_id", mcp.Description("workflow ID or filename (required for 'dispatch_workflow')")),
+		mcp.WithString("ref", mcp.Description("git ref branch or tag (required for 'dispatch_workflow')")),
+		mcp.WithObject("inputs", mcp.Description("workflow inputs object (for 'dispatch_workflow')")),
+		mcp.WithNumber("run_id", mcp.Description("run ID (required for 'cancel_run', 'rerun_run')")),
 	)
 )
 
 func init() {
-	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionWorkflowsTool, Handler: ListRepoActionWorkflowsFn})
-	Tool.RegisterRead(server.ServerTool{Tool: GetRepoActionWorkflowTool, Handler: GetRepoActionWorkflowFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: DispatchRepoActionWorkflowTool, Handler: DispatchRepoActionWorkflowFn})
+	Tool.RegisterRead(server.ServerTool{Tool: ActionsRunReadTool, Handler: runReadFn})
+	Tool.RegisterWrite(server.ServerTool{Tool: ActionsRunWriteTool, Handler: runWriteFn})
+}
 
-	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionRunsTool, Handler: ListRepoActionRunsFn})
-	Tool.RegisterRead(server.ServerTool{Tool: GetRepoActionRunTool, Handler: GetRepoActionRunFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: CancelRepoActionRunTool, Handler: CancelRepoActionRunFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: RerunRepoActionRunTool, Handler: RerunRepoActionRunFn})
+func runReadFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	method, err := params.GetString(req.GetArguments(), "method")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	switch method {
+	case "list_workflows":
+		return listRepoActionWorkflowsFn(ctx, req)
+	case "get_workflow":
+		return getRepoActionWorkflowFn(ctx, req)
+	case "list_runs":
+		return listRepoActionRunsFn(ctx, req)
+	case "get_run":
+		return getRepoActionRunFn(ctx, req)
+	case "list_jobs":
+		return listRepoActionJobsFn(ctx, req)
+	case "list_run_jobs":
+		return listRepoActionRunJobsFn(ctx, req)
+	case "get_job_log_preview":
+		return getRepoActionJobLogPreviewFn(ctx, req)
+	case "download_job_log":
+		return downloadRepoActionJobLogFn(ctx, req)
+	default:
+		return to.ErrorResult(fmt.Errorf("unknown method: %s", method))
+	}
+}
 
-	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionJobsTool, Handler: ListRepoActionJobsFn})
-	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionRunJobsTool, Handler: ListRepoActionRunJobsFn})
+func runWriteFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	method, err := params.GetString(req.GetArguments(), "method")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	switch method {
+	case "dispatch_workflow":
+		return dispatchRepoActionWorkflowFn(ctx, req)
+	case "cancel_run":
+		return cancelRepoActionRunFn(ctx, req)
+	case "rerun_run":
+		return rerunRepoActionRunFn(ctx, req)
+	default:
+		return to.ErrorResult(fmt.Errorf("unknown method: %s", method))
+	}
 }
 
 func doJSONWithFallback(ctx context.Context, method string, paths []string, query url.Values, body, respOut any) error {
@@ -146,8 +121,8 @@ func doJSONWithFallback(ctx context.Context, method string, paths []string, quer
 	return lastErr
 }
 
-func ListRepoActionWorkflowsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called ListRepoActionWorkflowsFn")
+func listRepoActionWorkflowsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called listRepoActionWorkflowsFn")
 	owner, err := params.GetString(req.GetArguments(), "owner")
 	if err != nil || owner == "" {
 		return to.ErrorResult(errors.New("owner is required"))
@@ -174,8 +149,8 @@ func ListRepoActionWorkflowsFn(ctx context.Context, req mcp.CallToolRequest) (*m
 	return to.TextResult(slimActionWorkflows(result))
 }
 
-func GetRepoActionWorkflowFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called GetRepoActionWorkflowFn")
+func getRepoActionWorkflowFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called getRepoActionWorkflowFn")
 	owner, err := params.GetString(req.GetArguments(), "owner")
 	if err != nil || owner == "" {
 		return to.ErrorResult(errors.New("owner is required"))
@@ -202,8 +177,8 @@ func GetRepoActionWorkflowFn(ctx context.Context, req mcp.CallToolRequest) (*mcp
 	return to.TextResult(slimActionWorkflow(result))
 }
 
-func DispatchRepoActionWorkflowFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called DispatchRepoActionWorkflowFn")
+func dispatchRepoActionWorkflowFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called dispatchRepoActionWorkflowFn")
 	owner, err := params.GetString(req.GetArguments(), "owner")
 	if err != nil || owner == "" {
 		return to.ErrorResult(errors.New("owner is required"))
@@ -225,9 +200,6 @@ func DispatchRepoActionWorkflowFn(ctx context.Context, req mcp.CallToolRequest)
 	if raw, exists := req.GetArguments()["inputs"]; exists {
 		if m, ok := raw.(map[string]any); ok {
 			inputs = m
-		} else if m, ok := raw.(map[string]any); ok {
-			inputs = make(map[string]any, len(m))
-			maps.Copy(inputs, m)
 		}
 	}
 
@@ -255,8 +227,8 @@ func DispatchRepoActionWorkflowFn(ctx context.Context, req mcp.CallToolRequest)
 	return to.TextResult(map[string]any{"message": "workflow dispatched"})
 }
 
-func ListRepoActionRunsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called ListRepoActionRunsFn")
+func listRepoActionRunsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called listRepoActionRunsFn")
 	owner, err := params.GetString(req.GetArguments(), "owner")
 	if err != nil || owner == "" {
 		return to.ErrorResult(errors.New("owner is required"))
@@ -288,8 +260,8 @@ func ListRepoActionRunsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.Ca
 	return to.TextResult(slimActionRuns(result))
 }
 
-func GetRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called GetRepoActionRunFn")
+func getRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called getRepoActionRunFn")
 	owner, err := params.GetString(req.GetArguments(), "owner")
 	if err != nil || owner == "" {
 		return to.ErrorResult(errors.New("owner is required"))
@@ -316,8 +288,8 @@ func GetRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.Call
 	return to.TextResult(slimActionRun(result))
 }
 
-func CancelRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called CancelRepoActionRunFn")
+func cancelRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called cancelRepoActionRunFn")
 	owner, err := params.GetString(req.GetArguments(), "owner")
 	if err != nil || owner == "" {
 		return to.ErrorResult(errors.New("owner is required"))
@@ -343,8 +315,8 @@ func CancelRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.C
 	return to.TextResult(map[string]any{"message": "run cancellation requested"})
 }
 
-func RerunRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called RerunRepoActionRunFn")
+func rerunRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called rerunRepoActionRunFn")
 	owner, err := params.GetString(req.GetArguments(), "owner")
 	if err != nil || owner == "" {
 		return to.ErrorResult(errors.New("owner is required"))
@@ -375,8 +347,8 @@ func RerunRepoActionRunFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.Ca
 	return to.TextResult(map[string]any{"message": "run rerun requested"})
 }
 
-func ListRepoActionJobsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called ListRepoActionJobsFn")
+func listRepoActionJobsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called listRepoActionJobsFn")
 	owner, err := params.GetString(req.GetArguments(), "owner")
 	if err != nil || owner == "" {
 		return to.ErrorResult(errors.New("owner is required"))
@@ -408,8 +380,8 @@ func ListRepoActionJobsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.Ca
 	return to.TextResult(slimActionJobs(result))
 }
 
-func ListRepoActionRunJobsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called ListRepoActionRunJobsFn")
+func listRepoActionRunJobsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called listRepoActionRunJobsFn")
 	owner, err := params.GetString(req.GetArguments(), "owner")
 	if err != nil || owner == "" {
 		return to.ErrorResult(errors.New("owner is required"))
@@ -440,3 +412,138 @@ func ListRepoActionRunJobsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp
 	}
 	return to.TextResult(slimActionJobs(result))
 }
+
+// Log functions (merged from logs.go)
+
+func logPaths(owner, repo string, jobID int64) []string {
+	return []string{
+		fmt.Sprintf("repos/%s/%s/actions/jobs/%d/logs", url.PathEscape(owner), url.PathEscape(repo), jobID),
+		fmt.Sprintf("repos/%s/%s/actions/jobs/%d/log", url.PathEscape(owner), url.PathEscape(repo), jobID),
+		fmt.Sprintf("repos/%s/%s/actions/tasks/%d/log", url.PathEscape(owner), url.PathEscape(repo), jobID),
+		fmt.Sprintf("repos/%s/%s/actions/task/%d/log", url.PathEscape(owner), url.PathEscape(repo), jobID),
+	}
+}
+
+func fetchJobLogBytes(ctx context.Context, owner, repo string, jobID int64) ([]byte, string, error) {
+	var lastErr error
+	for _, p := range logPaths(owner, repo, jobID) {
+		b, _, err := gitea.DoBytes(ctx, "GET", p, nil, nil, "text/plain")
+		if err == nil {
+			return b, p, nil
+		}
+		lastErr = err
+		var httpErr *gitea.HTTPError
+		if errors.As(err, &httpErr) && (httpErr.StatusCode == http.StatusNotFound || httpErr.StatusCode == http.StatusMethodNotAllowed) {
+			continue
+		}
+		return nil, p, err
+	}
+	return nil, "", lastErr
+}
+
+func tailByLines(data []byte, tailLines int) []byte {
+	if tailLines <= 0 || len(data) == 0 {
+		return data
+	}
+	lines := 0
+	i := len(data) - 1
+	for i >= 0 {
+		if data[i] == '\n' {
+			lines++
+			if lines > tailLines {
+				return data[i+1:]
+			}
+		}
+		i--
+	}
+	return data
+}
+
+func limitBytes(data []byte, maxBytes int) ([]byte, bool) {
+	if maxBytes <= 0 {
+		return data, false
+	}
+	if len(data) <= maxBytes {
+		return data, false
+	}
+	return data[len(data)-maxBytes:], true
+}
+
+func getRepoActionJobLogPreviewFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called getRepoActionJobLogPreviewFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	jobID, err := params.GetIndex(req.GetArguments(), "job_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	tailLines := int(params.GetOptionalInt(req.GetArguments(), "tail_lines", 200))
+	maxBytes := int(params.GetOptionalInt(req.GetArguments(), "max_bytes", 65536))
+	raw, usedPath, err := fetchJobLogBytes(ctx, owner, repo, jobID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get job log err: %v", err))
+	}
+
+	tailed := tailByLines(raw, tailLines)
+	limited, truncated := limitBytes(tailed, maxBytes)
+
+	return to.TextResult(map[string]any{
+		"endpoint":   usedPath,
+		"job_id":     jobID,
+		"bytes":      len(raw),
+		"tail_lines": tailLines,
+		"max_bytes":  maxBytes,
+		"truncated":  truncated,
+		"log":        string(limited),
+	})
+}
+
+func downloadRepoActionJobLogFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	log.Debugf("Called downloadRepoActionJobLogFn")
+	owner, err := params.GetString(req.GetArguments(), "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(req.GetArguments(), "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	jobID, err := params.GetIndex(req.GetArguments(), "job_id")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	outputPath, _ := req.GetArguments()["output_path"].(string)
+
+	raw, usedPath, err := fetchJobLogBytes(ctx, owner, repo, jobID)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("download job log err: %v", err))
+	}
+
+	if outputPath == "" {
+		home, _ := os.UserHomeDir()
+		if home == "" {
+			home = os.TempDir()
+		}
+		outputPath = filepath.Join(home, ".gitea-mcp", "artifacts", "actions-logs", owner, repo, fmt.Sprintf("%d.log", jobID))
+	}
+
+	if err := os.MkdirAll(filepath.Dir(outputPath), 0o700); err != nil {
+		return to.ErrorResult(fmt.Errorf("create output dir err: %v", err))
+	}
+	if err := os.WriteFile(outputPath, raw, 0o600); err != nil {
+		return to.ErrorResult(fmt.Errorf("write log file err: %v", err))
+	}
+
+	return to.TextResult(map[string]any{
+		"endpoint": usedPath,
+		"job_id":   jobID,
+		"path":     outputPath,
+		"bytes":    len(raw),
+	})
+}

operation/actions/secrets.go

@@ -1,280 +0,0 @@
-package actions
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/url"
-	"time"
-
-	"gitea.com/gitea/gitea-mcp/pkg/gitea"
-	"gitea.com/gitea/gitea-mcp/pkg/log"
-	"gitea.com/gitea/gitea-mcp/pkg/params"
-	"gitea.com/gitea/gitea-mcp/pkg/to"
-
-	gitea_sdk "code.gitea.io/sdk/gitea"
-	"github.com/mark3labs/mcp-go/mcp"
-	"github.com/mark3labs/mcp-go/server"
-)
-
-const (
-	ListRepoActionSecretsToolName  = "list_repo_action_secrets"
-	UpsertRepoActionSecretToolName = "upsert_repo_action_secret"
-	DeleteRepoActionSecretToolName = "delete_repo_action_secret"
-	ListOrgActionSecretsToolName   = "list_org_action_secrets"
-	UpsertOrgActionSecretToolName  = "upsert_org_action_secret"
-	DeleteOrgActionSecretToolName  = "delete_org_action_secret"
-)
-
-type secretMeta struct {
-	Name        string    `json:"name"`
-	Description string    `json:"description,omitempty"`
-	CreatedAt   time.Time `json:"created_at,omitzero"`
-}
-
-var (
-	ListRepoActionSecretsTool = mcp.NewTool(
-		ListRepoActionSecretsToolName,
-		mcp.WithDescription("List repository Actions secrets (metadata only; secret values are never returned)"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
-		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(30), mcp.Min(1)),
-	)
-
-	UpsertRepoActionSecretTool = mcp.NewTool(
-		UpsertRepoActionSecretToolName,
-		mcp.WithDescription("Create or update (upsert) a repository Actions secret"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("secret name")),
-		mcp.WithString("data", mcp.Required(), mcp.Description("secret value")),
-		mcp.WithString("description", mcp.Description("secret description")),
-	)
-
-	DeleteRepoActionSecretTool = mcp.NewTool(
-		DeleteRepoActionSecretToolName,
-		mcp.WithDescription("Delete a repository Actions secret"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithString("secretName", mcp.Required(), mcp.Description("secret name")),
-	)
-
-	ListOrgActionSecretsTool = mcp.NewTool(
-		ListOrgActionSecretsToolName,
-		mcp.WithDescription("List organization Actions secrets (metadata only; secret values are never returned)"),
-		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
-		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
-		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(30), mcp.Min(1)),
-	)
-
-	UpsertOrgActionSecretTool = mcp.NewTool(
-		UpsertOrgActionSecretToolName,
-		mcp.WithDescription("Create or update (upsert) an organization Actions secret"),
-		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("secret name")),
-		mcp.WithString("data", mcp.Required(), mcp.Description("secret value")),
-		mcp.WithString("description", mcp.Description("secret description")),
-	)
-
-	DeleteOrgActionSecretTool = mcp.NewTool(
-		DeleteOrgActionSecretToolName,
-		mcp.WithDescription("Delete an organization Actions secret"),
-		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
-		mcp.WithString("secretName", mcp.Required(), mcp.Description("secret name")),
-	)
-)
-
-func init() {
-	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionSecretsTool, Handler: ListRepoActionSecretsFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: UpsertRepoActionSecretTool, Handler: UpsertRepoActionSecretFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: DeleteRepoActionSecretTool, Handler: DeleteRepoActionSecretFn})
-
-	Tool.RegisterRead(server.ServerTool{Tool: ListOrgActionSecretsTool, Handler: ListOrgActionSecretsFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: UpsertOrgActionSecretTool, Handler: UpsertOrgActionSecretFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: DeleteOrgActionSecretTool, Handler: DeleteOrgActionSecretFn})
-}
-
-func ListRepoActionSecretsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called ListRepoActionSecretsFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil || owner == "" {
-		return to.ErrorResult(errors.New("owner is required"))
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil || repo == "" {
-		return to.ErrorResult(errors.New("repo is required"))
-	}
-	page, pageSize := params.GetPagination(req.GetArguments(), 30)
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-
-	secrets, _, err := client.ListRepoActionSecret(owner, repo, gitea_sdk.ListRepoActionSecretOption{
-		ListOptions: gitea_sdk.ListOptions{Page: page, PageSize: pageSize},
-	})
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("list repo action secrets err: %v", err))
-	}
-
-	metas := make([]secretMeta, 0, len(secrets))
-	for _, s := range secrets {
-		if s == nil {
-			continue
-		}
-		metas = append(metas, secretMeta{
-			Name:        s.Name,
-			Description: s.Description,
-			CreatedAt:   s.Created,
-		})
-	}
-	return to.TextResult(metas)
-}
-
-func UpsertRepoActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called UpsertRepoActionSecretFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil || owner == "" {
-		return to.ErrorResult(errors.New("owner is required"))
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil || repo == "" {
-		return to.ErrorResult(errors.New("repo is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-	data, err := params.GetString(req.GetArguments(), "data")
-	if err != nil || data == "" {
-		return to.ErrorResult(errors.New("data is required"))
-	}
-	description, _ := req.GetArguments()["description"].(string)
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	resp, err := client.CreateRepoActionSecret(owner, repo, gitea_sdk.CreateSecretOption{
-		Name:        name,
-		Data:        data,
-		Description: description,
-	})
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("upsert repo action secret err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "secret upserted", "status": resp.StatusCode})
-}
-
-func DeleteRepoActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called DeleteRepoActionSecretFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil || owner == "" {
-		return to.ErrorResult(errors.New("owner is required"))
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil || repo == "" {
-		return to.ErrorResult(errors.New("repo is required"))
-	}
-	secretName, err := params.GetString(req.GetArguments(), "secretName")
-	if err != nil || secretName == "" {
-		return to.ErrorResult(errors.New("secretName is required"))
-	}
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	resp, err := client.DeleteRepoActionSecret(owner, repo, secretName)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("delete repo action secret err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "secret deleted", "status": resp.StatusCode})
-}
-
-func ListOrgActionSecretsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called ListOrgActionSecretsFn")
-	org, err := params.GetString(req.GetArguments(), "org")
-	if err != nil || org == "" {
-		return to.ErrorResult(errors.New("org is required"))
-	}
-	page, pageSize := params.GetPagination(req.GetArguments(), 30)
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-
-	secrets, _, err := client.ListOrgActionSecret(org, gitea_sdk.ListOrgActionSecretOption{
-		ListOptions: gitea_sdk.ListOptions{Page: page, PageSize: pageSize},
-	})
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("list org action secrets err: %v", err))
-	}
-
-	metas := make([]secretMeta, 0, len(secrets))
-	for _, s := range secrets {
-		if s == nil {
-			continue
-		}
-		metas = append(metas, secretMeta{
-			Name:        s.Name,
-			Description: s.Description,
-			CreatedAt:   s.Created,
-		})
-	}
-	return to.TextResult(metas)
-}
-
-func UpsertOrgActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called UpsertOrgActionSecretFn")
-	org, err := params.GetString(req.GetArguments(), "org")
-	if err != nil || org == "" {
-		return to.ErrorResult(errors.New("org is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-	data, err := params.GetString(req.GetArguments(), "data")
-	if err != nil || data == "" {
-		return to.ErrorResult(errors.New("data is required"))
-	}
-	description, _ := req.GetArguments()["description"].(string)
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	resp, err := client.CreateOrgActionSecret(org, gitea_sdk.CreateSecretOption{
-		Name:        name,
-		Data:        data,
-		Description: description,
-	})
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("upsert org action secret err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "secret upserted", "status": resp.StatusCode})
-}
-
-func DeleteOrgActionSecretFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called DeleteOrgActionSecretFn")
-	org, err := params.GetString(req.GetArguments(), "org")
-	if err != nil || org == "" {
-		return to.ErrorResult(errors.New("org is required"))
-	}
-	secretName, err := params.GetString(req.GetArguments(), "secretName")
-	if err != nil || secretName == "" {
-		return to.ErrorResult(errors.New("secretName is required"))
-	}
-
-	escapedOrg := url.PathEscape(org)
-	escapedSecret := url.PathEscape(secretName)
-	_, err = gitea.DoJSON(ctx, "DELETE", fmt.Sprintf("orgs/%s/actions/secrets/%s", escapedOrg, escapedSecret), nil, nil, nil)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("delete org action secret err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "secret deleted"})
-}

operation/actions/variables.go

@@ -1,389 +0,0 @@
-package actions
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/url"
-	"strconv"
-
-	"gitea.com/gitea/gitea-mcp/pkg/gitea"
-	"gitea.com/gitea/gitea-mcp/pkg/log"
-	"gitea.com/gitea/gitea-mcp/pkg/params"
-	"gitea.com/gitea/gitea-mcp/pkg/to"
-
-	gitea_sdk "code.gitea.io/sdk/gitea"
-	"github.com/mark3labs/mcp-go/mcp"
-	"github.com/mark3labs/mcp-go/server"
-)
-
-const (
-	ListRepoActionVariablesToolName  = "list_repo_action_variables"
-	GetRepoActionVariableToolName    = "get_repo_action_variable"
-	CreateRepoActionVariableToolName = "create_repo_action_variable"
-	UpdateRepoActionVariableToolName = "update_repo_action_variable"
-	DeleteRepoActionVariableToolName = "delete_repo_action_variable"
-
-	ListOrgActionVariablesToolName  = "list_org_action_variables"
-	GetOrgActionVariableToolName    = "get_org_action_variable"
-	CreateOrgActionVariableToolName = "create_org_action_variable"
-	UpdateOrgActionVariableToolName = "update_org_action_variable"
-	DeleteOrgActionVariableToolName = "delete_org_action_variable"
-)
-
-var (
-	ListRepoActionVariablesTool = mcp.NewTool(
-		ListRepoActionVariablesToolName,
-		mcp.WithDescription("List repository Actions variables"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
-		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(30), mcp.Min(1)),
-	)
-
-	GetRepoActionVariableTool = mcp.NewTool(
-		GetRepoActionVariableToolName,
-		mcp.WithDescription("Get a repository Actions variable by name"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
-	)
-
-	CreateRepoActionVariableTool = mcp.NewTool(
-		CreateRepoActionVariableToolName,
-		mcp.WithDescription("Create a repository Actions variable"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
-		mcp.WithString("value", mcp.Required(), mcp.Description("variable value")),
-	)
-
-	UpdateRepoActionVariableTool = mcp.NewTool(
-		UpdateRepoActionVariableToolName,
-		mcp.WithDescription("Update a repository Actions variable"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
-		mcp.WithString("value", mcp.Required(), mcp.Description("new variable value")),
-	)
-
-	DeleteRepoActionVariableTool = mcp.NewTool(
-		DeleteRepoActionVariableToolName,
-		mcp.WithDescription("Delete a repository Actions variable"),
-		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
-		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
-	)
-
-	ListOrgActionVariablesTool = mcp.NewTool(
-		ListOrgActionVariablesToolName,
-		mcp.WithDescription("List organization Actions variables"),
-		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
-		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1), mcp.Min(1)),
-		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(30), mcp.Min(1)),
-	)
-
-	GetOrgActionVariableTool = mcp.NewTool(
-		GetOrgActionVariableToolName,
-		mcp.WithDescription("Get an organization Actions variable by name"),
-		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
-	)
-
-	CreateOrgActionVariableTool = mcp.NewTool(
-		CreateOrgActionVariableToolName,
-		mcp.WithDescription("Create an organization Actions variable"),
-		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
-		mcp.WithString("value", mcp.Required(), mcp.Description("variable value")),
-		mcp.WithString("description", mcp.Description("variable description")),
-	)
-
-	UpdateOrgActionVariableTool = mcp.NewTool(
-		UpdateOrgActionVariableToolName,
-		mcp.WithDescription("Update an organization Actions variable"),
-		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
-		mcp.WithString("value", mcp.Required(), mcp.Description("new variable value")),
-		mcp.WithString("description", mcp.Description("new variable description")),
-	)
-
-	DeleteOrgActionVariableTool = mcp.NewTool(
-		DeleteOrgActionVariableToolName,
-		mcp.WithDescription("Delete an organization Actions variable"),
-		mcp.WithString("org", mcp.Required(), mcp.Description("organization name")),
-		mcp.WithString("name", mcp.Required(), mcp.Description("variable name")),
-	)
-)
-
-func init() {
-	Tool.RegisterRead(server.ServerTool{Tool: ListRepoActionVariablesTool, Handler: ListRepoActionVariablesFn})
-	Tool.RegisterRead(server.ServerTool{Tool: GetRepoActionVariableTool, Handler: GetRepoActionVariableFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: CreateRepoActionVariableTool, Handler: CreateRepoActionVariableFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: UpdateRepoActionVariableTool, Handler: UpdateRepoActionVariableFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: DeleteRepoActionVariableTool, Handler: DeleteRepoActionVariableFn})
-
-	Tool.RegisterRead(server.ServerTool{Tool: ListOrgActionVariablesTool, Handler: ListOrgActionVariablesFn})
-	Tool.RegisterRead(server.ServerTool{Tool: GetOrgActionVariableTool, Handler: GetOrgActionVariableFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: CreateOrgActionVariableTool, Handler: CreateOrgActionVariableFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: UpdateOrgActionVariableTool, Handler: UpdateOrgActionVariableFn})
-	Tool.RegisterWrite(server.ServerTool{Tool: DeleteOrgActionVariableTool, Handler: DeleteOrgActionVariableFn})
-}
-
-func ListRepoActionVariablesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called ListRepoActionVariablesFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil || owner == "" {
-		return to.ErrorResult(errors.New("owner is required"))
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil || repo == "" {
-		return to.ErrorResult(errors.New("repo is required"))
-	}
-	page, pageSize := params.GetPagination(req.GetArguments(), 30)
-
-	query := url.Values{}
-	query.Set("page", strconv.Itoa(page))
-	query.Set("limit", strconv.Itoa(pageSize))
-
-	var result any
-	_, err = gitea.DoJSON(ctx, "GET", fmt.Sprintf("repos/%s/%s/actions/variables", url.PathEscape(owner), url.PathEscape(repo)), query, nil, &result)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("list repo action variables err: %v", err))
-	}
-	return to.TextResult(result)
-}
-
-func GetRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called GetRepoActionVariableFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil || owner == "" {
-		return to.ErrorResult(errors.New("owner is required"))
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil || repo == "" {
-		return to.ErrorResult(errors.New("repo is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	variable, _, err := client.GetRepoActionVariable(owner, repo, name)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get repo action variable err: %v", err))
-	}
-	return to.TextResult(variable)
-}
-
-func CreateRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called CreateRepoActionVariableFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil || owner == "" {
-		return to.ErrorResult(errors.New("owner is required"))
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil || repo == "" {
-		return to.ErrorResult(errors.New("repo is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-	value, err := params.GetString(req.GetArguments(), "value")
-	if err != nil || value == "" {
-		return to.ErrorResult(errors.New("value is required"))
-	}
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	resp, err := client.CreateRepoActionVariable(owner, repo, name, value)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("create repo action variable err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "variable created", "status": resp.StatusCode})
-}
-
-func UpdateRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called UpdateRepoActionVariableFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil || owner == "" {
-		return to.ErrorResult(errors.New("owner is required"))
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil || repo == "" {
-		return to.ErrorResult(errors.New("repo is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-	value, err := params.GetString(req.GetArguments(), "value")
-	if err != nil || value == "" {
-		return to.ErrorResult(errors.New("value is required"))
-	}
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	resp, err := client.UpdateRepoActionVariable(owner, repo, name, value)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("update repo action variable err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "variable updated", "status": resp.StatusCode})
-}
-
-func DeleteRepoActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called DeleteRepoActionVariableFn")
-	owner, err := params.GetString(req.GetArguments(), "owner")
-	if err != nil || owner == "" {
-		return to.ErrorResult(errors.New("owner is required"))
-	}
-	repo, err := params.GetString(req.GetArguments(), "repo")
-	if err != nil || repo == "" {
-		return to.ErrorResult(errors.New("repo is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	resp, err := client.DeleteRepoActionVariable(owner, repo, name)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("delete repo action variable err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "variable deleted", "status": resp.StatusCode})
-}
-
-func ListOrgActionVariablesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called ListOrgActionVariablesFn")
-	org, err := params.GetString(req.GetArguments(), "org")
-	if err != nil || org == "" {
-		return to.ErrorResult(errors.New("org is required"))
-	}
-	page, pageSize := params.GetPagination(req.GetArguments(), 30)
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	variables, _, err := client.ListOrgActionVariable(org, gitea_sdk.ListOrgActionVariableOption{
-		ListOptions: gitea_sdk.ListOptions{Page: page, PageSize: pageSize},
-	})
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("list org action variables err: %v", err))
-	}
-	return to.TextResult(variables)
-}
-
-func GetOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called GetOrgActionVariableFn")
-	org, err := params.GetString(req.GetArguments(), "org")
-	if err != nil || org == "" {
-		return to.ErrorResult(errors.New("org is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	variable, _, err := client.GetOrgActionVariable(org, name)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get org action variable err: %v", err))
-	}
-	return to.TextResult(variable)
-}
-
-func CreateOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called CreateOrgActionVariableFn")
-	org, err := params.GetString(req.GetArguments(), "org")
-	if err != nil || org == "" {
-		return to.ErrorResult(errors.New("org is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-	value, err := params.GetString(req.GetArguments(), "value")
-	if err != nil || value == "" {
-		return to.ErrorResult(errors.New("value is required"))
-	}
-	description, _ := req.GetArguments()["description"].(string)
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	resp, err := client.CreateOrgActionVariable(org, gitea_sdk.CreateOrgActionVariableOption{
-		Name:        name,
-		Value:       value,
-		Description: description,
-	})
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("create org action variable err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "variable created", "status": resp.StatusCode})
-}
-
-func UpdateOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called UpdateOrgActionVariableFn")
-	org, err := params.GetString(req.GetArguments(), "org")
-	if err != nil || org == "" {
-		return to.ErrorResult(errors.New("org is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-	value, err := params.GetString(req.GetArguments(), "value")
-	if err != nil || value == "" {
-		return to.ErrorResult(errors.New("value is required"))
-	}
-	description, _ := req.GetArguments()["description"].(string)
-
-	client, err := gitea.ClientFromContext(ctx)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
-	}
-	resp, err := client.UpdateOrgActionVariable(org, name, gitea_sdk.UpdateOrgActionVariableOption{
-		Value:       value,
-		Description: description,
-	})
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("update org action variable err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "variable updated", "status": resp.StatusCode})
-}
-
-func DeleteOrgActionVariableFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	log.Debugf("Called DeleteOrgActionVariableFn")
-	org, err := params.GetString(req.GetArguments(), "org")
-	if err != nil || org == "" {
-		return to.ErrorResult(errors.New("org is required"))
-	}
-	name, err := params.GetString(req.GetArguments(), "name")
-	if err != nil || name == "" {
-		return to.ErrorResult(errors.New("name is required"))
-	}
-
-	_, err = gitea.DoJSON(ctx, "DELETE", fmt.Sprintf("orgs/%s/actions/variables/%s", url.PathEscape(org), url.PathEscape(name)), nil, nil, nil)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("delete org action variable err: %v", err))
-	}
-	return to.TextResult(map[string]any{"message": "variable deleted"})
-}