@zierocode/mcp-atlassian-cloud 2.6.1

package/dist/index.js

@@ -0,0 +1,1833 @@
+import crypto from "node:crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+import { AtlassianManager } from "./atlassian.js";
+import { z } from "zod";
+const app = express();
+app.use(express.json());
+// CORS middleware for Anthropic domains (required for Claude Desktop/Web)
+app.use((req, res, next) => {
+    const allowedOrigins = [
+        "https://claude.ai",
+        "https://claude.com",
+        "https://www.anthropic.com",
+        "https://api.anthropic.com",
+    ];
+    const origin = req.headers.origin;
+    if (origin && allowedOrigins.includes(origin)) {
+        res.setHeader("Access-Control-Allow-Origin", origin);
+    }
+    res.setHeader("Access-Control-Allow-Credentials", "true");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, HEAD");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Api-Key, Mcp-Session-Id, Accept");
+    res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id, Mcp-Protocol-Version");
+    if (req.method === "OPTIONS") {
+        res.status(204).end();
+        return;
+    }
+    next();
+});
+const CLIENT_API_KEY = process.env.CLIENT_API_KEY;
+// ============================================================
+// ATLASSIAN OAUTH 2.0 CONFIGURATION
+// ============================================================
+const ATLASSIAN_CLIENT_ID = process.env.ATLASSIAN_CLIENT_ID;
+const ATLASSIAN_CLIENT_SECRET = process.env.ATLASSIAN_CLIENT_SECRET;
+const OAUTH_CALLBACK_URL = process.env.OAUTH_CALLBACK_URL || "https://atlassian-mcp-793556042663.asia-southeast1.run.app/oauth/callback";
+const oauthTokens = new Map();
+const pendingOAuthStates = new Map();
+const authorizationCodes = new Map();
+// Cleanup expired states every 10 minutes
+setInterval(() => {
+    const now = Date.now();
+    for (const [state, data] of pendingOAuthStates) {
+        if (now - data.createdAt > 10 * 60 * 1000) {
+            pendingOAuthStates.delete(state);
+        }
+    }
+}, 10 * 60 * 1000);
+// Timing-safe API key comparison to prevent timing attacks
+function timingSafeEqual(a, b) {
+    if (a.length !== b.length) {
+        crypto.timingSafeEqual(Buffer.from(a), Buffer.from(a));
+        return false;
+    }
+    return crypto.timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+// Authentication middleware - supports both X-Api-Key and OAuth tokens
+const authenticate = (req, res, next) => {
+    const apiKey = req.headers["x-api-key"];
+    const oauthToken = req.headers["x-oauth-token"] ||
+        req.headers.authorization?.replace("Bearer ", "");
+    // Check OAuth token first
+    if (oauthToken) {
+        const oauthData = oauthTokens.get(oauthToken);
+        if (oauthData) {
+            // Check if token is expired
+            if (Date.now() > oauthData.expiresAt) {
+                res.status(401).json({ error: "OAuth token expired, please refresh or re-authenticate" });
+                return;
+            }
+            // Attach OAuth data to request for later use
+            req.oauth = oauthData;
+            next();
+            return;
+        }
+    }
+    // Fall back to API key authentication
+    if (!CLIENT_API_KEY) {
+        // No auth configured, allow all
+        next();
+        return;
+    }
+    if (typeof apiKey === "string" && timingSafeEqual(apiKey, CLIENT_API_KEY)) {
+        next();
+        return;
+    }
+    // Include WWW-Authenticate header to tell clients where to authenticate (RFC 9728)
+    const proto = req.headers["x-forwarded-proto"] || req.protocol || "https";
+    const host = req.headers["x-forwarded-host"] || req.headers.host || "localhost:8080";
+    const baseUrl = `${proto}://${host}`;
+    res.setHeader("WWW-Authenticate", `Bearer realm="mcp", resource_metadata="${baseUrl}/.well-known/oauth-authorization-server"`);
+    res.status(401).json({ error: "unauthorized", message: "Bearer token required for MCP access" });
+};
+// Store active transports for session management
+const sessions = new Map();
+const rateLimitMap = new Map();
+const RATE_LIMIT_WINDOW_MS = 60 * 1000; // 1 minute
+const RATE_LIMIT_MAX_REQUESTS = 100;
+// Cleanup old entries every 5 minutes
+setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of rateLimitMap) {
+        if (now > entry.resetAt) {
+            rateLimitMap.delete(key);
+        }
+    }
+}, 5 * 60 * 1000);
+const rateLimit = (req, res, next) => {
+    // Use API key or IP as identifier
+    const clientId = req.headers["x-api-key"] || req.ip || "unknown";
+    const now = Date.now();
+    let entry = rateLimitMap.get(clientId);
+    if (!entry || now > entry.resetAt) {
+        // New window
+        entry = { count: 1, resetAt: now + RATE_LIMIT_WINDOW_MS };
+        rateLimitMap.set(clientId, entry);
+    }
+    else {
+        entry.count++;
+    }
+    // Set rate limit headers
+    res.setHeader("X-RateLimit-Limit", RATE_LIMIT_MAX_REQUESTS);
+    res.setHeader("X-RateLimit-Remaining", Math.max(0, RATE_LIMIT_MAX_REQUESTS - entry.count));
+    res.setHeader("X-RateLimit-Reset", Math.ceil(entry.resetAt / 1000));
+    if (entry.count > RATE_LIMIT_MAX_REQUESTS) {
+        res.status(429).json({
+            error: "Too Many Requests",
+            message: `Rate limit exceeded. Max ${RATE_LIMIT_MAX_REQUESTS} requests per minute.`,
+            retryAfter: Math.ceil((entry.resetAt - now) / 1000),
+        });
+        return;
+    }
+    next();
+};
+// ============================================================
+// COMMON ZOD SCHEMAS
+// ============================================================
+const issueKeySchema = z
+    .string()
+    .regex(/^[A-Z][A-Z0-9]*-\d+$/i, "Invalid issue key format (expected: ABC-123)")
+    .describe("The Jira issue key (e.g., ABC-123)");
+const projectKeySchema = z
+    .string()
+    .regex(/^[A-Z][A-Z0-9]*$/i, "Invalid project key format")
+    .describe("The Jira project key (e.g., PROJ)");
+const maxResultsSchema = (defaultVal, max) => z.number().min(1).max(max).optional().default(defaultVal);
+// ============================================================
+// ADF (Atlassian Document Format) SCHEMAS
+// ============================================================
+/**
+ * Schema for raw ADF nodes (panels, status, emoji, mention, etc.)
+ * Using passthrough to allow any valid ADF structure
+ * See: https://developer.atlassian.com/cloud/jira/platform/apis/document/structure/
+ */
+const adfNodeSchema = z.record(z.string(), z.unknown()).describe("ADF node (panel, status, emoji, etc.)");
+/**
+ * Schema for a complete ADF document
+ */
+const adfDocumentSchema = z.object({
+    type: z.literal("doc"),
+    version: z.literal(1),
+    content: z.array(adfNodeSchema),
+}).describe("Complete ADF document");
+/**
+ * Schema for description blocks (hybrid Markdown + ADF)
+ * Allows mixing simple Markdown with complex Jira-specific ADF nodes
+ */
+const descriptionBlockSchema = z.union([
+    z.object({ markdown: z.string().describe("Markdown text (converted to ADF)") }),
+    z.object({ adf: adfNodeSchema }),
+]).describe("A block that can be either Markdown or raw ADF");
+/**
+ * Format issue search results based on response_mode
+ * - keys_only: Just issue keys (smallest response)
+ * - summary: Essential fields only (key, summary, status, assignee, priority, type)
+ * - full: All fields (original behavior)
+ */
+function formatIssueResponse(data, response_mode = "summary") {
+    if (response_mode === "keys_only") {
+        const keys = data.issues.map(i => i.key);
+        return {
+            content: [{ type: "text", text: `Found ${data.total} issues: ${keys.join(", ")}` }],
+        };
+    }
+    const issues = data.issues.map(issue => {
+        if (response_mode === "summary") {
+            return {
+                key: issue.key,
+                summary: issue.fields.summary,
+                status: issue.fields.status?.name,
+                assignee: issue.fields.assignee?.displayName || null,
+                priority: issue.fields.priority?.name,
+                type: issue.fields.issuetype?.name,
+            };
+        }
+        return issue; // full mode
+    });
+    return {
+        content: [
+            { type: "text", text: `Found ${data.total} issues (showing ${data.issues.length})` },
+            { type: "text", text: JSON.stringify({ total: data.total, issues }, null, 2) },
+        ],
+    };
+}
+// ============================================================
+// CREATE MCP SERVER WITH ALL TOOLS
+// ============================================================
+export function createMcpServer() {
+    const atlassian = new AtlassianManager();
+    const mcpServer = new McpServer({
+        name: "atlassian-mcp-cloud",
+        version: "2.0.0",
+    });
+    // ============================================================
+    // ISSUE TOOLS - CRUD
+    // ============================================================
+    mcpServer.registerTool("get_jira_issue", {
+        description: "Get details of a Jira issue by key (e.g., PROJ-123)",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+        }),
+    }, async ({ issueKey }) => {
+        const data = await atlassian.getJiraIssue(issueKey);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("search_jira_issues", {
+        description: "Search issues using JQL",
+        inputSchema: z.object({
+            jql: z.string().min(1).max(5000).describe("JQL query"),
+            maxResults: maxResultsSchema(20, 50),
+            fields: z.array(z.string()).optional().describe("Specific fields to return"),
+            response_mode: z.enum(["full", "summary", "keys_only"]).optional().default("summary").describe("full=all, summary=essential, keys_only=just keys"),
+        }),
+    }, async ({ jql, maxResults, fields, response_mode }) => {
+        // Optimize API request based on response_mode
+        const effectiveFields = fields ?? (response_mode === "keys_only" ? ["key"] :
+            response_mode === "summary" ? ["key", "summary", "status", "assignee", "priority", "issuetype"] : undefined);
+        const data = await atlassian.searchIssues(jql, maxResults, effectiveFields);
+        return formatIssueResponse(data, response_mode);
+    });
+    mcpServer.registerTool("create_jira_issue", {
+        description: "Create Jira issue. Description formats: description (markdown), description_adf (raw ADF), description_blocks (mix). For panels/status/emoji use ADF.",
+        inputSchema: z.object({
+            projectKey: projectKeySchema,
+            issueType: z.string().describe("Issue type (e.g., Task, Bug, Story, Epic)"),
+            summary: z.string().min(1).max(255).describe("Issue summary/title"),
+            description: z.string().optional().describe("Issue description (Markdown)"),
+            description_adf: adfDocumentSchema.optional().describe("Raw ADF document (full control)"),
+            description_blocks: z.array(descriptionBlockSchema).optional().describe("Mix of Markdown and ADF blocks"),
+            assignee: z.string().optional().describe("Assignee account ID"),
+            priority: z.string().optional().describe("Priority (Highest, High, Medium, Low, Lowest)"),
+            labels: z.array(z.string()).optional().describe("Labels to add"),
+            components: z.array(z.string()).optional().describe("Component names"),
+            parentKey: z.string().optional().describe("Parent issue key (for subtasks)"),
+        }),
+    }, async (params) => {
+        const data = await atlassian.createIssue(params);
+        return {
+            content: [
+                { type: "text", text: `Created issue: ${data.key}` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("update_jira_issue", {
+        description: "Update Jira issue fields. Same description formats as create_jira_issue.",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            summary: z.string().min(1).max(255).optional().describe("New summary"),
+            description: z.string().optional().describe("New description (Markdown)"),
+            description_adf: adfDocumentSchema.optional().describe("Raw ADF document (full control)"),
+            description_blocks: z.array(descriptionBlockSchema).optional().describe("Mix of Markdown and ADF blocks"),
+            assignee: z.string().optional().describe("New assignee (empty to unassign)"),
+            priority: z.string().optional().describe("New priority"),
+            labels: z.array(z.string()).optional().describe("New labels (replaces existing)"),
+            components: z.array(z.string()).optional().describe("New components (replaces existing)"),
+        }),
+    }, async ({ issueKey, ...params }) => {
+        await atlassian.updateIssue(issueKey, params);
+        return {
+            content: [{ type: "text", text: `Issue ${issueKey} updated successfully` }],
+        };
+    });
+    mcpServer.registerTool("delete_jira_issue", {
+        description: "Delete a Jira issue (use with caution!)",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            deleteSubtasks: z.boolean().optional().default(false).describe("Also delete subtasks"),
+        }),
+    }, async ({ issueKey, deleteSubtasks }) => {
+        await atlassian.deleteIssue(issueKey, deleteSubtasks);
+        return {
+            content: [{ type: "text", text: `Issue ${issueKey} deleted successfully` }],
+        };
+    });
+    mcpServer.registerTool("bulk_create_issues", {
+        description: "Create multiple Jira issues at once (max 50)",
+        inputSchema: z.object({
+            issues: z.array(z.object({
+                projectKey: projectKeySchema,
+                issueType: z.string(),
+                summary: z.string().min(1).max(255),
+                description: z.string().optional(),
+                assignee: z.string().optional(),
+                priority: z.string().optional(),
+                labels: z.array(z.string()).optional(),
+                parentKey: z.string().optional(),
+            })).min(1).max(50).describe("Array of issues to create"),
+        }),
+    }, async ({ issues }) => {
+        const data = await atlassian.bulkCreateIssues(issues);
+        return {
+            content: [
+                { type: "text", text: `Created ${data.issues.length} issues, ${data.errors.length} errors` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    // ============================================================
+    // ISSUE TOOLS - TRANSITIONS & ASSIGNMENT
+    // ============================================================
+    mcpServer.registerTool("get_issue_transitions", {
+        description: "Get available status transitions for an issue (To Do → In Progress, etc.)",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+        }),
+    }, async ({ issueKey }) => {
+        const data = await atlassian.getIssueTransitions(issueKey);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} available transitions` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("transition_jira_issue", {
+        description: "Transition a Jira issue to a new status (e.g., To Do → In Progress). Use get_issue_transitions first to find the transition ID.",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            transitionId: z.string().describe("Transition ID (from get_issue_transitions)"),
+            comment: z.string().optional().describe("Optional comment for the transition"),
+        }),
+    }, async ({ issueKey, transitionId, comment }) => {
+        await atlassian.transitionIssue(issueKey, transitionId, comment);
+        return {
+            content: [{ type: "text", text: `Issue ${issueKey} transitioned successfully` }],
+        };
+    });
+    mcpServer.registerTool("assign_jira_issue", {
+        description: "Assign a Jira issue to a user",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            accountId: z.string().nullable().describe("User account ID (null to unassign)"),
+        }),
+    }, async ({ issueKey, accountId }) => {
+        await atlassian.assignIssue(issueKey, accountId);
+        const action = accountId ? "assigned" : "unassigned";
+        return {
+            content: [{ type: "text", text: `Issue ${issueKey} ${action} successfully` }],
+        };
+    });
+    // ============================================================
+    // COMMENT TOOLS
+    // ============================================================
+    mcpServer.registerTool("get_issue_comments", {
+        description: "Get comments on a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            maxResults: maxResultsSchema(50, 100).describe("Maximum comments to return"),
+        }),
+    }, async ({ issueKey, maxResults }) => {
+        const data = await atlassian.getIssueComments(issueKey, maxResults);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.total} comments (showing ${data.comments.length})` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("add_issue_comment", {
+        description: "Add a comment to a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            body: z.string().min(1).describe("Comment text"),
+        }),
+    }, async ({ issueKey, body }) => {
+        const data = await atlassian.addIssueComment(issueKey, body);
+        return {
+            content: [
+                { type: "text", text: `Comment added to ${issueKey}` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("update_issue_comment", {
+        description: "Update an existing comment on a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            commentId: z.string().describe("Comment ID to update"),
+            body: z.string().min(1).describe("New comment text"),
+        }),
+    }, async ({ issueKey, commentId, body }) => {
+        const data = await atlassian.updateIssueComment(issueKey, commentId, body);
+        return {
+            content: [
+                { type: "text", text: `Comment ${commentId} updated` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("delete_issue_comment", {
+        description: "Delete a comment from a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            commentId: z.string().describe("Comment ID to delete"),
+        }),
+    }, async ({ issueKey, commentId }) => {
+        await atlassian.deleteIssueComment(issueKey, commentId);
+        return {
+            content: [{ type: "text", text: `Comment ${commentId} deleted from ${issueKey}` }],
+        };
+    });
+    // ============================================================
+    // WORKLOG TOOLS
+    // ============================================================
+    mcpServer.registerTool("get_issue_worklogs", {
+        description: "Get time tracking worklogs for a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            maxResults: maxResultsSchema(50, 100),
+        }),
+    }, async ({ issueKey, maxResults }) => {
+        const data = await atlassian.getIssueWorklogs(issueKey, maxResults);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.total} worklogs (showing ${data.worklogs.length})` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("add_worklog", {
+        description: "Add a worklog entry (time tracking) to a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            timeSpent: z.string().describe("Time spent (e.g., '2h 30m', '1d', '30m')"),
+            comment: z.string().optional().describe("Work description"),
+            started: z.string().optional().describe("Start time (ISO 8601 format)"),
+        }),
+    }, async ({ issueKey, timeSpent, comment, started }) => {
+        const data = await atlassian.addWorklog(issueKey, timeSpent, comment, started);
+        return {
+            content: [
+                { type: "text", text: `Worklog added to ${issueKey}: ${timeSpent}` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("update_worklog", {
+        description: "Update an existing worklog entry",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            worklogId: z.string().describe("Worklog ID to update"),
+            timeSpent: z.string().describe("New time spent"),
+            comment: z.string().optional().describe("New work description"),
+        }),
+    }, async ({ issueKey, worklogId, timeSpent, comment }) => {
+        const data = await atlassian.updateWorklog(issueKey, worklogId, timeSpent, comment);
+        return {
+            content: [
+                { type: "text", text: `Worklog ${worklogId} updated` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("delete_worklog", {
+        description: "Delete a worklog entry from a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            worklogId: z.string().describe("Worklog ID to delete"),
+        }),
+    }, async ({ issueKey, worklogId }) => {
+        await atlassian.deleteWorklog(issueKey, worklogId);
+        return {
+            content: [{ type: "text", text: `Worklog ${worklogId} deleted from ${issueKey}` }],
+        };
+    });
+    // ============================================================
+    // ATTACHMENT TOOLS
+    // ============================================================
+    mcpServer.registerTool("delete_attachment", {
+        description: "Delete an attachment from Jira",
+        inputSchema: z.object({
+            attachmentId: z.string().describe("Attachment ID to delete"),
+        }),
+    }, async ({ attachmentId }) => {
+        await atlassian.deleteAttachment(attachmentId);
+        return {
+            content: [{ type: "text", text: `Attachment ${attachmentId} deleted` }],
+        };
+    });
+    mcpServer.registerTool("get_attachment_content", {
+        description: "Get attachment content (base64 encoded)",
+        inputSchema: z.object({
+            attachmentId: z.string().describe("Attachment ID"),
+        }),
+    }, async ({ attachmentId }) => {
+        const data = await atlassian.getAttachmentContent(attachmentId);
+        return {
+            content: [
+                { type: "text", text: `Attachment: ${data.filename}` },
+                { type: "text", text: `Content (base64): ${data.content.substring(0, 100)}...` },
+            ],
+        };
+    });
+    // ============================================================
+    // ISSUE LINK TOOLS
+    // ============================================================
+    mcpServer.registerTool("link_issues", {
+        description: "Create a link between two Jira issues",
+        inputSchema: z.object({
+            inwardIssueKey: issueKeySchema.describe("Source issue key"),
+            outwardIssueKey: issueKeySchema.describe("Target issue key"),
+            linkType: z.string().describe("Link type (e.g., 'Blocks', 'Relates', 'Duplicates')"),
+        }),
+    }, async ({ inwardIssueKey, outwardIssueKey, linkType }) => {
+        await atlassian.linkIssues(inwardIssueKey, outwardIssueKey, linkType);
+        return {
+            content: [{ type: "text", text: `Linked ${inwardIssueKey} → ${outwardIssueKey} (${linkType})` }],
+        };
+    });
+    mcpServer.registerTool("delete_issue_link", {
+        description: "Delete a link between issues",
+        inputSchema: z.object({
+            linkId: z.string().describe("Issue link ID to delete"),
+        }),
+    }, async ({ linkId }) => {
+        await atlassian.deleteIssueLink(linkId);
+        return {
+            content: [{ type: "text", text: `Issue link ${linkId} deleted` }],
+        };
+    });
+    mcpServer.registerTool("get_issue_link_types", {
+        description: "Get all available issue link types",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getIssueLinkTypes();
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} link types` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    // ============================================================
+    // WATCHER TOOLS
+    // ============================================================
+    mcpServer.registerTool("get_issue_watchers", {
+        description: "Get watchers of a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+        }),
+    }, async ({ issueKey }) => {
+        const data = await atlassian.getIssueWatchers(issueKey);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.watchers.length} watchers` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("add_watcher", {
+        description: "Add a watcher to a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            accountId: z.string().describe("User account ID to add as watcher"),
+        }),
+    }, async ({ issueKey, accountId }) => {
+        await atlassian.addWatcher(issueKey, accountId);
+        return {
+            content: [{ type: "text", text: `Watcher added to ${issueKey}` }],
+        };
+    });
+    mcpServer.registerTool("remove_watcher", {
+        description: "Remove a watcher from a Jira issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            accountId: z.string().describe("User account ID to remove"),
+        }),
+    }, async ({ issueKey, accountId }) => {
+        await atlassian.removeWatcher(issueKey, accountId);
+        return {
+            content: [{ type: "text", text: `Watcher removed from ${issueKey}` }],
+        };
+    });
+    // ============================================================
+    // PROJECT TOOLS
+    // ============================================================
+    mcpServer.registerTool("list_projects", {
+        description: "List Jira projects",
+        inputSchema: z.object({
+            maxResults: maxResultsSchema(50, 100),
+            response_mode: z.enum(["full", "summary", "keys_only"]).optional().default("summary").describe("full=all fields, summary=key+name, keys_only=just keys"),
+        }),
+    }, async ({ maxResults, response_mode }) => {
+        const data = await atlassian.listProjects(maxResults);
+        if (response_mode === "keys_only") {
+            const keys = data.map((p) => p.key);
+            return {
+                content: [{ type: "text", text: `Projects: ${keys.join(", ")}` }],
+            };
+        }
+        if (response_mode === "summary") {
+            const projects = data.map((p) => ({
+                key: p.key,
+                name: p.name,
+                type: p.projectTypeKey,
+            }));
+            return {
+                content: [{ type: "text", text: JSON.stringify({ count: projects.length, projects }, null, 2) }],
+            };
+        }
+        // full mode
+        return {
+            content: [{ type: "text", text: JSON.stringify({ count: data.length, projects: data }, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("get_project", {
+        description: "Get details of a Jira project",
+        inputSchema: z.object({
+            projectKey: projectKeySchema,
+        }),
+    }, async ({ projectKey }) => {
+        const data = await atlassian.getProject(projectKey);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("get_project_components", {
+        description: "Get components of a Jira project",
+        inputSchema: z.object({
+            projectKey: projectKeySchema,
+        }),
+    }, async ({ projectKey }) => {
+        const data = await atlassian.getProjectComponents(projectKey);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} components` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_project_versions", {
+        description: "Get versions/releases of a Jira project",
+        inputSchema: z.object({
+            projectKey: projectKeySchema,
+        }),
+    }, async ({ projectKey }) => {
+        const data = await atlassian.getProjectVersions(projectKey);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} versions` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_project_statuses", {
+        description: "Get available statuses in a Jira project",
+        inputSchema: z.object({
+            projectKey: projectKeySchema,
+        }),
+    }, async ({ projectKey }) => {
+        const data = await atlassian.getProjectStatuses(projectKey);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} statuses` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("create_project_version", {
+        description: "Create a new version/release in a Jira project",
+        inputSchema: z.object({
+            projectKey: projectKeySchema,
+            name: z.string().describe("Version name (e.g., '1.0.0')"),
+            description: z.string().optional().describe("Version description"),
+            releaseDate: z.string().optional().describe("Release date (YYYY-MM-DD)"),
+            startDate: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+        }),
+    }, async ({ projectKey, name, description, releaseDate, startDate }) => {
+        const data = await atlassian.createProjectVersion(projectKey, name, description, releaseDate, startDate);
+        return {
+            content: [
+                { type: "text", text: `Version '${name}' created in ${projectKey}` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("create_project_component", {
+        description: "Create a new component in a Jira project",
+        inputSchema: z.object({
+            projectKey: projectKeySchema,
+            name: z.string().describe("Component name"),
+            description: z.string().optional().describe("Component description"),
+            leadAccountId: z.string().optional().describe("Component lead account ID"),
+        }),
+    }, async ({ projectKey, name, description, leadAccountId }) => {
+        const data = await atlassian.createProjectComponent(projectKey, name, description, leadAccountId);
+        return {
+            content: [
+                { type: "text", text: `Component '${name}' created in ${projectKey}` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    // ============================================================
+    // USER TOOLS
+    // ============================================================
+    mcpServer.registerTool("search_users", {
+        description: "Search for Jira users by name or email",
+        inputSchema: z.object({
+            query: z.string().min(1).describe("Search query"),
+            maxResults: maxResultsSchema(20, 50),
+        }),
+    }, async ({ query, maxResults }) => {
+        const data = await atlassian.searchUsers(query, maxResults);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} users` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_current_user", {
+        description: "Get information about the currently authenticated user",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getCurrentUser();
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("get_user", {
+        description: "Get information about a specific user",
+        inputSchema: z.object({
+            accountId: z.string().describe("User account ID"),
+        }),
+    }, async ({ accountId }) => {
+        const data = await atlassian.getUser(accountId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("get_assignable_users", {
+        description: "Get users that can be assigned to issues in a project",
+        inputSchema: z.object({
+            projectKey: projectKeySchema,
+            issueKey: issueKeySchema.optional().describe("Specific issue to check assignability"),
+            maxResults: maxResultsSchema(50, 100),
+        }),
+    }, async ({ projectKey, issueKey, maxResults }) => {
+        const data = await atlassian.getAssignableUsers(projectKey, issueKey, maxResults);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} assignable users` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    // ============================================================
+    // AGILE - BOARD TOOLS
+    // ============================================================
+    mcpServer.registerTool("list_boards", {
+        description: "List Jira agile boards (Scrum/Kanban)",
+        inputSchema: z.object({
+            projectKeyOrId: z.string().optional().describe("Filter by project"),
+            type: z.enum(["scrum", "kanban"]).optional().describe("Board type filter"),
+            maxResults: maxResultsSchema(50, 100),
+        }),
+    }, async ({ projectKeyOrId, type, maxResults }) => {
+        const data = await atlassian.listBoards(projectKeyOrId, type, maxResults);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} boards` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_board", {
+        description: "Get details of a Jira agile board",
+        inputSchema: z.object({
+            boardId: z.number().describe("Board ID"),
+        }),
+    }, async ({ boardId }) => {
+        const data = await atlassian.getBoard(boardId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("get_board_issues", {
+        description: "Get issues on a board",
+        inputSchema: z.object({
+            boardId: z.number().describe("Board ID"),
+            jql: z.string().optional().describe("Additional JQL filter"),
+            maxResults: maxResultsSchema(50, 100),
+            response_mode: z.enum(["full", "summary", "keys_only"]).optional().default("summary"),
+        }),
+    }, async ({ boardId, jql, maxResults, response_mode }) => {
+        const data = await atlassian.getBoardIssues(boardId, jql, maxResults);
+        return formatIssueResponse(data, response_mode);
+    });
+    mcpServer.registerTool("get_backlog_issues", {
+        description: "Get backlog issues",
+        inputSchema: z.object({
+            boardId: z.number().describe("Board ID"),
+            maxResults: maxResultsSchema(50, 100),
+            response_mode: z.enum(["full", "summary", "keys_only"]).optional().default("summary"),
+        }),
+    }, async ({ boardId, maxResults, response_mode }) => {
+        const data = await atlassian.getBacklogIssues(boardId, maxResults);
+        return formatIssueResponse(data, response_mode);
+    });
+    // ============================================================
+    // AGILE - SPRINT TOOLS
+    // ============================================================
+    mcpServer.registerTool("list_sprints", {
+        description: "List sprints for a Jira board",
+        inputSchema: z.object({
+            boardId: z.number().describe("Board ID"),
+            state: z.enum(["active", "future", "closed"]).optional().describe("Sprint state filter"),
+            maxResults: maxResultsSchema(50, 100),
+        }),
+    }, async ({ boardId, state, maxResults }) => {
+        const data = await atlassian.listSprints(boardId, state, maxResults);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} sprints` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_sprint", {
+        description: "Get details of a Jira sprint",
+        inputSchema: z.object({
+            sprintId: z.number().describe("Sprint ID"),
+        }),
+    }, async ({ sprintId }) => {
+        const data = await atlassian.getSprint(sprintId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("get_sprint_issues", {
+        description: "Get sprint issues",
+        inputSchema: z.object({
+            sprintId: z.number().describe("Sprint ID"),
+            maxResults: maxResultsSchema(50, 100),
+            response_mode: z.enum(["full", "summary", "keys_only"]).optional().default("summary"),
+        }),
+    }, async ({ sprintId, maxResults, response_mode }) => {
+        const data = await atlassian.getSprintIssues(sprintId, maxResults);
+        return formatIssueResponse(data, response_mode);
+    });
+    mcpServer.registerTool("create_sprint", {
+        description: "Create a new sprint for a Jira board",
+        inputSchema: z.object({
+            boardId: z.number().describe("Board ID"),
+            name: z.string().describe("Sprint name"),
+            goal: z.string().optional().describe("Sprint goal"),
+            startDate: z.string().optional().describe("Start date (ISO 8601)"),
+            endDate: z.string().optional().describe("End date (ISO 8601)"),
+        }),
+    }, async ({ boardId, name, goal, startDate, endDate }) => {
+        const data = await atlassian.createSprint(boardId, name, goal, startDate, endDate);
+        return {
+            content: [
+                { type: "text", text: `Sprint '${name}' created` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("update_sprint", {
+        description: "Update a Jira sprint (name, goal, dates, state)",
+        inputSchema: z.object({
+            sprintId: z.number().describe("Sprint ID"),
+            name: z.string().optional().describe("New sprint name"),
+            goal: z.string().optional().describe("New sprint goal"),
+            state: z.enum(["active", "future", "closed"]).optional().describe("New sprint state"),
+            startDate: z.string().optional().describe("New start date"),
+            endDate: z.string().optional().describe("New end date"),
+        }),
+    }, async ({ sprintId, ...updates }) => {
+        const data = await atlassian.updateSprint(sprintId, updates);
+        return {
+            content: [
+                { type: "text", text: `Sprint ${sprintId} updated` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("move_issues_to_sprint", {
+        description: "Move issues to a sprint",
+        inputSchema: z.object({
+            sprintId: z.number().describe("Target sprint ID"),
+            issueKeys: z.array(issueKeySchema).min(1).describe("Issue keys to move"),
+        }),
+    }, async ({ sprintId, issueKeys }) => {
+        await atlassian.moveIssuesToSprint(sprintId, issueKeys);
+        return {
+            content: [{ type: "text", text: `Moved ${issueKeys.length} issues to sprint ${sprintId}` }],
+        };
+    });
+    // ============================================================
+    // AGILE - EPIC TOOLS
+    // ============================================================
+    mcpServer.registerTool("get_epic", {
+        description: "Get details of a Jira epic",
+        inputSchema: z.object({
+            epicIdOrKey: z.string().describe("Epic ID or issue key"),
+        }),
+    }, async ({ epicIdOrKey }) => {
+        const data = await atlassian.getEpic(epicIdOrKey);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("get_epic_issues", {
+        description: "Get issues belonging to an epic",
+        inputSchema: z.object({
+            epicIdOrKey: z.string().describe("Epic ID or issue key"),
+            maxResults: maxResultsSchema(50, 100),
+            response_mode: z.enum(["full", "summary", "keys_only"]).optional().default("summary"),
+        }),
+    }, async ({ epicIdOrKey, maxResults, response_mode }) => {
+        const data = await atlassian.getEpicIssues(epicIdOrKey, maxResults);
+        return formatIssueResponse(data, response_mode);
+    });
+    mcpServer.registerTool("move_issues_to_epic", {
+        description: "Move issues to an epic",
+        inputSchema: z.object({
+            epicIdOrKey: z.string().describe("Target epic ID or key"),
+            issueKeys: z.array(issueKeySchema).min(1).describe("Issue keys to move"),
+        }),
+    }, async ({ epicIdOrKey, issueKeys }) => {
+        await atlassian.moveIssuesToEpic(epicIdOrKey, issueKeys);
+        return {
+            content: [{ type: "text", text: `Moved ${issueKeys.length} issues to epic ${epicIdOrKey}` }],
+        };
+    });
+    mcpServer.registerTool("remove_issues_from_epic", {
+        description: "Remove issues from their epic",
+        inputSchema: z.object({
+            issueKeys: z.array(issueKeySchema).min(1).describe("Issue keys to remove from epic"),
+        }),
+    }, async ({ issueKeys }) => {
+        await atlassian.removeIssuesFromEpic(issueKeys);
+        return {
+            content: [{ type: "text", text: `Removed ${issueKeys.length} issues from their epics` }],
+        };
+    });
+    // ============================================================
+    // FILTER TOOLS
+    // ============================================================
+    mcpServer.registerTool("get_my_filters", {
+        description: "Get your saved Jira filters",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getMyFilters();
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} filters` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_favorite_filters", {
+        description: "Get your favorite Jira filters",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getFavoriteFilters();
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} favorite filters` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_filter", {
+        description: "Get details of a Jira filter",
+        inputSchema: z.object({
+            filterId: z.string().describe("Filter ID"),
+        }),
+    }, async ({ filterId }) => {
+        const data = await atlassian.getFilter(filterId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("create_filter", {
+        description: "Create a new Jira filter (saved search)",
+        inputSchema: z.object({
+            name: z.string().describe("Filter name"),
+            jql: z.string().describe("JQL query"),
+            description: z.string().optional().describe("Filter description"),
+            favourite: z.boolean().optional().describe("Add to favorites"),
+        }),
+    }, async ({ name, jql, description, favourite }) => {
+        const data = await atlassian.createFilter(name, jql, description, favourite);
+        return {
+            content: [
+                { type: "text", text: `Filter '${name}' created` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    // ============================================================
+    // METADATA TOOLS
+    // ============================================================
+    mcpServer.registerTool("get_fields", {
+        description: "Get all Jira fields (standard and custom)",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getFields();
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} fields` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_issue_types", {
+        description: "Get all Jira issue types",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getIssueTypes();
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} issue types` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_priorities", {
+        description: "Get all Jira priorities",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getPriorities();
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} priorities` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_statuses", {
+        description: "Get all Jira statuses",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getStatuses();
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} statuses` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_resolutions", {
+        description: "Get all Jira resolutions",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getResolutions();
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} resolutions` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("get_labels", {
+        description: "Get Jira labels",
+        inputSchema: z.object({
+            maxResults: z.number().min(1).max(1000).optional().default(100).describe("Max labels to return (default 100)"),
+        }),
+    }, async ({ maxResults }) => {
+        const data = await atlassian.getLabels(maxResults);
+        return {
+            content: [{ type: "text", text: JSON.stringify({ count: data.length, labels: data }, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("get_server_info", {
+        description: "Get Jira server/instance information",
+        inputSchema: z.object({}),
+    }, async () => {
+        const data = await atlassian.getServerInfo();
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    // ============================================================
+    // CACHE MANAGEMENT TOOLS
+    // ============================================================
+    mcpServer.registerTool("get_cache_stats", {
+        description: "Get metadata cache statistics (cached: fields, issue types, priorities, statuses, resolutions)",
+        inputSchema: z.object({}),
+    }, async () => {
+        const stats = atlassian.getMetadataCacheStats();
+        return {
+            content: [{ type: "text", text: JSON.stringify({ cache: stats, ttl: "30 minutes" }, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("clear_metadata_cache", {
+        description: "Clear the metadata cache to force fresh data from Jira (use if you just added new fields/priorities/etc)",
+        inputSchema: z.object({}),
+    }, async () => {
+        const result = atlassian.clearMetadataCache();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // ============================================================
+    // CHANGELOG TOOLS (Cloud only)
+    // ============================================================
+    mcpServer.registerTool("get_issue_changelog", {
+        description: "Get issue change history (Cloud only)",
+        inputSchema: z.object({
+            issueKey: issueKeySchema.describe("The Jira issue key (e.g., PROJ-123)"),
+            maxResults: maxResultsSchema(100, 100).describe("Maximum changelog entries to return"),
+        }),
+    }, async (params) => {
+        const data = await atlassian.getIssueChangelog(params.issueKey, params.maxResults);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("batch_get_changelogs", {
+        description: "Get changelogs for multiple issues (Cloud only, max 50)",
+        inputSchema: z.object({
+            issueKeys: z
+                .array(issueKeySchema)
+                .min(1)
+                .max(50)
+                .describe("Array of issue keys (max 50)"),
+            maxResults: maxResultsSchema(50, 100).describe("Maximum changelog entries per issue"),
+        }),
+    }, async (params) => {
+        const data = await atlassian.batchGetChangelogs(params.issueKeys, params.maxResults);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    mcpServer.registerTool("batch_create_versions", {
+        description: "Create multiple versions in a Jira project at once. Useful for setting up release schedules.",
+        inputSchema: z.object({
+            projectKey: projectKeySchema.describe("The project key"),
+            versions: z
+                .array(z.object({
+                name: z.string().describe("Version name (e.g., 'v1.0.0')"),
+                description: z.string().optional().describe("Version description"),
+                releaseDate: z.string().optional().describe("Release date (YYYY-MM-DD)"),
+                startDate: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+            }))
+                .min(1)
+                .max(50)
+                .describe("Array of versions to create"),
+        }),
+    }, async (params) => {
+        const data = await atlassian.batchCreateVersions(params.projectKey, params.versions);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    // ============================================================
+    // SEARCH FIELDS (fuzzy search) - v2.6
+    // ============================================================
+    mcpServer.registerTool("search_fields", {
+        description: "Search Jira fields by keyword (fuzzy match on name/id). Useful for finding custom field IDs.",
+        inputSchema: z.object({
+            keyword: z.string().min(1).describe("Search keyword (e.g., 'Tech', 'Sprint', 'Story')"),
+            limit: z.number().min(1).max(50).optional().default(10).describe("Max results (default 10)"),
+        }),
+    }, async ({ keyword, limit }) => {
+        const data = await atlassian.searchFields(keyword, limit);
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} fields matching "${keyword}"` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    // ============================================================
+    // REMOTE ISSUE LINKS - v2.6
+    // ============================================================
+    mcpServer.registerTool("create_remote_issue_link", {
+        description: "Create a web link on an issue (to Confluence, docs, external URLs)",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+            url: z.string().url().describe("Target URL (Confluence, docs, etc.)"),
+            title: z.string().min(1).describe("Link title displayed in Jira"),
+            summary: z.string().optional().describe("Optional description"),
+            iconUrl: z.string().url().optional().describe("16x16 icon URL"),
+            relationship: z.string().optional().describe("Relationship type (default: 'relates to')"),
+        }),
+    }, async ({ issueKey, url, title, summary, iconUrl, relationship }) => {
+        const data = await atlassian.createRemoteIssueLink(issueKey, url, title, summary, iconUrl, relationship);
+        return {
+            content: [
+                { type: "text", text: `Remote link created on ${issueKey}` },
+                { type: "text", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    // ============================================================
+    // DOWNLOAD ATTACHMENTS - v2.6
+    // ============================================================
+    mcpServer.registerTool("get_issue_attachments", {
+        description: "List all attachments on an issue",
+        inputSchema: z.object({
+            issueKey: issueKeySchema,
+        }),
+    }, async ({ issueKey }) => {
+        const data = await atlassian.getIssueAttachments(issueKey);
+        const summary = data.map(a => ({
+            id: a.id,
+            filename: a.filename,
+            mimeType: a.mimeType,
+            size: a.size,
+            created: a.created,
+        }));
+        return {
+            content: [
+                { type: "text", text: `Found ${data.length} attachments on ${issueKey}` },
+                { type: "text", text: JSON.stringify(summary, null, 2) },
+            ],
+        };
+    });
+    mcpServer.registerTool("download_attachment", {
+        description: "Download an attachment by ID (returns base64 content)",
+        inputSchema: z.object({
+            attachmentId: z.string().describe("Attachment ID (from get_issue_attachments)"),
+        }),
+    }, async ({ attachmentId }) => {
+        const data = await atlassian.downloadAttachment(attachmentId);
+        return {
+            content: [
+                { type: "text", text: `Downloaded: ${data.filename} (${data.mimeType}, ${data.size} bytes)` },
+                { type: "text", text: JSON.stringify({ filename: data.filename, mimeType: data.mimeType, size: data.size, content_base64: data.content }, null, 2) },
+            ],
+        };
+    });
+    // ============================================================
+    // PROJECT ISSUES (convenience) - v2.6
+    // ============================================================
+    mcpServer.registerTool("get_project_issues", {
+        description: "Get all issues in a project (no JQL needed). Returns issues sorted by created date desc.",
+        inputSchema: z.object({
+            projectKey: projectKeySchema,
+            maxResults: maxResultsSchema(50, 100),
+            response_mode: z.enum(["full", "summary", "keys_only"]).optional().default("summary"),
+        }),
+    }, async ({ projectKey, maxResults, response_mode }) => {
+        const effectiveFields = response_mode === "keys_only" ? ["key"] :
+            response_mode === "summary" ? ["key", "summary", "status", "assignee", "priority", "issuetype"] : undefined;
+        const data = await atlassian.getProjectIssues(projectKey, maxResults, effectiveFields);
+        return formatIssueResponse(data, response_mode);
+    });
+    // ============================================================
+    // LINK ISSUE TO EPIC (convenience) - v2.6
+    // ============================================================
+    mcpServer.registerTool("link_issue_to_epic", {
+        description: "Link a single issue to an epic (convenience wrapper)",
+        inputSchema: z.object({
+            issueKey: issueKeySchema.describe("Issue to link"),
+            epicKey: issueKeySchema.describe("Target epic"),
+        }),
+    }, async ({ issueKey, epicKey }) => {
+        await atlassian.linkIssueToEpic(issueKey, epicKey);
+        return {
+            content: [{ type: "text", text: `Linked ${issueKey} to epic ${epicKey}` }],
+        };
+    });
+    return mcpServer;
+}
+// ============================================================
+// EXPRESS SERVER SETUP
+// ============================================================
+app.get("/health", (_req, res) => {
+    res.status(200).json({
+        status: "healthy",
+        timestamp: new Date().toISOString(),
+        activeSessions: sessions.size,
+        version: "2.6.0",
+        features: {
+            metadataCaching: true,
+            retryWithBackoff: true,
+            rateLimiting: true,
+            oauthSupport: !!ATLASSIAN_CLIENT_ID,
+        },
+    });
+});
+// ============================================================
+// OAUTH 2.0 DISCOVERY ENDPOINTS (RFC 8414 & RFC 9728)
+// ============================================================
+// Get the base URL for the server
+const getBaseUrl = (req) => {
+    const proto = req.headers["x-forwarded-proto"] || req.protocol || "https";
+    const host = req.headers["x-forwarded-host"] || req.headers.host || "localhost:8080";
+    return `${proto}://${host}`;
+};
+// OAuth Authorization Server Metadata (RFC 8414)
+app.get("/.well-known/oauth-authorization-server", (req, res) => {
+    const baseUrl = getBaseUrl(req);
+    res.json({
+        issuer: baseUrl,
+        authorization_endpoint: `${baseUrl}/oauth/authorize`,
+        token_endpoint: `${baseUrl}/oauth/token`,
+        registration_endpoint: `${baseUrl}/oauth/register`,
+        token_endpoint_auth_methods_supported: ["none", "client_secret_post", "client_secret_basic"],
+        response_types_supported: ["code"],
+        grant_types_supported: ["authorization_code", "refresh_token"],
+        scopes_supported: [
+            "read:jira-work",
+            "write:jira-work",
+            "read:jira-user",
+            "manage:jira-project",
+            "read:me",
+            "read:account",
+            "offline_access"
+        ],
+        code_challenge_methods_supported: ["S256", "plain"],
+    });
+});
+// Also serve at /mcp path variant
+app.get("/.well-known/oauth-authorization-server/mcp", (req, res) => {
+    const baseUrl = getBaseUrl(req);
+    res.json({
+        issuer: baseUrl,
+        authorization_endpoint: `${baseUrl}/oauth/authorize`,
+        token_endpoint: `${baseUrl}/oauth/token`,
+        registration_endpoint: `${baseUrl}/oauth/register`,
+        token_endpoint_auth_methods_supported: ["none", "client_secret_post", "client_secret_basic"],
+        response_types_supported: ["code"],
+        grant_types_supported: ["authorization_code", "refresh_token"],
+        scopes_supported: [
+            "read:jira-work",
+            "write:jira-work",
+            "read:jira-user",
+            "manage:jira-project",
+            "read:me",
+            "read:account",
+            "offline_access"
+        ],
+        code_challenge_methods_supported: ["S256", "plain"],
+    });
+});
+// OAuth Protected Resource Metadata (RFC 9728)
+app.get("/.well-known/oauth-protected-resource", (req, res) => {
+    const baseUrl = getBaseUrl(req);
+    res.json({
+        resource: `${baseUrl}/mcp`,
+        authorization_servers: [baseUrl],
+        scopes_supported: [
+            "read:jira-work",
+            "write:jira-work",
+            "read:jira-user",
+            "manage:jira-project"
+        ],
+        bearer_methods_supported: ["header"],
+    });
+});
+// Also serve at /mcp path variant
+app.get("/.well-known/oauth-protected-resource/mcp", (req, res) => {
+    const baseUrl = getBaseUrl(req);
+    res.json({
+        resource: `${baseUrl}/mcp`,
+        authorization_servers: [baseUrl],
+        scopes_supported: [
+            "read:jira-work",
+            "write:jira-work",
+            "read:jira-user",
+            "manage:jira-project"
+        ],
+        bearer_methods_supported: ["header"],
+    });
+});
+// ============================================================
+// OAUTH 2.0 ENDPOINTS
+// ============================================================
+// Dynamic Client Registration (RFC 7591)
+// Allows clients like Claude Desktop to register dynamically
+app.post("/oauth/register", express.json(), (req, res) => {
+    const { client_name, redirect_uris } = req.body;
+    // Generate a client_id for this registration
+    const clientId = `mcp-client-${crypto.randomUUID()}`;
+    console.log(`OAuth: Dynamic client registration - ${client_name}, redirects: ${redirect_uris}`);
+    // Return client credentials (no secret for public clients)
+    res.status(201).json({
+        client_id: clientId,
+        client_name: client_name || "MCP Client",
+        redirect_uris: redirect_uris || [],
+        token_endpoint_auth_method: "none",
+        grant_types: ["authorization_code", "refresh_token"],
+        response_types: ["code"],
+        client_secret_expires_at: 0, // 0 means never expires
+    });
+});
+// Step 1: Redirect user to Atlassian OAuth
+// Accepts Claude Desktop's OAuth parameters: redirect_uri, state, code_challenge, code_challenge_method
+app.get("/oauth/authorize", (req, res) => {
+    if (!ATLASSIAN_CLIENT_ID) {
+        res.status(500).json({ error: "OAuth not configured: ATLASSIAN_CLIENT_ID missing" });
+        return;
+    }
+    // Generate our internal state for CSRF protection with Atlassian
+    const internalState = crypto.randomUUID();
+    // Store Claude's OAuth parameters to use after Atlassian callback
+    const clientRedirectUri = req.query.redirect_uri;
+    const clientState = req.query.state;
+    const codeChallenge = req.query.code_challenge;
+    const codeChallengeMethod = req.query.code_challenge_method;
+    pendingOAuthStates.set(internalState, {
+        createdAt: Date.now(),
+        clientRedirectUri,
+        clientState,
+        codeChallenge,
+        codeChallengeMethod,
+    });
+    console.log(`OAuth: Starting auth flow (internal_state: ${internalState}, client_redirect: ${clientRedirectUri}, client_state: ${clientState})`);
+    const scopes = [
+        "read:jira-work",
+        "write:jira-work",
+        "read:jira-user",
+        "manage:jira-project",
+        "read:me",
+        "read:account",
+        "offline_access"
+    ].join(" ");
+    const authUrl = new URL("https://auth.atlassian.com/authorize");
+    authUrl.searchParams.set("audience", "api.atlassian.com");
+    authUrl.searchParams.set("client_id", ATLASSIAN_CLIENT_ID);
+    authUrl.searchParams.set("scope", scopes);
+    authUrl.searchParams.set("redirect_uri", OAUTH_CALLBACK_URL);
+    authUrl.searchParams.set("state", internalState);
+    authUrl.searchParams.set("response_type", "code");
+    authUrl.searchParams.set("prompt", "consent");
+    console.log(`OAuth: Redirecting to Atlassian`);
+    res.redirect(authUrl.toString());
+});
+// Step 2: Handle OAuth callback from Atlassian
+// After getting Atlassian tokens, generate our authorization code and redirect to Claude
+app.get("/oauth/callback", async (req, res) => {
+    const { code, state, error, error_description } = req.query;
+    if (error) {
+        console.error(`OAuth error: ${error} - ${error_description}`);
+        res.status(400).json({ error: error, description: error_description });
+        return;
+    }
+    if (!code || !state) {
+        res.status(400).json({ error: "Missing code or state parameter" });
+        return;
+    }
+    const pendingState = pendingOAuthStates.get(state);
+    if (!pendingState) {
+        res.status(400).json({ error: "Invalid or expired state parameter" });
+        return;
+    }
+    pendingOAuthStates.delete(state);
+    if (!ATLASSIAN_CLIENT_ID || !ATLASSIAN_CLIENT_SECRET) {
+        res.status(500).json({ error: "OAuth not configured" });
+        return;
+    }
+    try {
+        // Exchange Atlassian code for tokens
+        const tokenResponse = await fetch("https://auth.atlassian.com/oauth/token", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                grant_type: "authorization_code",
+                client_id: ATLASSIAN_CLIENT_ID,
+                client_secret: ATLASSIAN_CLIENT_SECRET,
+                code: code,
+                redirect_uri: OAUTH_CALLBACK_URL,
+            }),
+        });
+        if (!tokenResponse.ok) {
+            const errorData = await tokenResponse.text();
+            console.error("Token exchange failed:", errorData);
+            res.status(400).json({ error: "Token exchange failed", details: errorData });
+            return;
+        }
+        const tokenData = await tokenResponse.json();
+        // Get accessible resources (cloud IDs)
+        const resourcesResponse = await fetch("https://api.atlassian.com/oauth/token/accessible-resources", {
+            headers: { Authorization: `Bearer ${tokenData.access_token}` },
+        });
+        if (!resourcesResponse.ok) {
+            res.status(400).json({ error: "Failed to get accessible resources" });
+            return;
+        }
+        const resources = await resourcesResponse.json();
+        if (resources.length === 0) {
+            res.status(400).json({ error: "No accessible Atlassian sites found" });
+            return;
+        }
+        const firstResource = resources[0];
+        const cloudId = firstResource.id;
+        const siteName = firstResource.name;
+        console.log(`OAuth: Got Atlassian tokens for site ${siteName} (cloudId: ${cloudId})`);
+        // If Claude sent a redirect_uri, we're in OAuth proxy mode
+        // Generate our own authorization code and redirect back to Claude
+        if (pendingState.clientRedirectUri) {
+            const authCode = crypto.randomUUID();
+            // Store the authorization code with the Atlassian tokens
+            authorizationCodes.set(authCode, {
+                createdAt: Date.now(),
+                accessToken: tokenData.access_token,
+                refreshToken: tokenData.refresh_token,
+                expiresIn: tokenData.expires_in,
+                scope: tokenData.scope,
+                cloudId: cloudId,
+                codeChallenge: pendingState.codeChallenge,
+                codeChallengeMethod: pendingState.codeChallengeMethod,
+            });
+            console.log(`OAuth: Generated auth code ${authCode} for client redirect`);
+            // Redirect to Claude's redirect_uri with our code and their original state
+            const redirectUrl = new URL(pendingState.clientRedirectUri);
+            redirectUrl.searchParams.set("code", authCode);
+            if (pendingState.clientState) {
+                redirectUrl.searchParams.set("state", pendingState.clientState);
+            }
+            console.log(`OAuth: Redirecting to client: ${redirectUrl.toString()}`);
+            res.redirect(redirectUrl.toString());
+            return;
+        }
+        // Direct mode (no client redirect): store tokens and return session token
+        const sessionToken = crypto.randomUUID();
+        oauthTokens.set(sessionToken, {
+            accessToken: tokenData.access_token,
+            refreshToken: tokenData.refresh_token,
+            expiresAt: Date.now() + tokenData.expires_in * 1000,
+            cloudId: cloudId,
+            scopes: tokenData.scope.split(" "),
+        });
+        console.log(`OAuth: Token stored for session ${sessionToken} (site: ${siteName})`);
+        res.json({
+            success: true,
+            token: sessionToken,
+            site: siteName,
+            message: "Use this token in the X-OAuth-Token header or Authorization: Bearer header",
+        });
+    }
+    catch (err) {
+        console.error("OAuth callback error:", err);
+        res.status(500).json({ error: "OAuth callback failed", details: String(err) });
+    }
+});
+// Step 3: OAuth Token endpoint - Exchange authorization code for access token
+// This is the standard OAuth2 token endpoint that Claude Desktop calls
+app.post("/oauth/token", express.urlencoded({ extended: true }), async (req, res) => {
+    const grantType = req.body.grant_type;
+    const authCode = req.body.code;
+    const codeVerifier = req.body.code_verifier;
+    const refreshToken = req.body.refresh_token;
+    console.log(`OAuth Token: grant_type=${grantType}, code=${authCode ? 'present' : 'missing'}`);
+    // Handle authorization_code grant
+    if (grantType === "authorization_code") {
+        if (!authCode) {
+            res.status(400).json({ error: "invalid_request", error_description: "Missing authorization code" });
+            return;
+        }
+        const codeData = authorizationCodes.get(authCode);
+        if (!codeData) {
+            res.status(400).json({ error: "invalid_grant", error_description: "Invalid or expired authorization code" });
+            return;
+        }
+        // Check if code has expired (10 minutes)
+        if (Date.now() - codeData.createdAt > 10 * 60 * 1000) {
+            authorizationCodes.delete(authCode);
+            res.status(400).json({ error: "invalid_grant", error_description: "Authorization code has expired" });
+            return;
+        }
+        // Verify PKCE code_verifier if code_challenge was provided
+        if (codeData.codeChallenge) {
+            if (!codeVerifier) {
+                res.status(400).json({ error: "invalid_request", error_description: "Missing code_verifier" });
+                return;
+            }
+            // Calculate S256 hash of code_verifier and compare with stored code_challenge
+            const hash = crypto.createHash("sha256").update(codeVerifier).digest();
+            const calculatedChallenge = hash.toString("base64url");
+            if (calculatedChallenge !== codeData.codeChallenge) {
+                res.status(400).json({ error: "invalid_grant", error_description: "Invalid code_verifier" });
+                return;
+            }
+        }
+        // Delete the code (single use)
+        authorizationCodes.delete(authCode);
+        // Generate a session token and store the OAuth data
+        const sessionToken = crypto.randomUUID();
+        oauthTokens.set(sessionToken, {
+            accessToken: codeData.accessToken,
+            refreshToken: codeData.refreshToken,
+            expiresAt: Date.now() + codeData.expiresIn * 1000,
+            cloudId: codeData.cloudId,
+            scopes: codeData.scope.split(" "),
+        });
+        console.log(`OAuth Token: Issued access token for code exchange`);
+        // Return standard OAuth2 token response
+        res.json({
+            access_token: sessionToken,
+            token_type: "Bearer",
+            expires_in: codeData.expiresIn,
+            refresh_token: sessionToken, // Use same token for refresh
+            scope: codeData.scope,
+        });
+        return;
+    }
+    // Handle refresh_token grant
+    if (grantType === "refresh_token") {
+        if (!refreshToken) {
+            res.status(400).json({ error: "invalid_request", error_description: "Missing refresh_token" });
+            return;
+        }
+        const oauthData = oauthTokens.get(refreshToken);
+        if (!oauthData) {
+            res.status(400).json({ error: "invalid_grant", error_description: "Invalid refresh token" });
+            return;
+        }
+        if (!ATLASSIAN_CLIENT_ID || !ATLASSIAN_CLIENT_SECRET) {
+            res.status(500).json({ error: "server_error", error_description: "OAuth not configured" });
+            return;
+        }
+        try {
+            const refreshResponse = await fetch("https://auth.atlassian.com/oauth/token", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    grant_type: "refresh_token",
+                    client_id: ATLASSIAN_CLIENT_ID,
+                    client_secret: ATLASSIAN_CLIENT_SECRET,
+                    refresh_token: oauthData.refreshToken,
+                }),
+            });
+            if (!refreshResponse.ok) {
+                oauthTokens.delete(refreshToken);
+                res.status(400).json({ error: "invalid_grant", error_description: "Token refresh failed" });
+                return;
+            }
+            const newTokenData = await refreshResponse.json();
+            // Update stored tokens
+            oauthData.accessToken = newTokenData.access_token;
+            oauthData.refreshToken = newTokenData.refresh_token;
+            oauthData.expiresAt = Date.now() + newTokenData.expires_in * 1000;
+            console.log(`OAuth Token: Refreshed access token`);
+            res.json({
+                access_token: refreshToken, // Keep the same session token
+                token_type: "Bearer",
+                expires_in: newTokenData.expires_in,
+                refresh_token: refreshToken,
+                scope: newTokenData.scope,
+            });
+        }
+        catch (err) {
+            console.error("Token refresh error:", err);
+            res.status(500).json({ error: "server_error", error_description: "Token refresh failed" });
+        }
+        return;
+    }
+    res.status(400).json({ error: "unsupported_grant_type", error_description: `Unsupported grant_type: ${grantType}` });
+});
+// Cleanup expired authorization codes every 5 minutes
+setInterval(() => {
+    const now = Date.now();
+    for (const [code, data] of authorizationCodes) {
+        if (now - data.createdAt > 10 * 60 * 1000) {
+            authorizationCodes.delete(code);
+        }
+    }
+}, 5 * 60 * 1000);
+// Legacy token refresh endpoint (for backwards compatibility)
+app.post("/oauth/refresh", async (req, res) => {
+    const token = req.headers["x-oauth-token"] ||
+        req.headers.authorization?.replace("Bearer ", "");
+    if (!token) {
+        res.status(401).json({ error: "No token provided" });
+        return;
+    }
+    const oauthData = oauthTokens.get(token);
+    if (!oauthData) {
+        res.status(401).json({ error: "Invalid token" });
+        return;
+    }
+    if (!ATLASSIAN_CLIENT_ID || !ATLASSIAN_CLIENT_SECRET) {
+        res.status(500).json({ error: "OAuth not configured" });
+        return;
+    }
+    try {
+        const refreshResponse = await fetch("https://auth.atlassian.com/oauth/token", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                grant_type: "refresh_token",
+                client_id: ATLASSIAN_CLIENT_ID,
+                client_secret: ATLASSIAN_CLIENT_SECRET,
+                refresh_token: oauthData.refreshToken,
+            }),
+        });
+        if (!refreshResponse.ok) {
+            oauthTokens.delete(token);
+            res.status(401).json({ error: "Token refresh failed, please re-authenticate" });
+            return;
+        }
+        const newTokenData = await refreshResponse.json();
+        oauthData.accessToken = newTokenData.access_token;
+        oauthData.refreshToken = newTokenData.refresh_token;
+        oauthData.expiresAt = Date.now() + newTokenData.expires_in * 1000;
+        res.json({ success: true, expiresIn: newTokenData.expires_in });
+    }
+    catch (err) {
+        console.error("Token refresh error:", err);
+        res.status(500).json({ error: "Token refresh failed" });
+    }
+});
+// Get OAuth token info
+app.get("/oauth/tokeninfo", (req, res) => {
+    const token = req.headers["x-oauth-token"] ||
+        req.headers.authorization?.replace("Bearer ", "");
+    if (!token) {
+        res.status(401).json({ error: "No token provided" });
+        return;
+    }
+    const oauthData = oauthTokens.get(token);
+    if (!oauthData) {
+        res.status(401).json({ error: "Invalid token" });
+        return;
+    }
+    res.json({
+        valid: true,
+        expiresAt: new Date(oauthData.expiresAt).toISOString(),
+        expiresIn: Math.max(0, Math.floor((oauthData.expiresAt - Date.now()) / 1000)),
+        scopes: oauthData.scopes,
+    });
+});
+// HEAD request for /mcp - return protocol version (required by Claude Desktop)
+app.head("/mcp", rateLimit, (req, res) => {
+    res.setHeader("MCP-Protocol-Version", "2025-06-18");
+    res.setHeader("Content-Type", "application/json");
+    // For unauthenticated HEAD requests, still return 401 with WWW-Authenticate
+    const bearerToken = req.headers.authorization?.replace(/^Bearer\s+/i, "");
+    const apiKey = req.headers["x-api-key"];
+    const hasAuth = bearerToken || (apiKey && CLIENT_API_KEY && apiKey === CLIENT_API_KEY);
+    if (!hasAuth && CLIENT_API_KEY) {
+        const proto = req.headers["x-forwarded-proto"] || req.protocol || "https";
+        const host = req.headers["x-forwarded-host"] || req.headers.host || "localhost:8080";
+        const baseUrl = `${proto}://${host}`;
+        res.setHeader("WWW-Authenticate", `Bearer realm="mcp", resource_metadata="${baseUrl}/.well-known/oauth-authorization-server"`);
+        res.status(401).end();
+        return;
+    }
+    res.status(200).end();
+});
+app.all("/mcp", rateLimit, authenticate, async (req, res) => {
+    // Set MCP-Protocol-Version header on all responses
+    res.setHeader("MCP-Protocol-Version", "2025-06-18");
+    const sessionId = crypto.randomUUID();
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => sessionId,
+    });
+    const mcpServer = createMcpServer();
+    sessions.set(sessionId, transport);
+    req.on("close", () => {
+        sessions.delete(sessionId);
+        console.log(`Session ${sessionId} disconnected. Active sessions: ${sessions.size}`);
+    });
+    try {
+        await mcpServer.connect(transport);
+        console.log(`Session ${sessionId} connected. Active sessions: ${sessions.size}`);
+        await transport.handleRequest(req, res);
+    }
+    catch (error) {
+        sessions.delete(sessionId);
+        console.error(`Failed to handle request for session ${sessionId}:`, error);
+        if (!res.headersSent) {
+            res.status(500).json({ error: "Internal server error" });
+        }
+    }
+});
+// Only start HTTP server when running as main entry point (not imported by stdio.ts)
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+    const PORT = process.env.PORT ?? 8080;
+    const server = app.listen(PORT, () => {
+        console.log(`MCP Server running on port ${PORT}`);
+        console.log(`Health check: http://localhost:${PORT}/health`);
+        console.log(`MCP endpoint: http://localhost:${PORT}/mcp`);
+        console.log(`\nRegistered 64 Jira tools across categories:`);
+        console.log(`  Issues: get, search, create, update, delete, bulk_create`);
+        console.log(`  Transitions: get_transitions, transition, assign`);
+        console.log(`  Comments: get, add, update, delete`);
+        console.log(`  Worklogs: get, add, update, delete`);
+        console.log(`  Attachments: delete, get_content`);
+        console.log(`  Links: link_issues, delete_link, get_link_types`);
+        console.log(`  Watchers: get, add, remove`);
+        console.log(`  Projects: list, get, components, versions, statuses, create_version, create_component`);
+        console.log(`  Users: search, get_current, get, get_assignable`);
+        console.log(`  Boards: list, get, get_issues, get_backlog`);
+        console.log(`  Sprints: list, get, get_issues, create, update, move_issues`);
+        console.log(`  Epics: get, get_issues, move_issues, remove_issues`);
+        console.log(`  Filters: get_my, get_favorites, get, create`);
+        console.log(`  Metadata: fields, issue_types, priorities, statuses, resolutions, labels, server_info`);
+        console.log(`  Changelog: get_changelog, batch_get_changelogs`);
+        console.log(`  Batch: batch_create_versions`);
+    });
+    function shutdown(signal) {
+        console.log(`\n${signal} received. Shutting down gracefully...`);
+        for (const [sessionId, transport] of sessions) {
+            transport.close().catch(console.error);
+            sessions.delete(sessionId);
+        }
+        server.close(() => {
+            console.log("Server closed. Goodbye!");
+            process.exit(0);
+        });
+        setTimeout(() => {
+            console.error("Forced shutdown after timeout");
+            process.exit(1);
+        }, 10000);
+    }
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGINT", () => shutdown("SIGINT"));
+}
+//# sourceMappingURL=index.js.map