@mokoconsulting/mcp-mokogitea-api 1.2.0

package/dist/index.js

@@ -0,0 +1,1119 @@
+#!/usr/bin/env node
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ *
+ * This file is part of a Moko Consulting project.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * FILE INFORMATION
+ * DEFGROUP: gitea-api-mcp.Server
+ * INGROUP: gitea-api-mcp
+ * REPO: https://git.mokoconsulting.tech/MokoConsulting/gitea-api-mcp
+ * PATH: /src/index.ts
+ * VERSION: 01.00.00
+ * BRIEF: MCP server entry point — registers all Gitea API tools
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { loadConfig, getConnection } from './config.js';
+import { GiteaClient } from './client.js';
+let config;
+function clientFor(connection) {
+    return new GiteaClient(getConnection(config, connection));
+}
+function formatResponse(res) {
+    if (res.status >= 400) {
+        const err = res.data;
+        const msg = err?.message ?? `HTTP ${res.status}: ${JSON.stringify(res.data, null, 2)}`;
+        return { content: [{ type: 'text', text: `Error: ${msg}` }] };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+    };
+}
+const ConnectionParam = {
+    connection: z.string().optional().describe('Named connection from config (uses default if omitted)'),
+};
+const PaginationParams = {
+    page: z.number().optional().describe('Page number (1-based)'),
+    limit: z.number().optional().describe('Items per page (max 50)'),
+};
+function pageQuery(params) {
+    const q = {};
+    if (params.page !== undefined)
+        q['page'] = String(params.page);
+    if (params.limit !== undefined)
+        q['limit'] = String(params.limit);
+    return q;
+}
+const OwnerRepo = {
+    owner: z.string().describe('Repository owner (user or org)'),
+    repo: z.string().describe('Repository name'),
+};
+const server = new McpServer({
+    name: 'mokogitea-api-mcp',
+    version: '1.0.0',
+});
+// ── User / Auth ─────────────────────────────────────────────────────────
+server.tool('gitea_me', 'Get the authenticated user info', { ...ConnectionParam }, async ({ connection }) => formatResponse(await clientFor(connection).get('/user')));
+server.tool('gitea_user_orgs', 'List organizations the authenticated user belongs to', { ...PaginationParams, ...ConnectionParam }, async ({ page, limit, connection }) => formatResponse(await clientFor(connection).get('/user/orgs', pageQuery({ page, limit }))));
+server.tool('gitea_user_repos', 'List repositories owned by the authenticated user', { ...PaginationParams, ...ConnectionParam }, async ({ page, limit, connection }) => formatResponse(await clientFor(connection).get('/user/repos', pageQuery({ page, limit }))));
+// ── Repository CRUD ─────────────────────────────────────────────────────
+server.tool('gitea_repo_get', 'Get repository details', { ...OwnerRepo, ...ConnectionParam }, async ({ owner, repo, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}`)));
+server.tool('gitea_repo_create', 'Create a new repository', {
+    name: z.string().describe('Repository name'),
+    org: z.string().optional().describe('Organization (omit for personal)'),
+    description: z.string().optional().describe('Description'),
+    private: z.boolean().optional().describe('Private repository'),
+    auto_init: z.boolean().optional().describe('Initialize with README'),
+    default_branch: z.string().optional().describe('Default branch (default "main")'),
+    template: z.boolean().optional().describe('Mark as template repository'),
+    ...ConnectionParam,
+}, async ({ name, org, description, private: priv, auto_init, default_branch, template: tmpl, connection }) => {
+    const client = clientFor(connection);
+    const body = { name };
+    if (description)
+        body.description = description;
+    if (priv !== undefined)
+        body.private = priv;
+    if (auto_init !== undefined)
+        body.auto_init = auto_init;
+    if (default_branch)
+        body.default_branch = default_branch;
+    if (tmpl !== undefined)
+        body.template = tmpl;
+    const endpoint = org ? `/orgs/${org}/repos` : '/user/repos';
+    return formatResponse(await client.post(endpoint, body));
+});
+server.tool('gitea_repo_delete', 'Delete a repository', { ...OwnerRepo, ...ConnectionParam }, async ({ owner, repo, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}`)));
+server.tool('gitea_repo_edit', 'Edit repository settings', {
+    ...OwnerRepo,
+    description: z.string().optional().describe('New description'),
+    private: z.boolean().optional().describe('Set private/public'),
+    has_issues: z.boolean().optional().describe('Enable issues'),
+    has_wiki: z.boolean().optional().describe('Enable wiki'),
+    has_pull_requests: z.boolean().optional().describe('Enable PRs'),
+    default_branch: z.string().optional().describe('Default branch'),
+    archived: z.boolean().optional().describe('Archive/unarchive'),
+    ...ConnectionParam,
+}, async ({ owner, repo, description, private: priv, has_issues, has_wiki, has_pull_requests, default_branch, archived, connection }) => {
+    const body = {};
+    if (description !== undefined)
+        body.description = description;
+    if (priv !== undefined)
+        body.private = priv;
+    if (has_issues !== undefined)
+        body.has_issues = has_issues;
+    if (has_wiki !== undefined)
+        body.has_wiki = has_wiki;
+    if (has_pull_requests !== undefined)
+        body.has_pull_requests = has_pull_requests;
+    if (default_branch !== undefined)
+        body.default_branch = default_branch;
+    if (archived !== undefined)
+        body.archived = archived;
+    return formatResponse(await clientFor(connection).patch(`/repos/${owner}/${repo}`, body));
+});
+server.tool('gitea_repo_fork', 'Fork a repository', {
+    ...OwnerRepo,
+    organization: z.string().optional().describe('Fork to this org (omit for personal)'),
+    name: z.string().optional().describe('Custom name for fork'),
+    ...ConnectionParam,
+}, async ({ owner, repo, organization, name, connection }) => {
+    const body = {};
+    if (organization)
+        body.organization = organization;
+    if (name)
+        body.name = name;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/forks`, body));
+});
+server.tool('gitea_repo_generate', 'Create a new repository from a template repository', {
+    template_owner: z.string().describe('Owner of the template repository'),
+    template_repo: z.string().describe('Name of the template repository'),
+    owner: z.string().describe('Target owner (user or org) for the new repo'),
+    name: z.string().describe('Name for the new repository'),
+    description: z.string().optional().describe('Description for the new repo'),
+    private: z.boolean().optional().describe('Make the new repo private'),
+    git_content: z.boolean().optional().describe('Copy git content (commits, branches) from template (default true)'),
+    topics: z.boolean().optional().describe('Copy topics from template'),
+    git_hooks: z.boolean().optional().describe('Copy git hooks from template'),
+    webhooks: z.boolean().optional().describe('Copy webhooks from template'),
+    labels: z.boolean().optional().describe('Copy labels from template'),
+    default_branch: z.string().optional().describe('Default branch for new repo'),
+    ...ConnectionParam,
+}, async ({ template_owner, template_repo, owner, name, description, private: priv, git_content, topics, git_hooks, webhooks, labels, default_branch, connection }) => {
+    const body = { owner, name };
+    if (description)
+        body.description = description;
+    if (priv !== undefined)
+        body.private = priv;
+    if (git_content !== undefined)
+        body.git_content = git_content;
+    if (topics !== undefined)
+        body.topics = topics;
+    if (git_hooks !== undefined)
+        body.git_hooks = git_hooks;
+    if (webhooks !== undefined)
+        body.webhooks = webhooks;
+    if (labels !== undefined)
+        body.labels = labels;
+    if (default_branch)
+        body.default_branch = default_branch;
+    return formatResponse(await clientFor(connection).post(`/repos/${template_owner}/${template_repo}/generate`, body));
+});
+server.tool('gitea_repo_search', 'Search repositories', {
+    q: z.string().describe('Search query'),
+    topic: z.boolean().optional().describe('Search in topics'),
+    sort: z.enum(['alpha', 'created', 'updated', 'size', 'stars', 'forks']).optional().describe('Sort field'),
+    order: z.enum(['asc', 'desc']).optional().describe('Sort order'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ q, topic, sort, order, page, limit, connection }) => {
+    const params = { q, ...pageQuery({ page, limit }) };
+    if (topic !== undefined)
+        params['topic'] = String(topic);
+    if (sort)
+        params['sort'] = sort;
+    if (order)
+        params['order'] = order;
+    return formatResponse(await clientFor(connection).get('/repos/search', params));
+});
+server.tool('gitea_org_repos', 'List repositories in an organization', {
+    org: z.string().describe('Organization name'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ org, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/orgs/${org}/repos`, pageQuery({ page, limit }))));
+// ── File Contents ───────────────────────────────────────────────────────
+server.tool('gitea_file_get', 'Get file contents from a repository', {
+    ...OwnerRepo,
+    filepath: z.string().describe('File path (e.g. "src/index.ts")'),
+    ref: z.string().optional().describe('Branch/tag/commit (default: default branch)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, filepath, ref, connection }) => {
+    const params = {};
+    if (ref)
+        params['ref'] = ref;
+    return formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/contents/${filepath}`, params));
+});
+server.tool('gitea_dir_get', 'Get directory contents (file listing) from a repository', {
+    ...OwnerRepo,
+    dirpath: z.string().optional().describe('Directory path (default: root)'),
+    ref: z.string().optional().describe('Branch/tag/commit'),
+    ...ConnectionParam,
+}, async ({ owner, repo, dirpath, ref, connection }) => {
+    const path = dirpath ? `/repos/${owner}/${repo}/contents/${dirpath}` : `/repos/${owner}/${repo}/contents`;
+    const params = {};
+    if (ref)
+        params['ref'] = ref;
+    return formatResponse(await clientFor(connection).get(path, params));
+});
+server.tool('gitea_file_create_or_update', 'Create or update a file in a repository', {
+    ...OwnerRepo,
+    filepath: z.string().describe('File path'),
+    content: z.string().describe('File content (will be base64-encoded automatically)'),
+    message: z.string().describe('Commit message'),
+    branch: z.string().optional().describe('Branch (default: default branch)'),
+    sha: z.string().optional().describe('SHA of existing file (required for updates)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, filepath, content, message, branch, sha, connection }) => {
+    const body = {
+        content: Buffer.from(content).toString('base64'),
+        message,
+    };
+    if (branch)
+        body.branch = branch;
+    if (sha)
+        body.sha = sha;
+    return formatResponse(await clientFor(connection).put(`/repos/${owner}/${repo}/contents/${filepath}`, body));
+});
+server.tool('gitea_file_delete', 'Delete a file from a repository', {
+    ...OwnerRepo,
+    filepath: z.string().describe('File path to delete'),
+    sha: z.string().describe('SHA of file to delete'),
+    message: z.string().describe('Commit message'),
+    branch: z.string().optional().describe('Branch'),
+    ...ConnectionParam,
+}, async ({ owner, repo, filepath, sha, message, branch, connection }) => {
+    const client = clientFor(connection);
+    const body = { sha, message };
+    if (branch)
+        body.branch = branch;
+    return formatResponse(await client.delete(`/repos/${owner}/${repo}/contents/${filepath}`, body));
+});
+server.tool('gitea_tree_get', 'Get the git tree for a repository (recursive file listing)', {
+    ...OwnerRepo,
+    sha: z.string().describe('Tree SHA or branch name'),
+    recursive: z.boolean().optional().describe('Recursive listing (default true)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, sha, recursive, connection }) => {
+    const params = {};
+    if (recursive !== false)
+        params['recursive'] = 'true';
+    return formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/git/trees/${sha}`, params));
+});
+// ── Branches ────────────────────────────────────────────────────────────
+server.tool('gitea_branches_list', 'List branches in a repository', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/branches`, pageQuery({ page, limit }))));
+server.tool('gitea_branch_get', 'Get a specific branch', { ...OwnerRepo, branch: z.string().describe('Branch name'), ...ConnectionParam }, async ({ owner, repo, branch, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/branches/${branch}`)));
+server.tool('gitea_branch_create', 'Create a new branch', {
+    ...OwnerRepo,
+    new_branch_name: z.string().describe('Name for new branch'),
+    old_branch_name: z.string().optional().describe('Source branch (default: default branch)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, new_branch_name, old_branch_name, connection }) => {
+    const body = { new_branch_name };
+    if (old_branch_name)
+        body.old_branch_name = old_branch_name;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/branches`, body));
+});
+server.tool('gitea_branch_delete', 'Delete a branch', { ...OwnerRepo, branch: z.string().describe('Branch name'), ...ConnectionParam }, async ({ owner, repo, branch, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}/branches/${branch}`)));
+// ── Commits ─────────────────────────────────────────────────────────────
+server.tool('gitea_commits_list', 'List commits in a repository', {
+    ...OwnerRepo,
+    sha: z.string().optional().describe('Branch or commit SHA'),
+    path: z.string().optional().describe('Filter by file path'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ owner, repo, sha, path, page, limit, connection }) => {
+    const params = { ...pageQuery({ page, limit }) };
+    if (sha)
+        params['sha'] = sha;
+    if (path)
+        params['path'] = path;
+    return formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/commits`, params));
+});
+server.tool('gitea_commit_get', 'Get a specific commit', { ...OwnerRepo, sha: z.string().describe('Commit SHA'), ...ConnectionParam }, async ({ owner, repo, sha, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/git/commits/${sha}`)));
+// ── Issues ──────────────────────────────────────────────────────────────
+server.tool('gitea_issues_list', 'List issues in a repository', {
+    ...OwnerRepo,
+    state: z.enum(['open', 'closed', 'all']).optional().describe('Issue state filter'),
+    type: z.enum(['issues', 'pulls']).optional().describe('Filter by type'),
+    labels: z.string().optional().describe('Comma-separated label names'),
+    milestones: z.string().optional().describe('Comma-separated milestone names'),
+    q: z.string().optional().describe('Search query'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ owner, repo, state, type, labels, milestones, q, page, limit, connection }) => {
+    const params = { ...pageQuery({ page, limit }) };
+    if (state)
+        params['state'] = state;
+    if (type)
+        params['type'] = type;
+    if (labels)
+        params['labels'] = labels;
+    if (milestones)
+        params['milestones'] = milestones;
+    if (q)
+        params['q'] = q;
+    return formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/issues`, params));
+});
+server.tool('gitea_issue_get', 'Get a single issue by number', { ...OwnerRepo, number: z.number().describe('Issue number'), ...ConnectionParam }, async ({ owner, repo, number, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/issues/${number}`)));
+server.tool('gitea_issue_create', 'Create a new issue', {
+    ...OwnerRepo,
+    title: z.string().describe('Issue title'),
+    body: z.string().optional().describe('Issue body (markdown)'),
+    labels: z.array(z.union([z.number(), z.string()])).optional().describe('Label IDs or names (use gitea_labels_list to discover available labels)'),
+    milestone: z.number().optional().describe('Milestone ID'),
+    assignees: z.array(z.string()).optional().describe('Usernames to assign'),
+    status_id: z.number().optional().describe('Issue status definition ID (use gitea_org_issue_statuses_list to discover)'),
+    priority_id: z.number().optional().describe('Issue priority definition ID (use gitea_org_issue_priorities_list to discover)'),
+    type_id: z.number().optional().describe('Issue type definition ID (use gitea_org_issue_types_list to discover)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, title, body: issueBody, labels, milestone, assignees, status_id, priority_id, type_id, connection }) => {
+    const body = { title };
+    if (issueBody)
+        body.body = issueBody;
+    if (labels)
+        body.labels = labels;
+    if (milestone)
+        body.milestone = milestone;
+    if (assignees)
+        body.assignees = assignees;
+    if (status_id !== undefined)
+        body.status_id = status_id;
+    if (priority_id !== undefined)
+        body.priority_id = priority_id;
+    if (type_id !== undefined)
+        body.type_id = type_id;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/issues`, body));
+});
+server.tool('gitea_issue_update', 'Update an issue (supports title, body, state, assignees, milestone, and org-level metadata)', {
+    ...OwnerRepo,
+    number: z.number().describe('Issue number'),
+    title: z.string().optional().describe('New title'),
+    body: z.string().optional().describe('New body'),
+    state: z.enum(['open', 'closed']).optional().describe('State'),
+    assignees: z.array(z.string()).optional().describe('Assignees'),
+    milestone: z.number().optional().describe('Milestone ID'),
+    status_id: z.number().optional().describe('Issue status definition ID (use gitea_org_issue_statuses_list to discover; 0 to clear)'),
+    priority_id: z.number().optional().describe('Issue priority definition ID (use gitea_org_issue_priorities_list to discover; 0 to clear)'),
+    type_id: z.number().optional().describe('Issue type definition ID (use gitea_org_issue_types_list to discover; 0 to clear)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, number, title, body: issueBody, state, assignees, milestone, status_id, priority_id, type_id, connection }) => {
+    const body = {};
+    if (title !== undefined)
+        body.title = title;
+    if (issueBody !== undefined)
+        body.body = issueBody;
+    if (state)
+        body.state = state;
+    if (assignees)
+        body.assignees = assignees;
+    if (milestone !== undefined)
+        body.milestone = milestone;
+    if (status_id !== undefined)
+        body.status_id = status_id;
+    if (priority_id !== undefined)
+        body.priority_id = priority_id;
+    if (type_id !== undefined)
+        body.type_id = type_id;
+    return formatResponse(await clientFor(connection).patch(`/repos/${owner}/${repo}/issues/${number}`, body));
+});
+server.tool('gitea_issue_set_status', 'Set or clear the status on an issue (convenience wrapper around issue update)', {
+    ...OwnerRepo,
+    number: z.number().describe('Issue number'),
+    status_id: z.number().describe('Status definition ID (0 to clear)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, number, status_id, connection }) => {
+    return formatResponse(await clientFor(connection).patch(`/repos/${owner}/${repo}/issues/${number}`, { status_id }));
+});
+server.tool('gitea_issue_set_priority', 'Set or clear the priority on an issue (convenience wrapper around issue update)', {
+    ...OwnerRepo,
+    number: z.number().describe('Issue number'),
+    priority_id: z.number().describe('Priority definition ID (0 to clear)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, number, priority_id, connection }) => {
+    return formatResponse(await clientFor(connection).patch(`/repos/${owner}/${repo}/issues/${number}`, { priority_id }));
+});
+server.tool('gitea_issue_comments_list', 'List comments on an issue', { ...OwnerRepo, number: z.number().describe('Issue number'), ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, number, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/issues/${number}/comments`, pageQuery({ page, limit }))));
+server.tool('gitea_issue_comment_create', 'Add a comment to an issue', {
+    ...OwnerRepo,
+    number: z.number().describe('Issue number'),
+    body: z.string().describe('Comment body (markdown)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, number, body: commentBody, connection }) => {
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/issues/${number}/comments`, { body: commentBody }));
+});
+server.tool('gitea_issue_search', 'Search issues across all repositories', {
+    q: z.string().describe('Search query'),
+    state: z.enum(['open', 'closed', 'all']).optional().describe('State filter'),
+    labels: z.string().optional().describe('Comma-separated label IDs or names'),
+    type: z.enum(['issues', 'pulls']).optional().describe('Filter type'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ q, state, labels, type, page, limit, connection }) => {
+    const params = { q, ...pageQuery({ page, limit }) };
+    if (state)
+        params['state'] = state;
+    if (labels)
+        params['labels'] = labels;
+    if (type)
+        params['type'] = type;
+    return formatResponse(await clientFor(connection).get('/repos/search', params));
+});
+// ── Labels ──────────────────────────────────────────────────────────────
+server.tool('gitea_labels_list', 'List all labels in a repository (includes id, name, color, description — use to discover available type/priority/status labels)', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/labels`, pageQuery({ page, limit }))));
+server.tool('gitea_label_create', 'Create a label', {
+    ...OwnerRepo,
+    name: z.string().describe('Label name'),
+    color: z.string().describe('Color hex (e.g. "#d73a4a")'),
+    description: z.string().optional().describe('Label description'),
+    ...ConnectionParam,
+}, async ({ owner, repo, name, color, description, connection }) => {
+    const body = { name, color };
+    if (description)
+        body.description = description;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/labels`, body));
+});
+// ── Milestones ──────────────────────────────────────────────────────────
+server.tool('gitea_milestones_list', 'List milestones in a repository', {
+    ...OwnerRepo,
+    state: z.enum(['open', 'closed', 'all']).optional().describe('State filter'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ owner, repo, state, page, limit, connection }) => {
+    const params = { ...pageQuery({ page, limit }) };
+    if (state)
+        params['state'] = state;
+    return formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/milestones`, params));
+});
+server.tool('gitea_milestone_create', 'Create a milestone', {
+    ...OwnerRepo,
+    title: z.string().describe('Milestone title'),
+    description: z.string().optional().describe('Description'),
+    due_on: z.string().optional().describe('Due date (ISO 8601)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, title, description, due_on, connection }) => {
+    const body = { title };
+    if (description)
+        body.description = description;
+    if (due_on)
+        body.due_on = due_on;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/milestones`, body));
+});
+// ── Pull Requests ───────────────────────────────────────────────────────
+server.tool('gitea_pulls_list', 'List pull requests', {
+    ...OwnerRepo,
+    state: z.enum(['open', 'closed', 'all']).optional().describe('State filter'),
+    sort: z.enum(['oldest', 'recentupdate', 'leastupdate', 'mostcomment', 'leastcomment', 'priority']).optional(),
+    labels: z.string().optional().describe('Comma-separated label IDs'),
+    milestone: z.number().optional().describe('Milestone ID'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ owner, repo, state, sort, labels, milestone, page, limit, connection }) => {
+    const params = { ...pageQuery({ page, limit }) };
+    if (state)
+        params['state'] = state;
+    if (sort)
+        params['sort'] = sort;
+    if (labels)
+        params['labels'] = labels;
+    if (milestone !== undefined)
+        params['milestone'] = String(milestone);
+    return formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/pulls`, params));
+});
+server.tool('gitea_pull_get', 'Get a single pull request', { ...OwnerRepo, number: z.number().describe('PR number'), ...ConnectionParam }, async ({ owner, repo, number, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/pulls/${number}`)));
+server.tool('gitea_pull_create', 'Create a pull request', {
+    ...OwnerRepo,
+    title: z.string().describe('PR title'),
+    head: z.string().describe('Source branch'),
+    base: z.string().describe('Target branch'),
+    body: z.string().optional().describe('PR description (markdown)'),
+    labels: z.array(z.union([z.number(), z.string()])).optional().describe('Label IDs or names (use gitea_labels_list to discover available labels)'),
+    milestone: z.number().optional().describe('Milestone ID'),
+    assignees: z.array(z.string()).optional().describe('Assignees'),
+    ...ConnectionParam,
+}, async ({ owner, repo, title, head, base, body: prBody, labels, milestone, assignees, connection }) => {
+    const body = { title, head, base };
+    if (prBody)
+        body.body = prBody;
+    if (labels)
+        body.labels = labels;
+    if (milestone)
+        body.milestone = milestone;
+    if (assignees)
+        body.assignees = assignees;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/pulls`, body));
+});
+server.tool('gitea_pull_merge', 'Merge a pull request', {
+    ...OwnerRepo,
+    number: z.number().describe('PR number'),
+    merge_type: z.enum(['merge', 'rebase', 'squash', 'rebase-merge']).optional().describe('Merge method (default: merge)'),
+    title: z.string().optional().describe('Custom merge commit title'),
+    message: z.string().optional().describe('Custom merge commit message'),
+    delete_branch_after_merge: z.boolean().optional().describe('Delete head branch after merge'),
+    ...ConnectionParam,
+}, async ({ owner, repo, number, merge_type, title, message, delete_branch_after_merge, connection }) => {
+    const body = { Do: merge_type ?? 'merge' };
+    if (title)
+        body.MergeTitleField = title;
+    if (message)
+        body.MergeMessageField = message;
+    if (delete_branch_after_merge !== undefined)
+        body.delete_branch_after_merge = delete_branch_after_merge;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/pulls/${number}/merge`, body));
+});
+server.tool('gitea_pull_files', 'List files changed in a pull request', { ...OwnerRepo, number: z.number().describe('PR number'), ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, number, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/pulls/${number}/files`, pageQuery({ page, limit }))));
+server.tool('gitea_pull_review_create', 'Create a pull request review', {
+    ...OwnerRepo,
+    number: z.number().describe('PR number'),
+    event: z.enum(['APPROVED', 'REQUEST_CHANGES', 'COMMENT']).describe('Review action'),
+    body: z.string().optional().describe('Review comment'),
+    ...ConnectionParam,
+}, async ({ owner, repo, number, event, body: reviewBody, connection }) => {
+    const body = { event };
+    if (reviewBody)
+        body.body = reviewBody;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/pulls/${number}/reviews`, body));
+});
+// ── Releases ────────────────────────────────────────────────────────────
+server.tool('gitea_releases_list', 'List releases', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/releases`, pageQuery({ page, limit }))));
+server.tool('gitea_release_get', 'Get a single release by ID', { ...OwnerRepo, id: z.number().describe('Release ID'), ...ConnectionParam }, async ({ owner, repo, id, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/releases/${id}`)));
+server.tool('gitea_release_latest', 'Get the latest release', { ...OwnerRepo, ...ConnectionParam }, async ({ owner, repo, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/releases/latest`)));
+server.tool('gitea_release_create', 'Create a new release', {
+    ...OwnerRepo,
+    tag_name: z.string().describe('Tag name (e.g. "v1.0.0")'),
+    name: z.string().optional().describe('Release title'),
+    body: z.string().optional().describe('Release notes (markdown)'),
+    target_commitish: z.string().optional().describe('Target branch/commit'),
+    draft: z.boolean().optional().describe('Create as draft'),
+    prerelease: z.boolean().optional().describe('Mark as prerelease'),
+    ...ConnectionParam,
+}, async ({ owner, repo, tag_name, name, body: notes, target_commitish, draft, prerelease, connection }) => {
+    const body = { tag_name };
+    if (name)
+        body.name = name;
+    if (notes)
+        body.body = notes;
+    if (target_commitish)
+        body.target_commitish = target_commitish;
+    if (draft !== undefined)
+        body.draft = draft;
+    if (prerelease !== undefined)
+        body.prerelease = prerelease;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/releases`, body));
+});
+server.tool('gitea_release_delete', 'Delete a release', { ...OwnerRepo, id: z.number().describe('Release ID'), ...ConnectionParam }, async ({ owner, repo, id, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}/releases/${id}`)));
+// ── Tags ────────────────────────────────────────────────────────────────
+server.tool('gitea_tags_list', 'List tags', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/tags`, pageQuery({ page, limit }))));
+server.tool('gitea_tag_create', 'Create a tag', {
+    ...OwnerRepo,
+    tag_name: z.string().describe('Tag name'),
+    target: z.string().optional().describe('Target branch/commit SHA'),
+    message: z.string().optional().describe('Tag message (annotated tag)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, tag_name, target, message, connection }) => {
+    const body = { tag_name };
+    if (target)
+        body.target = target;
+    if (message)
+        body.message = message;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/tags`, body));
+});
+server.tool('gitea_tag_delete', 'Delete a tag', { ...OwnerRepo, tag: z.string().describe('Tag name'), ...ConnectionParam }, async ({ owner, repo, tag, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}/tags/${tag}`)));
+// ── Actions (CI/CD) ─────────────────────────────────────────────────────
+server.tool('gitea_actions_runs_list', 'List workflow runs for a repository', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/actions/runs`, pageQuery({ page, limit }))));
+server.tool('gitea_actions_run_get', 'Get a specific workflow run', { ...OwnerRepo, run_id: z.number().describe('Run ID'), ...ConnectionParam }, async ({ owner, repo, run_id, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/actions/runs/${run_id}`)));
+server.tool('gitea_actions_dispatch', 'Trigger a workflow dispatch (e.g. pre-release, deploy)', {
+    ...OwnerRepo,
+    workflow: z.string().describe('Workflow filename (e.g. pre-release.yml)'),
+    ref: z.string().describe('Branch or tag to run on (e.g. dev, main)'),
+    inputs: z.record(z.string()).optional().describe('Workflow input key-value pairs'),
+    ...ConnectionParam,
+}, async ({ owner, repo, workflow, ref, inputs, connection }) => formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/actions/workflows/${workflow}/dispatches`, { ref, inputs: inputs ?? {} })));
+server.tool('gitea_actions_jobs_list', 'List jobs for a workflow run', { ...OwnerRepo, run_id: z.number().describe('Run ID'), ...ConnectionParam }, async ({ owner, repo, run_id, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/actions/runs/${run_id}/jobs`)));
+server.tool('gitea_actions_job_logs', 'Get log output for a workflow job', { ...OwnerRepo, job_id: z.number().describe('Job ID'), ...ConnectionParam }, async ({ owner, repo, job_id, connection }) => {
+    const client = clientFor(connection);
+    const res = await client.get(`/repos/${owner}/${repo}/actions/jobs/${job_id}/logs`);
+    if (res.status >= 400)
+        return formatResponse(res);
+    // Logs come as plain text
+    const text = typeof res.data === 'string' ? res.data : JSON.stringify(res.data);
+    return { content: [{ type: 'text', text }] };
+});
+server.tool('gitea_release_asset_upload', 'Upload a file as a release asset (provide base64-encoded content)', {
+    ...OwnerRepo,
+    release_id: z.number().describe('Release ID'),
+    name: z.string().describe('Asset filename'),
+    content_base64: z.string().describe('Base64-encoded file content'),
+    ...ConnectionParam,
+}, async ({ owner, repo, release_id, name, content_base64, connection }) => {
+    const client = clientFor(connection);
+    // Gitea expects multipart form data for asset upload
+    // For now, use the API with the binary content
+    const res = await client.post(`/repos/${owner}/${repo}/releases/${release_id}/assets?name=${encodeURIComponent(name)}`, Buffer.from(content_base64, 'base64'));
+    return formatResponse(res);
+});
+server.tool('gitea_release_asset_delete', 'Delete a release asset', {
+    ...OwnerRepo,
+    release_id: z.number().describe('Release ID'),
+    asset_id: z.number().describe('Asset ID'),
+    ...ConnectionParam,
+}, async ({ owner, repo, release_id, asset_id, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}/releases/${release_id}/assets/${asset_id}`)));
+server.tool('gitea_bulk_file_push', 'Push the same file content to multiple repos (uses Contents API)', {
+    owner: z.string().describe('Organization name'),
+    repos: z.array(z.string()).describe('List of repository names'),
+    path: z.string().describe('File path in each repo (e.g. .mokogitea/workflows/pre-release.yml)'),
+    content_base64: z.string().describe('Base64-encoded file content'),
+    message: z.string().describe('Commit message'),
+    branch: z.string().optional().describe('Target branch (default: main)'),
+    ...ConnectionParam,
+}, async ({ owner, repos, path, content_base64, message, branch, connection }) => {
+    const client = clientFor(connection);
+    const targetBranch = branch ?? 'main';
+    const results = [];
+    for (const repo of repos) {
+        try {
+            // Get current file SHA
+            const existing = await client.get(`/repos/${owner}/${repo}/contents/${path}?ref=${targetBranch}`);
+            const sha = existing.data?.sha;
+            if (sha) {
+                // Update existing file
+                await client.put(`/repos/${owner}/${repo}/contents/${path}`, {
+                    content: content_base64,
+                    sha,
+                    message,
+                    branch: targetBranch,
+                });
+                results.push({ repo, status: 'updated' });
+            }
+            else {
+                // Create new file
+                await client.post(`/repos/${owner}/${repo}/contents/${path}`, {
+                    content: content_base64,
+                    message,
+                    branch: targetBranch,
+                });
+                results.push({ repo, status: 'created' });
+            }
+        }
+        catch (e) {
+            results.push({ repo, status: `error: ${e}` });
+        }
+    }
+    const summary = results.map(r => `${r.repo}: ${r.status}`).join('\n');
+    return { content: [{ type: 'text', text: summary }] };
+});
+// ── Organizations ───────────────────────────────────────────────────────
+server.tool('gitea_org_get', 'Get organization details', { org: z.string().describe('Organization name'), ...ConnectionParam }, async ({ org, connection }) => formatResponse(await clientFor(connection).get(`/orgs/${org}`)));
+server.tool('gitea_org_teams_list', 'List teams in an organization', { org: z.string().describe('Organization name'), ...PaginationParams, ...ConnectionParam }, async ({ org, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/orgs/${org}/teams`, pageQuery({ page, limit }))));
+server.tool('gitea_org_members_list', 'List members of an organization', { org: z.string().describe('Organization name'), ...PaginationParams, ...ConnectionParam }, async ({ org, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/orgs/${org}/members`, pageQuery({ page, limit }))));
+// ── Organization Issue Metadata ──────────────────────────────────────────
+server.tool('gitea_org_issue_statuses_list', 'List issue status definitions for an organization (id, name, color, closes_issue — use to discover valid status_id values)', { org: z.string().describe('Organization name'), ...ConnectionParam }, async ({ org, connection }) => formatResponse(await clientFor(connection).get(`/orgs/${org}/issue-statuses`)));
+server.tool('gitea_org_issue_priorities_list', 'List issue priority definitions for an organization (id, name, color, is_default — use to discover valid priority_id values)', { org: z.string().describe('Organization name'), ...ConnectionParam }, async ({ org, connection }) => formatResponse(await clientFor(connection).get(`/orgs/${org}/issue-priorities`)));
+server.tool('gitea_org_issue_types_list', 'List issue type definitions for an organization (id, name, color, is_default — use to discover valid type_id values)', { org: z.string().describe('Organization name'), ...ConnectionParam }, async ({ org, connection }) => formatResponse(await clientFor(connection).get(`/orgs/${org}/issue-types`)));
+// ── Users ───────────────────────────────────────────────────────────────
+server.tool('gitea_user_get', 'Get a user profile', { username: z.string().describe('Username'), ...ConnectionParam }, async ({ username, connection }) => formatResponse(await clientFor(connection).get(`/users/${username}`)));
+server.tool('gitea_users_search', 'Search users', {
+    q: z.string().describe('Search query'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ q, page, limit, connection }) => formatResponse(await clientFor(connection).get('/users/search', { q, ...pageQuery({ page, limit }) })));
+// ── Webhooks ────────────────────────────────────────────────────────────
+server.tool('gitea_webhooks_list', 'List webhooks for a repository', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/hooks`, pageQuery({ page, limit }))));
+server.tool('gitea_webhook_create', 'Create a webhook', {
+    ...OwnerRepo,
+    type: z.enum(['gitea', 'slack', 'discord', 'dingtalk', 'telegram', 'msteams', 'feishu', 'matrix', 'wechatwork', 'packagist']).describe('Hook type'),
+    url: z.string().describe('Webhook URL'),
+    events: z.array(z.string()).optional().describe('Events to listen for (e.g. ["push", "pull_request"])'),
+    active: z.boolean().optional().describe('Active status'),
+    ...ConnectionParam,
+}, async ({ owner, repo, type, url, events, active, connection }) => {
+    const body = {
+        type,
+        config: { url, content_type: 'json' },
+        events: events ?? ['push'],
+        active: active ?? true,
+    };
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/hooks`, body));
+});
+// ── Wiki ────────────────────────────────────────────────────────────────
+server.tool('gitea_wiki_pages_list', 'List wiki pages', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/wiki/pages`, pageQuery({ page, limit }))));
+server.tool('gitea_wiki_page_get', 'Get a wiki page', { ...OwnerRepo, page_name: z.string().describe('Page name/slug'), ...ConnectionParam }, async ({ owner, repo, page_name, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/wiki/page/${page_name}`)));
+// ── Notifications ───────────────────────────────────────────────────────
+server.tool('gitea_notifications_list', 'List notifications for the authenticated user', {
+    status_types: z.string().optional().describe('Comma-separated: read, unread, pinned'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ status_types, page, limit, connection }) => {
+    const params = { ...pageQuery({ page, limit }) };
+    if (status_types)
+        params['status-types'] = status_types;
+    return formatResponse(await clientFor(connection).get('/notifications', params));
+});
+server.tool('gitea_notifications_read', 'Mark all notifications as read', { ...ConnectionParam }, async ({ connection }) => formatResponse(await clientFor(connection).put('/notifications', {})));
+// ── Topics ──────────────────────────────────────────────────────────────
+server.tool('gitea_repo_topics', 'Get topics (tags) for a repository', { ...OwnerRepo, ...ConnectionParam }, async ({ owner, repo, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/topics`)));
+server.tool('gitea_repo_topics_set', 'Set topics for a repository (replaces all existing)', {
+    ...OwnerRepo,
+    topics: z.array(z.string()).describe('Array of topic names'),
+    ...ConnectionParam,
+}, async ({ owner, repo, topics, connection }) => formatResponse(await clientFor(connection).put(`/repos/${owner}/${repo}/topics`, { topics })));
+server.tool('gitea_topic_search', 'Search topics across all repositories', {
+    q: z.string().describe('Search query'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ q, page, limit, connection }) => formatResponse(await clientFor(connection).get('/topics/search', { q, ...pageQuery({ page, limit }) })));
+// ── Collaborators ───────────────────────────────────────────────────────
+server.tool('gitea_collaborators_list', 'List collaborators on a repository', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/collaborators`, pageQuery({ page, limit }))));
+server.tool('gitea_collaborator_add', 'Add a collaborator to a repository', {
+    ...OwnerRepo,
+    collaborator: z.string().describe('Username to add'),
+    permission: z.enum(['read', 'write', 'admin']).optional().describe('Permission level (default: write)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, collaborator, permission, connection }) => {
+    const body = {};
+    if (permission)
+        body.permission = permission;
+    return formatResponse(await clientFor(connection).put(`/repos/${owner}/${repo}/collaborators/${collaborator}`, body));
+});
+server.tool('gitea_collaborator_remove', 'Remove a collaborator from a repository', {
+    ...OwnerRepo,
+    collaborator: z.string().describe('Username to remove'),
+    ...ConnectionParam,
+}, async ({ owner, repo, collaborator, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}/collaborators/${collaborator}`)));
+// ── Deploy Keys ─────────────────────────────────────────────────────────
+server.tool('gitea_deploy_keys_list', 'List deploy keys for a repository', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/keys`, pageQuery({ page, limit }))));
+server.tool('gitea_deploy_key_create', 'Add a deploy key to a repository', {
+    ...OwnerRepo,
+    title: z.string().describe('Key title'),
+    key: z.string().describe('SSH public key content'),
+    read_only: z.boolean().optional().describe('Read-only access (default: true)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, title, key, read_only, connection }) => {
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/keys`, {
+        title,
+        key,
+        read_only: read_only ?? true,
+    }));
+});
+server.tool('gitea_deploy_key_delete', 'Remove a deploy key from a repository', {
+    ...OwnerRepo,
+    id: z.number().describe('Deploy key ID'),
+    ...ConnectionParam,
+}, async ({ owner, repo, id, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}/keys/${id}`)));
+// ── Branch Protection ───────────────────────────────────────────────────
+server.tool('gitea_branch_protections_list', 'List branch protection rules for a repository', { ...OwnerRepo, ...ConnectionParam }, async ({ owner, repo, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/branch_protections`)));
+server.tool('gitea_branch_protection_create', 'Create a branch protection rule', {
+    ...OwnerRepo,
+    branch_name: z.string().describe('Branch name or pattern (e.g. "main", "release/*")'),
+    enable_push: z.boolean().optional().describe('Allow push (default: true)'),
+    enable_push_whitelist: z.boolean().optional().describe('Enable push whitelist'),
+    push_whitelist_usernames: z.array(z.string()).optional().describe('Users allowed to push'),
+    require_signed_commits: z.boolean().optional().describe('Require signed commits'),
+    required_approvals: z.number().optional().describe('Required PR approvals (0 = none)'),
+    enable_status_check: z.boolean().optional().describe('Require status checks'),
+    status_check_contexts: z.array(z.string()).optional().describe('Required status check names'),
+    ...ConnectionParam,
+}, async ({ owner, repo, branch_name, enable_push, enable_push_whitelist, push_whitelist_usernames, require_signed_commits, required_approvals, enable_status_check, status_check_contexts, connection }) => {
+    const body = { branch_name };
+    if (enable_push !== undefined)
+        body.enable_push = enable_push;
+    if (enable_push_whitelist !== undefined)
+        body.enable_push_whitelist = enable_push_whitelist;
+    if (push_whitelist_usernames)
+        body.push_whitelist_usernames = push_whitelist_usernames;
+    if (require_signed_commits !== undefined)
+        body.require_signed_commits = require_signed_commits;
+    if (required_approvals !== undefined)
+        body.required_approvals = required_approvals;
+    if (enable_status_check !== undefined)
+        body.enable_status_check = enable_status_check;
+    if (status_check_contexts)
+        body.status_check_contexts = status_check_contexts;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/branch_protections`, body));
+});
+server.tool('gitea_branch_protection_delete', 'Delete a branch protection rule', {
+    ...OwnerRepo,
+    name: z.string().describe('Branch protection rule name'),
+    ...ConnectionParam,
+}, async ({ owner, repo, name, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}/branch_protections/${name}`)));
+// ── Organization Labels ─────────────────────────────────────────────────
+server.tool('gitea_org_labels_list', 'List labels for an organization (shared across repos — includes id, name, color, description for type/priority/status discovery)', {
+    org: z.string().describe('Organization name'),
+    ...PaginationParams,
+    ...ConnectionParam,
+}, async ({ org, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/orgs/${org}/labels`, pageQuery({ page, limit }))));
+server.tool('gitea_org_label_create', 'Create an organization-level label', {
+    org: z.string().describe('Organization name'),
+    name: z.string().describe('Label name'),
+    color: z.string().describe('Color hex (e.g. "#d73a4a")'),
+    description: z.string().optional().describe('Label description'),
+    ...ConnectionParam,
+}, async ({ org, name, color, description, connection }) => {
+    const body = { name, color };
+    if (description)
+        body.description = description;
+    return formatResponse(await clientFor(connection).post(`/orgs/${org}/labels`, body));
+});
+// ── Repository Secrets (Actions) ────────────────────────────────────────
+server.tool('gitea_repo_actions_secrets_list', 'List Actions secrets for a repository (names only, values hidden)', { ...OwnerRepo, ...PaginationParams, ...ConnectionParam }, async ({ owner, repo, page, limit, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/actions/secrets`, pageQuery({ page, limit }))));
+server.tool('gitea_repo_actions_secret_create', 'Create or update an Actions secret', {
+    ...OwnerRepo,
+    name: z.string().describe('Secret name'),
+    data: z.string().describe('Secret value'),
+    ...ConnectionParam,
+}, async ({ owner, repo, name, data, connection }) => formatResponse(await clientFor(connection).put(`/repos/${owner}/${repo}/actions/secrets/${name}`, { data })));
+server.tool('gitea_repo_actions_secret_delete', 'Delete an Actions secret', {
+    ...OwnerRepo,
+    name: z.string().describe('Secret name'),
+    ...ConnectionParam,
+}, async ({ owner, repo, name, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}/actions/secrets/${name}`)));
+// ── Repo Transfer / Mirror ──────────────────────────────────────────────
+server.tool('gitea_repo_mirror_sync', 'Trigger a push mirror sync for a repository', { ...OwnerRepo, ...ConnectionParam }, async ({ owner, repo, connection }) => formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/mirror-sync`, {})));
+server.tool('gitea_repo_mirrors_list', 'List push mirrors for a repository', { ...OwnerRepo, ...ConnectionParam }, async ({ owner, repo, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/push_mirrors`)));
+server.tool('gitea_repo_mirror_create', 'Create a push mirror to GitHub (backup). Sets up automatic push mirroring from Gitea to a GitHub repo.', {
+    ...OwnerRepo,
+    github_owner: z.string().optional().describe('GitHub org or user (defaults to config github.org)'),
+    github_repo: z.string().optional().describe('GitHub repo name (defaults to same as Gitea repo)'),
+    github_token: z.string().optional().describe('GitHub token (defaults to config github.token)'),
+    interval: z.string().optional().describe('Sync interval (e.g. "8h0m0s", default "8h0m0s")'),
+    ...ConnectionParam,
+}, async ({ owner, repo, github_owner, github_repo, github_token, interval, connection }) => {
+    const ghToken = github_token ?? config.github?.token;
+    const ghOwner = github_owner ?? config.github?.org;
+    if (!ghToken)
+        return { content: [{ type: 'text', text: 'Error: No GitHub token. Pass github_token or set github.token in config.' }] };
+    if (!ghOwner)
+        return { content: [{ type: 'text', text: 'Error: No GitHub owner. Pass github_owner or set github.org in config.' }] };
+    const ghRepo = github_repo ?? repo;
+    return formatResponse(await clientFor(connection).post(`/repos/${owner}/${repo}/push_mirrors`, {
+        remote_address: `https://github.com/${ghOwner}/${ghRepo}.git`,
+        remote_username: ghOwner,
+        remote_password: ghToken,
+        interval: interval ?? '8h0m0s',
+        sync_on_commit: true,
+    }));
+});
+server.tool('gitea_repo_mirror_delete', 'Delete a push mirror from a repository', {
+    ...OwnerRepo,
+    mirror_name: z.string().describe('Push mirror remote name (from mirrors_list)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, mirror_name, connection }) => formatResponse(await clientFor(connection).delete(`/repos/${owner}/${repo}/push_mirrors/${mirror_name}`)));
+server.tool('gitea_repo_mirror_setup_github_backup', 'One-step GitHub backup mirror setup: creates the GitHub repo (if needed) and configures push mirror. Requires a GitHub token with repo+org scope.', {
+    ...OwnerRepo,
+    github_org: z.string().optional().describe('GitHub org (defaults to config github.org)'),
+    github_token: z.string().optional().describe('GitHub token (defaults to config github.token)'),
+    private: z.boolean().optional().describe('Make GitHub repo private (default true)'),
+    description: z.string().optional().describe('GitHub repo description'),
+    interval: z.string().optional().describe('Mirror sync interval (default "8h0m0s")'),
+    ...ConnectionParam,
+}, async ({ owner, repo, github_org, github_token, private: isPrivate, description, interval, connection }) => {
+    const ghToken = github_token ?? config.github?.token;
+    const ghOrg = github_org ?? config.github?.org;
+    if (!ghToken)
+        return { content: [{ type: 'text', text: 'Error: No GitHub token. Pass github_token or set github.token in config.' }] };
+    if (!ghOrg)
+        return { content: [{ type: 'text', text: 'Error: No GitHub org. Pass github_org or set github.org in config.' }] };
+    const client = clientFor(connection);
+    const results = [];
+    // 1. Try to create the GitHub repo via GitHub API
+    const ghRes = await fetch(`https://api.github.com/orgs/${ghOrg}/repos`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ghToken}`,
+            'Accept': 'application/vnd.github+json',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            name: repo,
+            private: isPrivate ?? true,
+            description: description ?? `Backup mirror of ${owner}/${repo} from MokoGitea`,
+            auto_init: false,
+            has_issues: false,
+            has_wiki: false,
+            has_projects: false,
+        }),
+    });
+    const ghData = await ghRes.json();
+    if (ghRes.status === 201) {
+        results.push(`GitHub repo created: ${ghOrg}/${repo}`);
+    }
+    else if (ghRes.status === 422) {
+        results.push(`GitHub repo already exists: ${ghOrg}/${repo}`);
+    }
+    else {
+        return { content: [{ type: 'text', text: `GitHub repo creation failed (${ghRes.status}): ${JSON.stringify(ghData)}` }] };
+    }
+    // 2. Create push mirror on Gitea
+    const mirrorRes = await client.post(`/repos/${owner}/${repo}/push_mirrors`, {
+        remote_address: `https://github.com/${ghOrg}/${repo}.git`,
+        remote_username: ghOrg,
+        remote_password: ghToken,
+        interval: interval ?? '8h0m0s',
+        sync_on_commit: true,
+    });
+    if (mirrorRes.status >= 400) {
+        const err = mirrorRes.data;
+        results.push(`Push mirror failed: ${err?.message ?? mirrorRes.status}`);
+    }
+    else {
+        results.push(`Push mirror configured: sync every ${interval ?? '8h0m0s'}, sync on commit`);
+    }
+    // 3. Trigger initial sync
+    await client.post(`/repos/${owner}/${repo}/mirror-sync`, {});
+    results.push('Initial sync triggered');
+    return { content: [{ type: 'text', text: results.join('\n') }] };
+});
+server.tool('gitea_repo_mirror_setup_github_backup_full', 'Full GitHub backup: mirrors code repo + wiki repo to GitHub. Creates GitHub repo, sets up push mirrors for both code and wiki, triggers initial sync.', {
+    ...OwnerRepo,
+    github_org: z.string().optional().describe('GitHub org (defaults to config github.org)'),
+    github_token: z.string().optional().describe('GitHub token (defaults to config github.token)'),
+    private: z.boolean().optional().describe('Make GitHub repo private (default true)'),
+    description: z.string().optional().describe('GitHub repo description'),
+    interval: z.string().optional().describe('Mirror sync interval (default "8h0m0s")'),
+    ...ConnectionParam,
+}, async ({ owner, repo, github_org, github_token, private: isPrivate, description, interval, connection }) => {
+    const ghToken = github_token ?? config.github?.token;
+    const ghOrg = github_org ?? config.github?.org;
+    if (!ghToken)
+        return { content: [{ type: 'text', text: 'Error: No GitHub token. Pass github_token or set github.token in config.' }] };
+    if (!ghOrg)
+        return { content: [{ type: 'text', text: 'Error: No GitHub org. Pass github_org or set github.org in config.' }] };
+    const client = clientFor(connection);
+    const syncInterval = interval ?? '8h0m0s';
+    const results = [];
+    // 1. Create GitHub repo (if needed)
+    const ghRes = await fetch(`https://api.github.com/orgs/${ghOrg}/repos`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ghToken}`,
+            'Accept': 'application/vnd.github+json',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            name: repo,
+            private: isPrivate ?? true,
+            description: description ?? `Backup mirror of ${owner}/${repo} from MokoGitea`,
+            auto_init: false,
+            has_issues: false,
+            has_wiki: true,
+            has_projects: false,
+        }),
+    });
+    const ghData = await ghRes.json();
+    if (ghRes.status === 201) {
+        results.push(`GitHub repo created: ${ghOrg}/${repo}`);
+    }
+    else if (ghRes.status === 422) {
+        results.push(`GitHub repo already exists: ${ghOrg}/${repo}`);
+    }
+    else {
+        return { content: [{ type: 'text', text: `GitHub repo creation failed (${ghRes.status}): ${JSON.stringify(ghData)}` }] };
+    }
+    // 2. Enable wiki on GitHub repo (in case it was disabled)
+    await fetch(`https://api.github.com/repos/${ghOrg}/${repo}`, {
+        method: 'PATCH',
+        headers: {
+            'Authorization': `Bearer ${ghToken}`,
+            'Accept': 'application/vnd.github+json',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ has_wiki: true }),
+    });
+    // 3. Code push mirror
+    const codeRes = await client.post(`/repos/${owner}/${repo}/push_mirrors`, {
+        remote_address: `https://github.com/${ghOrg}/${repo}.git`,
+        remote_username: ghOrg,
+        remote_password: ghToken,
+        interval: syncInterval,
+        sync_on_commit: true,
+    });
+    if (codeRes.status >= 400) {
+        const err = codeRes.data;
+        results.push(`Code mirror: ${err?.message ?? `failed (${codeRes.status})`}`);
+    }
+    else {
+        results.push(`Code mirror configured: sync every ${syncInterval}, sync on commit`);
+    }
+    // 4. Wiki push mirror — Gitea wiki repos are at {repo}.wiki
+    // Check if wiki exists first
+    const wikiCheck = await client.get(`/repos/${owner}/${repo}/wiki/pages`);
+    if (wikiCheck.status < 400) {
+        const wikiRes = await client.post(`/repos/${owner}/${repo}/push_mirrors`, {
+            remote_address: `https://github.com/${ghOrg}/${repo}.wiki.git`,
+            remote_username: ghOrg,
+            remote_password: ghToken,
+            interval: syncInterval,
+            sync_on_commit: true,
+        });
+        if (wikiRes.status >= 400) {
+            const err = wikiRes.data;
+            results.push(`Wiki mirror: ${err?.message ?? `failed (${wikiRes.status})`}`);
+        }
+        else {
+            results.push(`Wiki mirror configured: ${ghOrg}/${repo}.wiki.git`);
+        }
+    }
+    else {
+        results.push('Wiki mirror skipped: no wiki pages found');
+    }
+    // 5. Trigger initial sync
+    await client.post(`/repos/${owner}/${repo}/mirror-sync`, {});
+    results.push('Initial sync triggered');
+    return { content: [{ type: 'text', text: results.join('\n') }] };
+});
+// ── Repo Statistics ─────────────────────────────────────────────────────
+server.tool('gitea_repo_languages', 'Get language breakdown for a repository', { ...OwnerRepo, ...ConnectionParam }, async ({ owner, repo, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/languages`)));
+server.tool('gitea_repo_contributors', 'List contributors with commit counts', { ...OwnerRepo, ...ConnectionParam }, async ({ owner, repo, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/contributors`)));
+// ── Issue Labels (Bulk) ─────────────────────────────────────────────────
+server.tool('gitea_issue_labels_set', 'Set labels on an issue (replaces existing)', {
+    ...OwnerRepo,
+    number: z.number().describe('Issue/PR number'),
+    labels: z.array(z.union([z.number(), z.string()])).describe('Label IDs or names to set (use gitea_labels_list to discover available labels)'),
+    ...ConnectionParam,
+}, async ({ owner, repo, number, labels, connection }) => formatResponse(await clientFor(connection).put(`/repos/${owner}/${repo}/issues/${number}/labels`, { labels })));
+// ── Diff / Compare ──────────────────────────────────────────────────────
+server.tool('gitea_compare', 'Compare two branches, tags, or commits (returns diff stats)', {
+    ...OwnerRepo,
+    base: z.string().describe('Base branch/tag/SHA'),
+    head: z.string().describe('Head branch/tag/SHA'),
+    ...ConnectionParam,
+}, async ({ owner, repo, base, head, connection }) => formatResponse(await clientFor(connection).get(`/repos/${owner}/${repo}/compare/${base}...${head}`)));
+// ── Gitea Admin (Instance-Level) ────────────────────────────────────────
+server.tool('gitea_admin_orgs_list', 'List all organizations (admin only)', { ...PaginationParams, ...ConnectionParam }, async ({ page, limit, connection }) => formatResponse(await clientFor(connection).get('/admin/orgs', pageQuery({ page, limit }))));
+server.tool('gitea_admin_users_list', 'List all users (admin only)', { ...PaginationParams, ...ConnectionParam }, async ({ page, limit, connection }) => formatResponse(await clientFor(connection).get('/admin/users', pageQuery({ page, limit }))));
+server.tool('gitea_admin_cron_list', 'List cron tasks and their last run time (admin only)', { ...ConnectionParam }, async ({ connection }) => formatResponse(await clientFor(connection).get('/admin/cron')));
+server.tool('gitea_admin_cron_run', 'Trigger a cron task (admin only)', {
+    task: z.string().describe('Cron task name (e.g. "repo_health_check", "resync_all_hooks", "repo_archive_cleanup")'),
+    ...ConnectionParam,
+}, async ({ task, connection }) => formatResponse(await clientFor(connection).post(`/admin/cron/${task}`, {})));
+// ── Generic API Call ────────────────────────────────────────────────────
+server.tool('gitea_api_request', 'Make a raw API request to any Gitea v1 endpoint', {
+    method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']).describe('HTTP method'),
+    endpoint: z.string().describe('API endpoint path (e.g. "/repos/owner/repo")'),
+    body: z.record(z.string(), z.unknown()).optional().describe('Request body'),
+    params: z.record(z.string(), z.string()).optional().describe('Query parameters'),
+    ...ConnectionParam,
+}, async ({ method, endpoint, body, params, connection }) => {
+    const client = clientFor(connection);
+    switch (method) {
+        case 'GET': return formatResponse(await client.get(endpoint, params));
+        case 'POST': return formatResponse(await client.post(endpoint, body));
+        case 'PUT': return formatResponse(await client.put(endpoint, body));
+        case 'PATCH': return formatResponse(await client.patch(endpoint, body));
+        case 'DELETE': return formatResponse(await client.delete(endpoint, body));
+    }
+});
+// ── Connections ──────────────────────────────────────────────────────────
+server.tool('gitea_list_connections', 'List configured Gitea connections', {}, async () => {
+    const lines = Object.entries(config.connections).map(([name, conn]) => {
+        const is_default = name === config.defaultConnection ? ' (default)' : '';
+        return `  ${name}${is_default}: ${conn.baseUrl}`;
+    });
+    return { content: [{ type: 'text', text: `Configured connections:\n${lines.join('\n')}` }] };
+});
+// ── Manifest ────────────────────────────────────────────────────────────
+server.tool('gitea_manifest_get', 'Get manifest settings for a repository (identity, governance, distribution, build metadata)', {
+    owner: z.string().describe('Repository owner'),
+    repo: z.string().describe('Repository name'),
+    ...ConnectionParam,
+}, async ({ owner, repo, connection }) => {
+    const c = clientFor(connection);
+    return formatResponse(await c.get(`/repos/${owner}/${repo}/manifest`));
+});
+server.tool('gitea_manifest_update', 'Update manifest settings for a repository', {
+    owner: z.string().describe('Repository owner'),
+    repo: z.string().describe('Repository name'),
+    name: z.string().optional().describe('Project name (Joomla: base element name, e.g. mokowaas)'),
+    org: z.string().optional().describe('Organization'),
+    description: z.string().optional().describe('Project description'),
+    version: z.string().optional().describe('Version string (e.g. 06.00.00)'),
+    version_prefix: z.string().optional().describe('Tag prefix for version display (e.g. v1.26.1-moko.)'),
+    element_name: z.string().optional().describe('Full element name override (e.g. pkg_mokowaas). Auto-constructed from type + name if empty.'),
+    license_spdx: z.string().optional().describe('SPDX license identifier'),
+    license_name: z.string().optional().describe('Human-readable license name'),
+    platform: z.string().optional().describe('Platform (joomla, wordpress, dolibarr, go, mcp, platform, generic)'),
+    standards_version: z.string().optional().describe('MokoPlatform standards version'),
+    standards_source: z.string().optional().describe('URL to standards repo'),
+    display_name: z.string().optional().describe('Human-readable name for update feeds (e.g. Package - MokoWaaS)'),
+    maintainer: z.string().optional().describe('Maintainer/author name'),
+    maintainer_url: z.string().optional().describe('Maintainer website URL'),
+    info_url: z.string().optional().describe('Extension info/product page URL'),
+    target_version: z.string().optional().describe('Target platform version regex (e.g. (5|6)\\.*)'),
+    php_minimum: z.string().optional().describe('Minimum PHP version (e.g. 8.1)'),
+    language: z.string().optional().describe('Primary language (Go, PHP, TypeScript, etc.)'),
+    package_type: z.string().optional().describe('Package type (application, library, component, module, plugin, package, template, file)'),
+    entry_point: z.string().optional().describe('Build entry point path'),
+    ...ConnectionParam,
+}, async ({ owner, repo, connection, ...fields }) => {
+    const c = clientFor(connection);
+    const current = await c.get(`/repos/${owner}/${repo}/manifest`);
+    const merged = { ...current.data };
+    for (const [k, v] of Object.entries(fields)) {
+        if (v !== undefined)
+            merged[k] = v;
+    }
+    return formatResponse(await c.put(`/repos/${owner}/${repo}/manifest`, merged));
+});
+// ── Start Server ────────────────────────────────────────────────────────
+async function main() {
+    config = await loadConfig();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    process.stderr.write(`Fatal: ${err}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map