@aaronsb/jira-cloud-mcp 0.2.4 → 0.2.6

package/build/client/jira-client.js

@@ -176,8 +176,8 @@ export class JiraClient {
             fields.parent = params.parentKey ? { key: params.parentKey } : null;
         }
         if (params.assignee !== undefined) {
-            // null unassigns, string assigns by account ID or name
-            fields.assignee = params.assignee ? { id: params.assignee } : null;
+            // null unassigns, string assigns by account ID
+            fields.assignee = params.assignee ? { accountId: params.assignee } : null;
         }
         if (params.priority)
             fields.priority = { id: params.priority };
@@ -696,7 +696,7 @@ export class JiraClient {
         if (params.priority)
             fields.priority = { id: params.priority };
         if (params.assignee)
-            fields.assignee = { name: params.assignee };
+            fields.assignee = { accountId: params.assignee };
         if (params.labels)
             fields.labels = params.labels;
         if (params.customFields) {

package/build/worker.js

@@ -0,0 +1,200 @@
+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' },
+        });
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaronsb/jira-cloud-mcp",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Model Context Protocol (MCP) server for Jira Cloud - enables AI assistants to interact with Jira",
   "type": "module",
   "bin": {
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.3",
-    "jira.js": "^5.2.2",
+    "jira.js": "5.2.2",
     "jsdom": "^27.3.0",
     "markdown-it": "^14.1.0"
   },