org-jira-mcp-adapter 1.2.2 → 1.2.3

package/README.md

@@ -22,14 +22,15 @@
       ],
       "env": {
         "JIRA_HOST": "jira.example.com",
-        "JIRA_API_TOKEN": "your_pat_token"
+        "JIRA_API_TOKEN": "your_pat_token",
+        "CONFLUENCE_HOST": "https://confluence.example.com",
+        "CONFLUENCE_TOKEN": "your_confluence_pat"
       }
     }
   }
 }
-```
 
-> **Важно**: Замените `jira.example.com` и `your_pat_token` на ваши реальные данные.
+> **Важно**: Замените `jira.example.com`, `your_pat_token` и настройки Confluence на ваши реальные данные.
 
 ### Переменные окружения
 

package/confluence-service.mjs

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+
+export class ConfluenceService {
+    constructor(host, token) {
+        this.baseUrl = host.replace(/\/$/, '') + '/rest/api';
+        this.token = token;
+        this.headers = {
+            'Authorization': `Bearer ${token}`,
+            'Accept': 'application/json',
+            'Content-Type': 'application/json'
+        };
+    }
+
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                ...this.headers,
+                ...options.headers
+            }
+        });
+
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Confluence API error: ${response.status} ${response.statusText} - ${body}`);
+        }
+
+        return response.json();
+    }
+
+    async searchPages(cql, limit = 10) {
+        const params = new URLSearchParams({
+            cql,
+            limit: limit.toString(),
+            expand: 'space,version,body.view'
+        });
+        return this.request(`/content/search?${params}`);
+    }
+
+    async getPage(pageId, expand) {
+        const expandParam = expand ? `&expand=${expand}` : '&expand=body.storage,version,space';
+        return this.request(`/content/${pageId}?${expandParam}`);
+    }
+
+    async getSpace(spaceKey) {
+        return this.request(`/space/${spaceKey}`);
+    }
+}
+
+export const confluenceToolSchemas = {
+    searchPages: {
+        cql: z.string().describe("Confluence Query Language (CQL) string"),
+        limit: z.number().optional().describe("Maximum number of results to return")
+    },
+    getPage: {
+        pageId: z.string().describe("Confluence Page ID"),
+        expand: z.string().optional().describe("Comma separated fields to expand")
+    },
+    getSpace: {
+        spaceKey: z.string().describe("Confluence Space Key")
+    }
+};

package/index.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { connectServer, createMcpServer, formatToolResponse } from '@atlassian-dc-mcp/common';
 import { JiraService, jiraToolSchemas } from './jira-service.mjs';
+import { ConfluenceService, confluenceToolSchemas } from './confluence-service.mjs';
 import * as process from 'node:process';
 
 const missingEnvVars = JiraService.validateConfig();
@@ -12,12 +13,45 @@ if (missingEnvVars.length > 0) {
 // Removing email from constructor as it is not needed for PAT auth
 const jiraService = new JiraService(process.env.JIRA_HOST, process.env.JIRA_API_TOKEN, process.env.JIRA_API_BASE_PATH);
 
+// Confluence setup - используем CONFLUENCE_TOKEN если есть, иначе пробуем JIRA_API_TOKEN
+const confluenceToken = process.env.CONFLUENCE_TOKEN || process.env.JIRA_API_TOKEN;
+const confluenceHost = process.env.CONFLUENCE_HOST;
+
+if (!confluenceHost) {
+    console.error("Warning: CONFLUENCE_HOST is not set. Confluence tools will fail.");
+}
+
+const confluenceService = new ConfluenceService(
+    confluenceHost || '',
+    confluenceToken
+);
+
 const server = createMcpServer({
     name: "atlassian-jira-mcp",
     version: "0.1.0"
 });
 
 const jiraInstanceType = "JIRA Data Center edition instance";
+const confluenceInstanceType = "Confluence Data Center instance";
+
+// --- Confluence Tools ---
+
+server.tool("confluence_searchPages", `Search for Confluence pages using CQL in the ${confluenceInstanceType}`, confluenceToolSchemas.searchPages, async ({ cql, limit }) => {
+    const result = await confluenceService.searchPages(cql, limit);
+    return formatToolResponse(result);
+});
+
+server.tool("confluence_getPage", `Get details of a Confluence page by its ID from the ${confluenceInstanceType}`, confluenceToolSchemas.getPage, async ({ pageId, expand }) => {
+    const result = await confluenceService.getPage(pageId, expand);
+    return formatToolResponse(result);
+});
+
+server.tool("confluence_getSpace", `Get details of a Confluence space by its key from the ${confluenceInstanceType}`, confluenceToolSchemas.getSpace, async ({ spaceKey }) => {
+    const result = await confluenceService.getSpace(spaceKey);
+    return formatToolResponse(result);
+});
+
+// --- Jira Tools ---
 
 server.tool("jira_searchIssues", `Search for JIRA issues using JQL in the ${jiraInstanceType}`, jiraToolSchemas.searchIssues, async ({ jql, expand, startAt, maxResults = 10 }) => {
     const result = await jiraService.searchIssues(jql, startAt, expand, maxResults);
@@ -124,4 +158,19 @@ server.tool("jira_findUsers", `Find users in the ${jiraInstanceType}`, jiraToolS
     return formatToolResponse(result);
 });
 
+server.tool("jira_getIssueAttachments", `Get attachments for a JIRA issue in the ${jiraInstanceType}`, jiraToolSchemas.getIssueAttachments, async ({ issueKey }) => {
+    const result = await jiraService.getIssueAttachments(issueKey);
+    return formatToolResponse(result);
+});
+
+server.tool("jira_getAttachmentContentUrl", `Get download URL for a JIRA attachment in the ${jiraInstanceType}`, jiraToolSchemas.getAttachmentContentUrl, async ({ attachmentId }) => {
+    const url = await jiraService.getAttachmentContentUrl(attachmentId);
+    return formatToolResponse({ url, attachmentId });
+});
+
+server.tool("jira_addAttachment", `Add an attachment to a JIRA issue in the ${jiraInstanceType}`, jiraToolSchemas.addAttachment, async ({ issueKey, filePath }) => {
+    const result = await jiraService.addAttachment(issueKey, filePath);
+    return formatToolResponse(result);
+});
+
 await connectServer(server);

package/jira-service.mjs

@@ -1,6 +1,9 @@
 import { z } from 'zod';
 import { handleApiOperation } from '@atlassian-dc-mcp/common';
-import { IssueService, OpenAPI, SearchService } from '@atlassian-dc-mcp/jira/build/jira-client/index.js';
+import { IssueService, OpenAPI, SearchService, ProjectService, MyselfService, GroupuserpickerService } from '@atlassian-dc-mcp/jira/build/jira-client/index.js';
+import { request } from '@atlassian-dc-mcp/jira/build/jira-client/core/request.js';
+import * as fs from 'fs';
+import * as path from 'path';
 
 export class JiraService {
     constructor(host, token, fullBaseUrl) {
@@ -130,6 +133,91 @@ export class JiraService {
         return handleApiOperation(() => GroupuserpickerService.findUsersAndGroups(undefined, maxResults, query, undefined, undefined, undefined), 'Error finding users');
     }
 
+    async getIssueAttachments(issueKey) {
+        return handleApiOperation(async () => {
+            const issue = await IssueService.getIssue(issueKey, ['attachment']);
+            const attachments = issue.fields?.attachment || [];
+            // Attachment'ы уже содержат поле 'content' с URL для скачивания
+            return attachments;
+        }, 'Error getting issue attachments');
+    }
+
+    async getAttachmentContentUrl(attachmentId) {
+        // Возвращает URL для скачивания attachment'а
+        // В Jira REST API attachment'ы доступны через /secure/attachment/{id}
+        const baseUrl = OpenAPI.BASE.replace('/rest', '');
+        return `${baseUrl}/secure/attachment/${attachmentId}`;
+    }
+
+    async addAttachment(issueKey, filePath) {
+        return handleApiOperation(async () => {
+            // Проверяем существование файла
+            if (!fs.existsSync(filePath)) {
+                throw new Error(`File not found: ${filePath}`);
+            }
+
+            // Читаем файл
+            const fileBuffer = fs.readFileSync(filePath);
+            const fileName = path.basename(filePath);
+            
+            // Создаем File из буфера (в Node.js 18+ доступен глобальный File)
+            // File наследуется от Blob и содержит имя файла
+            let file;
+            if (typeof File !== 'undefined') {
+                file = new File([fileBuffer], fileName, { 
+                    type: this.getMimeType(filePath) 
+                });
+            } else {
+                // Если File недоступен, создаем Blob и добавляем имя через специальный объект
+                const blob = new Blob([fileBuffer], { 
+                    type: this.getMimeType(filePath) 
+                });
+                // Создаем объект, который будет правильно обработан FormData
+                file = Object.assign(blob, { name: fileName });
+            }
+
+            // Для Jira API нужно передать объект с ключом 'file' и значением File/Blob
+            // Используем request напрямую для правильной обработки multipart/form-data
+            // Также нужно добавить заголовок X-Atlassian-Token: no-check для защиты от XSRF
+            return request(OpenAPI, {
+                method: 'POST',
+                url: '/api/2/issue/{issueIdOrKey}/attachments',
+                path: {
+                    'issueIdOrKey': issueKey,
+                },
+                headers: {
+                    'X-Atlassian-Token': 'no-check'
+                },
+                formData: {
+                    'file': file
+                },
+                mediaType: 'multipart/form-data',
+                errors: {
+                    403: `Returned if attachments is disabled or if you don't have permission to add attachments to this issue.`,
+                    404: `Returned if the requested issue is not found, the user does not have permission to view it, or if the attachments exceeds the maximum configured attachment size.`,
+                },
+            });
+        }, 'Error adding attachment');
+    }
+
+    getMimeType(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const mimeTypes = {
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.pdf': 'application/pdf',
+            '.txt': 'text/plain',
+            '.doc': 'application/msword',
+            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            '.xls': 'application/vnd.ms-excel',
+            '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            '.zip': 'application/zip',
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+
     static validateConfig() {
         const requiredEnvVars = ['JIRA_API_TOKEN'];
         const missingVars = requiredEnvVars.filter(varName => !process.env[varName]);
@@ -227,5 +315,15 @@ export const jiraToolSchemas = {
         description: z.string().optional().describe("New description in JIRA Wiki Markup (optional)"),
         issueTypeId: z.string().optional().describe("New issue type id (optional)"),
         customFields: z.object({}).catchall(z.any()).optional().describe("Optional custom fields to update as key-value pairs. Examples: {'customfield_10001': 'Custom Value', 'priority': {'id': '1'}, 'assignee': {'name': 'john.doe'}, 'labels': ['urgent', 'bug']}")
+    },
+    getIssueAttachments: {
+        issueKey: z.string().describe("JIRA issue key (e.g., PROJ-123)")
+    },
+    getAttachmentContentUrl: {
+        attachmentId: z.string().describe("Attachment ID from JIRA issue")
+    },
+    addAttachment: {
+        issueKey: z.string().describe("JIRA issue key (e.g., PROJ-123)"),
+        filePath: z.string().describe("Path to the file to attach (absolute or relative path)")
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "org-jira-mcp-adapter",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "MCP server for Jira Data Center/Server (On-Premise)",
   "type": "module",
   "main": "index.mjs",