@aaronsb/jira-cloud-mcp 0.5.11 → 0.6.1

package/build/index.js

@@ -4,11 +4,14 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ErrorCode, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, McpError, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { fieldDiscovery } from './client/field-discovery.js';
+import { GraphObjectCache } from './client/graph-object-cache.js';
+import { discoverCloudId, GraphQLClient } from './client/graphql-client.js';
 import { JiraClient } from './client/jira-client.js';
 import { handleAnalysisRequest } from './handlers/analysis-handler.js';
 import { handleBoardRequest } from './handlers/board-handlers.js';
 import { handleFilterRequest } from './handlers/filter-handlers.js';
 import { handleIssueRequest } from './handlers/issue-handlers.js';
+import { handlePlanRequest } from './handlers/plan-handler.js';
 import { handleProjectRequest } from './handlers/project-handlers.js';
 import { createQueueHandler } from './handlers/queue-handler.js';
 import { setupResourceHandlers } from './handlers/resource-handlers.js';
@@ -32,9 +35,34 @@ if (!JIRA_EMAIL || !JIRA_API_TOKEN || !JIRA_HOST) {
 }
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
+/** Map manage_jira_issue update args to GraphIssue field patches */
+function extractChangedFields(args) {
+    const fields = {};
+    if ('dueDate' in args)
+        fields.dueDate = args.dueDate;
+    if ('summary' in args)
+        fields.summary = args.summary;
+    if ('assignee' in args)
+        fields.assignee = args.assignee;
+    if ('storyPoints' in args)
+        fields.storyPoints = args.storyPoints;
+    // startDate may come via customFields — check both
+    if ('startDate' in args)
+        fields.startDate = args.startDate;
+    const customFields = args.customFields;
+    if (customFields) {
+        for (const [key, val] of Object.entries(customFields)) {
+            if (key.toLowerCase().includes('start'))
+                fields.startDate = val;
+        }
+    }
+    return fields;
+}
 class JiraServer {
     server;
     jiraClient;
+    graphqlClient = null;
+    cache = new GraphObjectCache();
     constructor() {
         const serverName = process.env.MCP_SERVER_NAME || 'jira-cloud';
         console.error(`Initializing Jira MCP server: ${serverName}`);
@@ -55,7 +83,15 @@ class JiraServer {
         });
         this.setupHandlers();
         // Start async field discovery (non-blocking)
-        fieldDiscovery.startAsync(this.jiraClient.v3Client);
+        fieldDiscovery.startAsync(this.jiraClient.v3Client).then(() => {
+            const sprintId = fieldDiscovery.getWellKnownFieldId('sprint');
+            if (sprintId) {
+                this.jiraClient.setSprintFieldId(sprintId);
+                console.error(`[jira-cloud] Sprint field: ${sprintId}`);
+            }
+        }).catch(() => { });
+        // CloudId discovery happens in run() before server connects — must complete
+        // before ListTools so analyze_jira_plan is registered if available.
         this.server.onerror = (error) => console.error('[MCP Error]', error);
         process.on('SIGINT', async () => {
             await this.server.close();
@@ -66,6 +102,7 @@ class JiraServer {
         // Set up required MCP protocol handlers
         this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
             tools: Object.entries(toolSchemas)
+                .filter(([key]) => key !== 'analyze_jira_plan' || this.graphqlClient !== null)
                 .map(([key, schema]) => ({
                 name: key,
                 description: schema.description,
@@ -101,6 +138,7 @@ class JiraServer {
         // Set up tool handlers
         this.server.setRequestHandler(CallToolRequestSchema, async (request, _extra) => {
             console.error('Received request:', JSON.stringify(request, null, 2));
+            this.cache.tick();
             const { name } = request.params;
             console.error(`Handling tool request: ${name}`);
             try {
@@ -110,11 +148,14 @@ class JiraServer {
                     manage_jira_board: handleBoardRequest,
                     manage_jira_sprint: handleSprintRequest,
                     manage_jira_filter: handleFilterRequest,
-                    analyze_jira_issues: handleAnalysisRequest,
+                    analyze_jira_issues: (client, req) => handleAnalysisRequest(client, req, this.graphqlClient, this.cache),
                 };
                 const handlers = {
                     ...toolHandlers,
                     queue_jira_operations: createQueueHandler(toolHandlers, JIRA_HOST),
+                    ...(this.graphqlClient ? {
+                        analyze_jira_plan: (_client, req) => handlePlanRequest(this.jiraClient, this.graphqlClient, req, this.cache),
+                    } : {}),
                 };
                 const handler = handlers[name];
                 if (!handler) {
@@ -131,6 +172,21 @@ class JiraServer {
                         response.content[0].text += `\n\n---\n**💡 Efficiency tip:** You've made ${consecutiveIssueCalls} consecutive \`manage_jira_issue\` calls. Consider using \`queue_jira_operations\` to batch multiple issue operations into a single call — it's faster and uses less context.`;
                         consecutiveIssueCalls = 0;
                     }
+                    // Surgical cache patching — update cached issues on mutations
+                    const reqArgs = request.params.arguments;
+                    const op = reqArgs?.operation;
+                    if ((op === 'update' || op === 'transition') && this.cache.walks.size > 0) {
+                        const issueKey = reqArgs?.issueKey;
+                        if (issueKey) {
+                            const changedFields = extractChangedFields(reqArgs);
+                            if (Object.keys(changedFields).length > 0) {
+                                const patched = this.cache.patch(issueKey, changedFields);
+                                if (patched) {
+                                    console.error(`[graph-cache] Patched ${issueKey} in cache`);
+                                }
+                            }
+                        }
+                    }
                 }
                 else {
                     consecutiveIssueCalls = 0;
@@ -178,6 +234,20 @@ class JiraServer {
         });
     }
     async run() {
+        // Discover cloudId before connecting — must complete before ListTools
+        try {
+            const cloudId = await discoverCloudId(JIRA_HOST, JIRA_EMAIL, JIRA_API_TOKEN);
+            if (cloudId) {
+                this.graphqlClient = new GraphQLClient(JIRA_EMAIL, JIRA_API_TOKEN, cloudId);
+                console.error(`[jira-cloud] GraphQL client ready (cloudId: ${cloudId.slice(0, 8)}...)`);
+            }
+            else {
+                console.error('[jira-cloud] GraphQL/Plans unavailable — analyze_jira_plan disabled');
+            }
+        }
+        catch {
+            console.error('[jira-cloud] GraphQL discovery failed — analyze_jira_plan disabled');
+        }
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         console.error('Jira MCP server running on stdio');

package/build/schemas/tool-schemas.js

@@ -332,24 +332,28 @@ export const toolSchemas = {
             properties: {
                 jql: {
                     type: 'string',
-                    description: 'JQL query selecting the issues to analyze. Either jql or filterId is required (filterId takes precedence). Examples: "project in (AA, GC, LGS)", "sprint in openSprints()", "assignee = currentUser() AND resolution = Unresolved".',
+                    description: 'JQL query selecting the issues to analyze. Either jql, filterId, or dataRef is required (dataRef > filterId > jql precedence). Examples: "project in (AA, GC, LGS)", "sprint in openSprints()", "assignee = currentUser() AND resolution = Unresolved".',
                 },
                 filterId: {
                     type: 'string',
                     description: 'ID of a saved Jira filter to use as the query source. The filter\'s JQL is resolved automatically. Use this to run different analyses against a saved query without repeating the JQL. Create filters with manage_jira_filter.',
                 },
+                dataRef: {
+                    type: 'string',
+                    description: 'Root issue key of a cached hierarchy walk. Analyzes cached plan data without re-fetching from Jira. Start a walk with analyze_jira_plan first. Supports all metrics except flow. Takes precedence over jql/filterId.',
+                },
                 metrics: {
                     type: 'array',
                     items: {
                         type: 'string',
-                        enum: ['summary', 'points', 'time', 'schedule', 'cycle', 'distribution', 'flow', 'cube_setup'],
+                        enum: ['summary', 'points', 'time', 'schedule', 'cycle', 'distribution', 'flow', 'hierarchy', 'cube_setup'],
                     },
-                    description: 'Which metric groups to compute. summary = exact counts via count API (no issue cap, fastest) — use with groupBy for "how many by assignee/status/priority" questions. distribution = approximate counts from fetched issues (capped by maxResults — use summary + groupBy instead when you need exact counts). flow = status transition analysis from bulk changelogs — entries per status, avg time in each, bounce rates, top bouncers. cube_setup = discover dimensions before cube queries. points = earned value/SPI. time = effort estimates. schedule = overdue/risk. cycle = lead time/throughput. Default: all detail metrics (excluding flow — request flow explicitly). For counting/breakdown questions, always prefer summary + groupBy over distribution.',
+                    description: 'Which metric groups to compute. summary = exact counts via count API (no issue cap, fastest) — use with groupBy for "how many by assignee/status/priority" questions. distribution = approximate counts from fetched issues (capped by maxResults — use summary + groupBy instead when you need exact counts). flow = status transition analysis from bulk changelogs — entries per status, avg time in each, bounce rates, top bouncers. hierarchy = tree visualization with rollups for parent-child structures (requires GraphQL — opt-in like flow). cube_setup = discover dimensions before cube queries. points = earned value/SPI. time = effort estimates. schedule = overdue/risk. cycle = lead time/throughput. Default: all detail metrics (excluding flow and hierarchy — request explicitly). For counting/breakdown questions, always prefer summary + groupBy over distribution.',
                 },
                 groupBy: {
                     type: 'string',
-                    enum: ['project', 'assignee', 'priority', 'issuetype'],
-                    description: 'Split counts by this dimension — produces a breakdown table. Use with metrics: ["summary"] for exact counts. This is the correct approach for "how many issues per assignee/priority/type" questions. "project" produces a per-project comparison.',
+                    enum: ['project', 'assignee', 'priority', 'issuetype', 'parent', 'sprint'],
+                    description: 'Split counts by this dimension — produces a breakdown table. Use with metrics: ["summary"] for exact counts. This is the correct approach for "how many issues per assignee/priority/type" questions. "project" produces a per-project comparison. "parent" groups by parent issue. "sprint" groups by sprint name.',
                 },
                 compute: {
                     type: 'array',
@@ -371,6 +375,42 @@ export const toolSchemas = {
             required: [],
         },
     },
+    analyze_jira_plan: {
+        name: 'analyze_jira_plan',
+        description: 'Analyze hierarchy rollups for any parent issue. Walks the issue tree via GraphQL, computes rolled-up dates, points, progress, assignees, and detects date conflicts. Results are cached server-side for fast re-analysis. Works on any Jira instance (no Plans/Premium required). For flat-set metrics use analyze_jira_issues (with dataRef to analyze cached plan data); for structure without rollups use manage_jira_issue hierarchy.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                operation: {
+                    type: 'string',
+                    enum: ['analyze', 'release'],
+                    description: 'Operation to perform. analyze (default): walk hierarchy and compute rollups. release: free cached walk data for this issueKey.',
+                },
+                issueKey: {
+                    type: 'string',
+                    description: 'Issue key at the root of the plan tree (e.g., PROJ-100). Required.',
+                },
+                rollups: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: ['dates', 'points', 'progress', 'assignees'],
+                    },
+                    description: 'Which rollup dimensions to include. Default: all.',
+                },
+                focus: {
+                    type: 'string',
+                    description: 'Issue key to focus on within the cached plan. Shows the node, its parent, siblings, and children — a windowed view for navigating large plans. Requires a completed walk.',
+                },
+                mode: {
+                    type: 'string',
+                    enum: ['rollup', 'gaps'],
+                    description: 'Output mode. rollup (default): summary + entry points. gaps: conflicts and missing data only.',
+                },
+            },
+            required: ['issueKey'],
+        },
+    },
     queue_jira_operations: {
         name: 'queue_jira_operations',
         description: 'Execute multiple Jira operations in a single call. Operations run sequentially with result references ($0.key) and per-operation error strategies (bail/continue). Powerful for analysis pipelines: create a filter, then run multiple analyze_jira_issues calls against $0.filterId with different groupBy/compute — all in one call.',

package/build/utils/next-steps.js

@@ -39,7 +39,7 @@ export function issueNextSteps(operation, issueKey) {
             steps.push({ description: 'View the linked issue', tool: 'manage_jira_issue', example: { operation: 'get', issueKey } }, { description: 'Read available link types from jira://issue-link-types resource' });
             break;
         case 'hierarchy':
-            steps.push({ description: 'View a specific issue from the tree', tool: 'manage_jira_issue', example: { operation: 'get', issueKey } }, { description: 'Search for issues in this project', tool: 'manage_jira_filter', example: { operation: 'execute_jql', jql: `project = "${issueKey?.split('-')[0]}"` } });
+            steps.push({ description: 'View a specific issue from the tree', tool: 'manage_jira_issue', example: { operation: 'get', issueKey } }, { description: 'Analyze plan rollups (requires Jira Plans)', tool: 'analyze_jira_plan', example: { issueKey } }, { description: 'Search for issues in this project', tool: 'manage_jira_filter', example: { operation: 'execute_jql', jql: `project = "${issueKey?.split('-')[0]}"` } });
             break;
     }
     return steps.length > 0 ? formatSteps(steps) : '';
@@ -125,6 +125,52 @@ export function boardNextSteps(operation, boardId) {
     }
     return steps.length > 0 ? formatSteps(steps) : '';
 }
+export function planNextSteps(issueKey, mode, conflicts, rollup) {
+    const steps = [];
+    steps.push({ description: 'View the issue details', tool: 'manage_jira_issue', example: { operation: 'get', issueKey } }, { description: 'Explore the hierarchy tree', tool: 'manage_jira_issue', example: { operation: 'hierarchy', issueKey } });
+    if (mode !== 'gaps') {
+        steps.push({ description: 'Check for data gaps and conflicts', tool: 'analyze_jira_plan', example: { issueKey, mode: 'gaps' } });
+    }
+    if (mode !== 'timeline') {
+        steps.push({ description: 'View the timeline', tool: 'analyze_jira_plan', example: { issueKey, mode: 'timeline' } });
+    }
+    steps.push({ description: 'Run flat metrics on children', tool: 'analyze_jira_issues', example: { jql: `parent = ${issueKey}`, metrics: ['summary'], groupBy: 'assignee' } });
+    let result = formatSteps(steps);
+    // Append conflict fix operations if conflicts exist
+    if (conflicts && conflicts.length > 0 && rollup) {
+        result += conflictFixSteps(conflicts, rollup);
+    }
+    return result;
+}
+export function conflictFixSteps(conflicts, rollup) {
+    const fixOps = [];
+    const lines = ['\n\n**Conflict fixes:**'];
+    for (const conflict of conflicts) {
+        switch (conflict.type) {
+            case 'due_date':
+                if (rollup.rolledUpEnd) {
+                    lines.push(`- Update ${conflict.issueKey} due date to ${rollup.rolledUpEnd} — \`manage_jira_issue\` \`{ operation: "update", issueKey: "${conflict.issueKey}", dueDate: "${rollup.rolledUpEnd}" }\``);
+                    fixOps.push({ tool: 'manage_jira_issue', args: { operation: 'update', issueKey: conflict.issueKey, dueDate: rollup.rolledUpEnd } });
+                }
+                break;
+            case 'start_date':
+                if (rollup.rolledUpStart) {
+                    lines.push(`- Update ${conflict.issueKey} start date to ${rollup.rolledUpStart} — read \`jira://custom-fields\` to find the start date field ID, then use \`manage_jira_issue update\``);
+                    // Don't auto-generate queue op for start date — field ID is instance-specific
+                }
+                break;
+            case 'resolved_with_open_children':
+                lines.push(`- ${conflict.issueKey}: ${conflict.message} — reopen parent or resolve open children (use \`manage_jira_issue get\` with \`expand: ["transitions"]\` to find transition IDs)`);
+                break;
+        }
+    }
+    if (fixOps.length > 0) {
+        lines.push('');
+        lines.push('**Fix all date conflicts in one call:**');
+        lines.push(`\`queue_jira_operations\` — \`${JSON.stringify({ operations: fixOps.map(op => ({ ...op, onError: 'continue' })) })}\``);
+    }
+    return lines.join('\n');
+}
 export function analysisNextSteps(jql, issueKeys, truncated = false, groupBy, filterSource) {
     const steps = [];
     if (issueKeys.length > 0) {
@@ -144,6 +190,10 @@ export function analysisNextSteps(jql, issueKeys, truncated = false, groupBy, fi
     if (truncated) {
         steps.push({ description: 'Distribution counts above are approximate (issue cap hit). For exact breakdowns use summary + groupBy', tool: 'analyze_jira_issues', example: { jql, metrics: ['summary'], groupBy: 'assignee' } }, { description: 'Or narrow JQL for precise detail metrics', tool: 'analyze_jira_issues', example: { jql: `${jql} AND assignee = currentUser()`, metrics: ['cycle'] } });
     }
+    // Suggest plan analysis when issue keys suggest hierarchical structure
+    if (issueKeys.length > 0) {
+        steps.push({ description: 'Analyze plan rollups for a parent issue (requires Jira Plans)', tool: 'analyze_jira_plan', example: { issueKey: issueKeys[0] } });
+    }
     // Suggest saving as filter if not already using one
     if (!filterSource) {
         steps.push({ description: 'Save this query as a filter for reuse across analyses', tool: 'manage_jira_filter', example: { operation: 'create', name: '<descriptive name>', jql } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaronsb/jira-cloud-mcp",
-  "version": "0.5.11",
+  "version": "0.6.1",
   "mcpName": "io.github.aaronsb/jira-cloud",
   "description": "Model Context Protocol (MCP) server for Jira Cloud - enables AI assistants to interact with Jira",
   "type": "module",

package/build/worker.js

@@ -1,200 +0,0 @@
-import { McpAgent } from 'agents/mcp';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { JiraClient } from './client/jira-client.js';
-// Atlassian OAuth handler
-async function atlassianAuthHandler(request, env) {
-    const url = new URL(request.url);
-    if (url.pathname === '/callback') {
-        const code = url.searchParams.get('code');
-        const state = url.searchParams.get('state');
-        if (!code) {
-            return new Response('Missing authorization code', { status: 400 });
-        }
-        // Exchange 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: env.ATLASSIAN_CLIENT_ID,
-                client_secret: env.ATLASSIAN_CLIENT_SECRET,
-                code,
-                redirect_uri: `${url.origin}/callback`,
-            }),
-        });
-        if (!tokenResponse.ok) {
-            const error = await tokenResponse.text();
-            return new Response(`Token exchange failed: ${error}`, { status: 400 });
-        }
-        const tokens = await tokenResponse.json();
-        // Get accessible resources (cloud instances)
-        const resourcesResponse = await fetch('https://api.atlassian.com/oauth/token/accessible-resources', {
-            headers: {
-                'Authorization': `Bearer ${tokens.access_token}`,
-                'Accept': 'application/json',
-            },
-        });
-        if (!resourcesResponse.ok) {
-            return new Response('Failed to get accessible resources', { status: 400 });
-        }
-        const resources = await resourcesResponse.json();
-        if (resources.length === 0) {
-            return new Response('No accessible Jira instances found', { status: 400 });
-        }
-        // Use first available resource (could add selection UI later)
-        const cloudId = resources[0].id;
-        // Get user info
-        const userResponse = await fetch(`https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/myself`, {
-            headers: {
-                'Authorization': `Bearer ${tokens.access_token}`,
-                'Accept': 'application/json',
-            },
-        });
-        const user = await userResponse.json();
-        // Store session in KV
-        const sessionId = crypto.randomUUID();
-        await env.OAUTH_KV.put(`session:${sessionId}`, JSON.stringify({
-            accessToken: tokens.access_token,
-            refreshToken: tokens.refresh_token,
-            cloudId,
-            email: user.emailAddress,
-            displayName: user.displayName,
-        }), { expirationTtl: 3600 * 24 * 7 }); // 7 days
-        // Redirect back to original state or home
-        const redirectUrl = state || '/';
-        return new Response(null, {
-            status: 302,
-            headers: {
-                'Location': redirectUrl,
-                'Set-Cookie': `session=${sessionId}; HttpOnly; Secure; SameSite=Lax; Path=/; Max-Age=${3600 * 24 * 7}`,
-            },
-        });
-    }
-    if (url.pathname === '/authorize') {
-        const state = url.searchParams.get('state') || '/';
-        const scopes = [
-            'read:jira-work',
-            'write:jira-work',
-            'read:jira-user',
-            'offline_access', // For refresh tokens
-        ].join(' ');
-        const authUrl = new URL('https://auth.atlassian.com/authorize');
-        authUrl.searchParams.set('audience', 'api.atlassian.com');
-        authUrl.searchParams.set('client_id', env.ATLASSIAN_CLIENT_ID);
-        authUrl.searchParams.set('scope', scopes);
-        authUrl.searchParams.set('redirect_uri', `${url.origin}/callback`);
-        authUrl.searchParams.set('state', state);
-        authUrl.searchParams.set('response_type', 'code');
-        authUrl.searchParams.set('prompt', 'consent');
-        return Response.redirect(authUrl.toString(), 302);
-    }
-    return new Response('Not found', { status: 404 });
-}
-// MCP Agent for Jira
-export class JiraMCP extends McpAgent {
-    server = new McpServer({
-        name: 'jira-cloud-mcp',
-        version: '0.2.4',
-    });
-    jiraClient = null;
-    async init() {
-        // Initialize Jira client with OAuth token
-        if (this.props?.accessToken && this.props?.cloudId) {
-            this.jiraClient = new JiraClient({
-                host: `api.atlassian.com/ex/jira/${this.props.cloudId}`,
-                email: this.props.email,
-                apiToken: this.props.accessToken, // OAuth token used as bearer
-                // Note: We'll need to modify JiraClient to support OAuth bearer tokens
-            });
-        }
-        // Register tools
-        this.registerTools();
-    }
-    registerTools() {
-        // For now, register a simple test tool
-        // Full tool registration will come in next iteration
-        this.server.tool('test_connection', 'Test the Jira connection', {}, async () => {
-            if (!this.jiraClient) {
-                return {
-                    content: [{ type: 'text', text: 'Not authenticated. Please authorize first.' }],
-                };
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Connected as ${this.props?.displayName} (${this.props?.email})`
-                    }],
-            };
-        });
-        // TODO: Register full Jira tools from existing handlers
-        // this.registerIssueTools();
-        // this.registerProjectTools();
-        // this.registerBoardTools();
-        // this.registerSprintTools();
-        // this.registerFilterTools();
-    }
-}
-// Main Worker export
-export default {
-    async fetch(request, env, ctx) {
-        const url = new URL(request.url);
-        // Handle OAuth endpoints
-        if (url.pathname === '/authorize' || url.pathname === '/callback') {
-            return atlassianAuthHandler(request, env);
-        }
-        // Handle MCP endpoints (SSE and streamable-http)
-        if (url.pathname === '/sse' || url.pathname === '/mcp') {
-            // Get session from cookie
-            const cookies = request.headers.get('Cookie') || '';
-            const sessionMatch = cookies.match(/session=([^;]+)/);
-            const sessionId = sessionMatch?.[1];
-            let props;
-            if (sessionId) {
-                const sessionData = await env.OAUTH_KV.get(`session:${sessionId}`);
-                if (sessionData) {
-                    props = JSON.parse(sessionData);
-                }
-            }
-            // Route to Durable Object
-            const id = env.MCP_OBJECT.idFromName('jira-mcp');
-            const stub = env.MCP_OBJECT.get(id);
-            // Pass props to the Durable Object
-            const newRequest = new Request(request.url, {
-                method: request.method,
-                headers: request.headers,
-                body: request.body,
-            });
-            // Add props as header for the Durable Object
-            if (props) {
-                newRequest.headers.set('X-MCP-Props', JSON.stringify(props));
-            }
-            return stub.fetch(newRequest);
-        }
-        // Home page with auth status
-        const cookies = request.headers.get('Cookie') || '';
-        const sessionMatch = cookies.match(/session=([^;]+)/);
-        const sessionId = sessionMatch?.[1];
-        if (sessionId) {
-            const sessionData = await env.OAUTH_KV.get(`session:${sessionId}`);
-            if (sessionData) {
-                const session = JSON.parse(sessionData);
-                return new Response(`
-          <h1>Jira Cloud MCP Server</h1>
-          <p>Logged in as: ${session.displayName} (${session.email})</p>
-          <p>MCP Endpoint: <code>${url.origin}/mcp</code></p>
-          <p>SSE Endpoint: <code>${url.origin}/sse</code></p>
-        `, {
-                    headers: { 'Content-Type': 'text/html' },
-                });
-            }
-        }
-        return new Response(`
-      <h1>Jira Cloud MCP Server</h1>
-      <p><a href="/authorize">Authorize with Atlassian</a></p>
-    `, {
-            headers: { 'Content-Type': 'text/html' },
-        });
-    },
-};