@mmtr-tech/yandex-tracker-mcp 0.1.0

package/dist/client/tracker-client.js

@@ -0,0 +1,459 @@
+import axios from 'axios';
+import https from 'https';
+const DEFAULT_BASE_URL = 'https://api.tracker.yandex.net/v3';
+/**
+ * HTTP client for Yandex Tracker API v3 (OAuth + X-Org-ID / Yandex 360).
+ */
+export class TrackerClient {
+    http;
+    config;
+    constructor(config) {
+        this.config = config;
+        const httpsAgent = new https.Agent({
+            rejectUnauthorized: config.sslVerify ?? true,
+        });
+        this.http = axios.create({
+            baseURL: config.baseUrl.replace(/\/$/, ''),
+            timeout: config.timeoutMs ?? 30_000,
+            headers: {
+                Authorization: `OAuth ${config.token}`,
+                'X-Org-ID': config.orgId,
+                Accept: 'application/json',
+            },
+            httpsAgent,
+        });
+    }
+    async getMyself() {
+        try {
+            const { data } = await this.http.get('/myself');
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async listQueues(params = {}) {
+        try {
+            const { data } = await this.http.get('/queues/', {
+                params: {
+                    perPage: params.perPage,
+                    page: params.page,
+                    expand: params.expand,
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getQueue(params) {
+        try {
+            const { data } = await this.http.get(`/queues/${encodeURIComponent(params.queueId)}`, {
+                params: { expand: params.expand },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getIssue(params) {
+        try {
+            const { data } = await this.http.get(`/issues/${encodeURIComponent(params.issueId)}`, {
+                params: {
+                    expand: params.expand,
+                    fields: params.fields,
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async searchIssues(params) {
+        try {
+            const body = {};
+            if (params.query !== undefined)
+                body.query = params.query;
+            if (params.filter !== undefined)
+                body.filter = params.filter;
+            if (params.keys !== undefined)
+                body.keys = params.keys;
+            if (params.queue !== undefined)
+                body.queue = params.queue;
+            if (params.order !== undefined)
+                body.order = params.order;
+            const { data } = await this.http.post('/issues/_search', body, {
+                params: {
+                    perPage: params.perPage,
+                    page: params.page,
+                    expand: params.expand,
+                    fields: params.fields,
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getIssueComments(params) {
+        try {
+            const { data } = await this.http.get(`/issues/${encodeURIComponent(params.issueId)}/comments`, {
+                params: {
+                    perPage: params.perPage,
+                    expand: params.expand,
+                    id: params.afterId,
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getIssueLinks(issueId) {
+        try {
+            const { data } = await this.http.get(`/issues/${encodeURIComponent(issueId)}/links`);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getIssueTransitions(issueId) {
+        try {
+            const { data } = await this.http.get(`/issues/${encodeURIComponent(issueId)}/transitions`);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getIssueChangelog(params) {
+        try {
+            const { data } = await this.http.get(`/issues/${encodeURIComponent(params.issueId)}/changelog`, {
+                params: {
+                    perPage: params.perPage,
+                    id: params.afterId,
+                    field: params.field,
+                    type: params.type,
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getIssueAttachments(issueId) {
+        try {
+            const { data } = await this.http.get(`/issues/${encodeURIComponent(issueId)}`, {
+                params: { expand: 'attachments' },
+            });
+            const attachments = data?.attachments;
+            return Array.isArray(attachments) ? attachments : [];
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getUser(params) {
+        try {
+            const { data } = await this.http.get(`/users/${encodeURIComponent(params.userId)}`, {
+                params: { expand: params.expand },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async listUsers(params = {}) {
+        try {
+            const { data } = await this.http.get('/users', {
+                params: {
+                    perPage: params.perPage,
+                    id: params.id,
+                    email: params.email,
+                    expand: params.expand,
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async createIssue(params) {
+        try {
+            const body = {
+                queue: params.queue,
+                summary: params.summary,
+                ...(params.fields ?? {}),
+            };
+            if (params.description !== undefined)
+                body.description = params.description;
+            if (params.type !== undefined)
+                body.type = params.type;
+            if (params.priority !== undefined)
+                body.priority = params.priority;
+            if (params.assignee !== undefined)
+                body.assignee = params.assignee;
+            if (params.parent !== undefined)
+                body.parent = params.parent;
+            if (params.tags !== undefined)
+                body.tags = params.tags;
+            if (params.markupType !== undefined)
+                body.markupType = params.markupType;
+            const { data } = await this.http.post('/issues/', body);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async updateIssue(params) {
+        try {
+            const body = { ...(params.fields ?? {}) };
+            if (params.summary !== undefined)
+                body.summary = params.summary;
+            if (params.description !== undefined)
+                body.description = params.description;
+            if (params.type !== undefined)
+                body.type = params.type;
+            if (params.priority !== undefined)
+                body.priority = params.priority;
+            if (params.assignee !== undefined)
+                body.assignee = params.assignee;
+            if (params.parent !== undefined)
+                body.parent = params.parent;
+            if (params.tags !== undefined)
+                body.tags = params.tags;
+            if (params.markupType !== undefined)
+                body.markupType = params.markupType;
+            const { data } = await this.http.patch(`/issues/${encodeURIComponent(params.issueId)}`, body, { params: { version: params.version } });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async createIssueLink(params) {
+        try {
+            const { data } = await this.http.post(`/issues/${encodeURIComponent(params.issueId)}/links`, { relationship: params.relationship, issue: params.linkedIssueId });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async deleteIssueLink(params) {
+        try {
+            const { data } = await this.http.delete(`/issues/${encodeURIComponent(params.issueId)}/links/${encodeURIComponent(String(params.linkId))}`);
+            return data ?? { ok: true };
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async addIssueFollowers(params) {
+        try {
+            const { data } = await this.http.patch(`/issues/${encodeURIComponent(params.issueId)}`, { followers: { add: params.users } }, { params: { version: params.version } });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async removeIssueFollowers(params) {
+        try {
+            const { data } = await this.http.patch(`/issues/${encodeURIComponent(params.issueId)}`, { followers: { remove: params.users } }, { params: { version: params.version } });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getIssueWorklog(params) {
+        try {
+            const { data } = await this.http.get(`/issues/${encodeURIComponent(params.issueId)}/worklog`, {
+                params: {
+                    perPage: params.perPage,
+                    id: params.afterId,
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async addIssueWorklog(params) {
+        try {
+            const body = { duration: params.duration };
+            if (params.start !== undefined)
+                body.start = params.start;
+            if (params.comment !== undefined)
+                body.comment = params.comment;
+            const { data } = await this.http.post(`/issues/${encodeURIComponent(params.issueId)}/worklog`, body);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getQueueVersions(queueId) {
+        try {
+            const { data } = await this.http.get(`/queues/${encodeURIComponent(queueId)}/versions`);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getQueueComponents(queueId) {
+        try {
+            const { data } = await this.http.get(`/queues/${encodeURIComponent(queueId)}`, {
+                params: { expand: 'components' },
+            });
+            const components = data?.components;
+            return Array.isArray(components) ? components : [];
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async countIssues(params) {
+        try {
+            const body = {};
+            if (params.query !== undefined)
+                body.query = params.query;
+            if (params.filter !== undefined)
+                body.filter = params.filter;
+            const { data } = await this.http.post('/issues/_count', body);
+            return typeof data === 'number' ? { count: data } : data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async getIssueChecklist(issueId) {
+        try {
+            const { data } = await this.http.get(`/issues/${encodeURIComponent(issueId)}/checklistItems`);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async updateChecklistItem(params) {
+        try {
+            const body = {};
+            if (params.checked !== undefined)
+                body.checked = params.checked;
+            if (params.text !== undefined)
+                body.text = params.text;
+            const { data } = await this.http.patch(`/issues/${encodeURIComponent(params.issueId)}/checklistItems/${encodeURIComponent(params.itemId)}`, body);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async listBoards(params = {}) {
+        try {
+            const { data } = await this.http.get('/boards/', {
+                params: { perPage: params.perPage, page: params.page },
+            });
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async listBoardSprints(params) {
+        try {
+            const { data } = await this.http.get(`/boards/${encodeURIComponent(String(params.boardId))}/sprints`);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async uploadIssueAttachment(params) {
+        try {
+            const { readFile } = await import('fs/promises');
+            const path = await import('path');
+            const { Blob } = await import('buffer');
+            const fileBytes = await readFile(params.filePath);
+            const filename = params.filename || path.basename(params.filePath);
+            const form = new FormData();
+            form.append('file', new Blob([new Uint8Array(fileBytes)]), filename);
+            const { data } = await this.http.post(`/issues/${encodeURIComponent(params.issueId)}/attachments/`, form);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async addIssueComment(params) {
+        try {
+            const body = { text: params.text };
+            if (params.markupType !== undefined)
+                body.markupType = params.markupType;
+            if (params.summonees !== undefined)
+                body.summonees = params.summonees;
+            const { data } = await this.http.post(`/issues/${encodeURIComponent(params.issueId)}/comments`, body);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    async executeTransition(params) {
+        try {
+            const body = { ...(params.fields ?? {}) };
+            if (params.comment !== undefined)
+                body.comment = params.comment;
+            if (params.resolution !== undefined)
+                body.resolution = params.resolution;
+            const { data } = await this.http.post(`/issues/${encodeURIComponent(params.issueId)}/transitions/${encodeURIComponent(params.transitionId)}/_execute`, body);
+            return data;
+        }
+        catch (error) {
+            throw this.wrapError(error);
+        }
+    }
+    wrapError(error) {
+        if (axios.isAxiosError(error)) {
+            const ax = error;
+            const status = ax.response?.status;
+            const data = ax.response?.data;
+            const detail = data?.errorMessages?.join('; ') ||
+                (data?.errors ? JSON.stringify(data.errors) : undefined) ||
+                data?.message ||
+                data?.error ||
+                ax.message;
+            return new Error(status ? `API ${status}: ${detail}` : `API error: ${detail}`);
+        }
+        return error instanceof Error ? error : new Error(String(error));
+    }
+}
+export function createTrackerClient() {
+    const baseUrl = process.env.API_BASE_URL || DEFAULT_BASE_URL;
+    const token = process.env.API_TOKEN;
+    const orgId = process.env.X_ORG_ID;
+    if (!token || !orgId) {
+        throw new Error('Missing required environment variables: API_TOKEN and X_ORG_ID');
+    }
+    return new TrackerClient({
+        baseUrl,
+        token,
+        orgId,
+        sslVerify: process.env.API_SSL_VERIFY !== 'false',
+    });
+}
+//# sourceMappingURL=tracker-client.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createTrackerClient } from './client/tracker-client.js';
+import { registerAllTools } from './tools/index.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function readPackageVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+const server = new Server({
+    name: 'yandex-tracker-mcp',
+    version: readPackageVersion(),
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+const client = createTrackerClient();
+registerAllTools(server, () => client);
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('@mmtr-tech/yandex-tracker-mcp started');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/tools/boards.d.ts

@@ -0,0 +1,2 @@
+export declare function registerBoardTools(): void;
+//# sourceMappingURL=boards.d.ts.map

package/dist/tools/boards.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { registerTool } from './index.js';
+const listBoardsSchema = z.object({
+    perPage: z.coerce.number().int().positive().max(100).optional(),
+    page: z.coerce.number().int().positive().optional(),
+});
+const boardIdSchema = z.object({
+    boardId: z.union([z.string().min(1), z.coerce.number()]).describe('Board id'),
+});
+export function registerBoardTools() {
+    registerTool({
+        zodSchema: listBoardsSchema,
+        schema: {
+            name: 'list_boards',
+            description: 'List boards (GET /boards/). Paginated.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    perPage: { type: 'number' },
+                    page: { type: 'number' },
+                },
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().listBoards(args);
+        },
+    });
+    registerTool({
+        zodSchema: boardIdSchema,
+        schema: {
+            name: 'list_board_sprints',
+            description: 'List sprints for a board (GET /boards/{boardId}/sprints).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    boardId: { description: 'Board id', oneOf: [{ type: 'string' }, { type: 'number' }] },
+                },
+                required: ['boardId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().listBoardSprints(args);
+        },
+    });
+}
+//# sourceMappingURL=boards.js.map

package/dist/tools/index.d.ts

@@ -0,0 +1,24 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { ZodTypeAny } from 'zod';
+import type { TrackerClient } from '../client/tracker-client.js';
+export interface ToolDefinition {
+    schema: Tool;
+    zodSchema: ZodTypeAny;
+    execute: (args: any, getClient: () => TrackerClient) => Promise<any>;
+}
+export declare function registerTool(definition: ToolDefinition): void;
+export declare function getToolSchemas(): Tool[];
+export declare function getTool(name: string): ToolDefinition | undefined;
+export declare function clearToolRegistry(): void;
+export declare function initToolRegistry(): void;
+export declare function registerAllTools(server: Server, getClient: () => TrackerClient): void;
+/** Validate + execute (unit helpers). */
+export declare function callTool(name: string, args: unknown, getClient: () => TrackerClient): Promise<{
+    ok: true;
+    data: unknown;
+} | {
+    ok: false;
+    error: string;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,97 @@
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { truncatePayload } from '../utils/truncate.js';
+import { registerUserTools } from './users.js';
+import { registerQueueTools } from './queues.js';
+import { registerIssueTools } from './issues.js';
+import { registerIssueExtraTools } from './issue-extras.js';
+import { registerBoardTools } from './boards.js';
+const toolRegistry = new Map();
+export function registerTool(definition) {
+    toolRegistry.set(definition.schema.name, definition);
+}
+export function getToolSchemas() {
+    return Array.from(toolRegistry.values()).map((t) => t.schema);
+}
+export function getTool(name) {
+    return toolRegistry.get(name);
+}
+export function clearToolRegistry() {
+    toolRegistry.clear();
+}
+export function initToolRegistry() {
+    toolRegistry.clear();
+    registerUserTools();
+    registerQueueTools();
+    registerIssueTools();
+    registerIssueExtraTools();
+    registerBoardTools();
+}
+function formatZodError(error) {
+    return error.issues
+        .map((issue) => {
+        const path = issue.path.length ? issue.path.join('.') : '(root)';
+        return `${path}: ${issue.message}`;
+    })
+        .join('; ');
+}
+export function registerAllTools(server, getClient) {
+    initToolRegistry();
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: getToolSchemas() };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const tool = getTool(name);
+        if (!tool) {
+            return {
+                content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                isError: true,
+            };
+        }
+        const parsed = tool.zodSchema.safeParse(args ?? {});
+        if (!parsed.success) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Invalid arguments for ${name}: ${formatZodError(parsed.error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const result = await tool.execute(parsed.data, getClient);
+            const safe = truncatePayload(result);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(safe, null, 2) }],
+                isError: false,
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+/** Validate + execute (unit helpers). */
+export async function callTool(name, args, getClient) {
+    const tool = getTool(name);
+    if (!tool) {
+        return { ok: false, error: `Unknown tool: ${name}` };
+    }
+    const parsed = tool.zodSchema.safeParse(args ?? {});
+    if (!parsed.success) {
+        return { ok: false, error: `Invalid arguments for ${name}: ${formatZodError(parsed.error)}` };
+    }
+    try {
+        const data = await tool.execute(parsed.data, getClient);
+        return { ok: true, data };
+    }
+    catch (error) {
+        return { ok: false, error: error.message };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/tools/issue-extras.d.ts

@@ -0,0 +1,2 @@
+export declare function registerIssueExtraTools(): void;
+//# sourceMappingURL=issue-extras.d.ts.map