Что такое MCP сервер и как его создать. Часть 2

const logStream = fs.createWriteStream('/tmp/notes-mcp.log', { flags: 'a' });
 
function log(message: string, data?: any) {
  const entry = {
    timestamp: new Date().toISOString(),
    message,
    data
  };
  logStream.write(JSON.stringify(entry) + '\n');
}
 
// При инициализации
log('Server starting', { cwd: process.cwd(), env: process.env });

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 
const transport = new StdioClientTransport({
  command: 'node',
  args: ['./build/index.js']
});
 
const client = new Client({
  name: 'test-client',
  version: '1.0.0'
});
 
await client.connect(transport);
 
// Получаем список инструментов
const tools = await client.listTools();
console.log('Available tools:', tools);
 
// Вызываем инструмент
const result = await client.callTool('create_note', {
  title: 'Test',
  content: 'Content'
});
console.log('Result:', result);

// logger.ts
import fs from 'fs';
import path from 'path';
 
const LOG_FILE = process.env.MCP_LOG_FILE || '/tmp/mcp-server.log';
const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
 
const levels = { debug: 0, info: 1, warn: 2, error: 3 };
 
export function log(level: keyof typeof levels, msg: string, meta?: any) {
  if (levels[level] < levels[LOG_LEVEL]) return;
  
  const entry = {
    ts: new Date().toISOString(),
    level,
    msg,
    ...meta && { meta }
  };
  
  // stderr для критичных ошибок
  if (level === 'error') {
    console.error(JSON.stringify(entry));
  }
  
  // файл для всего остального
  fs.appendFileSync(LOG_FILE, JSON.stringify(entry) + '
');
}
 
// Отлавливаем необработанные исключения
process.on('uncaughtException', (error) => {
  log('error', 'Uncaught exception', { 
    message: error.message, 
    stack: error.stack 
  });
  process.exit(1);
});

import { Transform } from 'stream';
 
const logStdin = new Transform({
  transform(chunk, encoding, callback) {
    log('debug', 'Received from client', { data: chunk.toString() });
    callback(null, chunk);
  }
});
 
const logStdout = new Transform({
  transform(chunk, encoding, callback) {
    log('debug', 'Sending to client', { data: chunk.toString() });
    callback(null, chunk);
  }
});
 
process.stdin.pipe(logStdin).pipe(actualStdin);
actualStdout.pipe(logStdout).pipe(process.stdout);

type ToolHandler = (args: any) => Promise<any>;
type Middleware = (
  handler: ToolHandler,
  name: string,
  args: any
) => Promise<any>;
 
const middlewares: Middleware[] = [];
 
function use(middleware: Middleware) {
  middlewares.push(middleware);
}
 
// Логирование всех вызовов
use(async (handler, name, args) => {
  const start = Date.now();
  log('info', [INLINE]Calling ${name}[/INLINE], { args });
  
  try {
    const result = await handler(args);
    log('info', [INLINE]${name} completed[/INLINE], { 
      duration: Date.now() - start 
    });
    return result;
  } catch (error: any) {
    log('error', [INLINE]${name} failed[/INLINE], { 
      error: error.message,
      duration: Date.now() - start
    });
    throw error;
  }
});
 
// Применяем middleware при регистрации
function registerTool(name: string, handler: ToolHandler) {
  const wrapped = async (args: any) => {
    let fn = handler;
    
    // Оборачиваем в обратном порядке
    for (let i = middlewares.length - 1; i >= 0; i--) {
      const middleware = middlewares[i];
      const previousFn = fn;
      fn = (args) => middleware(previousFn, name, args);
    }
    
    return fn(args);
  };
  
  server.tool(name, /* ... */, wrapped);
}

const cache = new Map<string, { value: any; expires: number }>();
 
use(async (handler, name, args) => {
  // Только для read-операций
  if (!name.startsWith('get_') && !name.startsWith('list_')) {
    return handler(args);
  }
  
  const cacheKey = `${name}:${JSON.stringify(args)}`;
  const cached = cache.get(cacheKey);
  
  if (cached && cached.expires > Date.now()) {
    log('debug', 'Cache hit', { name, cacheKey });
    return cached.value;
  }
  
  const result = await handler(args);
  
  cache.set(cacheKey, {
    value: result,
    expires: Date.now() + 60000 // 1 минута
  });
  
  return result;
});

const rateLimits = new Map<string, number[]>();
 
use(async (handler, name, args) => {
  const key = name;
  const now = Date.now();
  const window = 60000; // 1 минута
  const limit = 10; // максимум вызовов
  
  const calls = rateLimits.get(key) || [];
  const recentCalls = calls.filter(t => now - t < window);
  
  if (recentCalls.length >= limit) {
    throw new Error(`Rate limit exceeded for ${name}`);
  }
  
  recentCalls.push(now);
  rateLimits.set(key, recentCalls);
  
  return handler(args);
});

const jobs = new Map<string, Promise<any>>();
 
server.tool('start_long_task', /* ... */, async (args) => {
  const jobId = randomUUID();
  
  jobs.set(jobId, (async () => {
    // Долгая работа
    await processLargeFile(args.filename);
    return { status: 'completed' };
  })());
  
  return { jobId, status: 'started' };
});
 
server.tool('get_job_status', /* ... */, async ({ jobId }) => {
  const job = jobs.get(jobId);
  if (!job) return { status: 'not_found' };
  
  try {
    const result = await Promise.race([
      job,
      new Promise((_, reject) => 
        setTimeout(() => reject('pending'), 100)
      )
    ]);
    
    jobs.delete(jobId);
    return { status: 'completed', result };
  } catch {
    return { status: 'pending' };
  }
});

server.resource(
  "note:///{filename}",
  "Markdown заметка по имени файла",
  async (uri) => {
    // Извлекаем filename из URI
    const filename = uri.path.replace(/^\//, "");
    const filepath = path.join(NOTES_DIR, filename);
    
    try {
      const content = await fs.readFile(filepath, "utf-8");
      
      return {
        contents: [{
          uri: uri.toString(),
          mimeType: "text/markdown",
          text: content
        }]
      };
    } catch (error: any) {
      if (error.code === "ENOENT") {
        throw new Error(`Заметка не найдена: ${filename}`);
      }
      throw error;
    }
  }
);

server.listResources(async () => {
  const files = await fs.readdir(NOTES_DIR);
  const mdFiles = files.filter(f => f.endsWith(".md"));
  
  return {
    resources: mdFiles.map(filename => ({
      uri: [INLINE]note:///${filename}[/INLINE],
      name: filename.replace(/\.md$/, ""),
      description: [INLINE]Заметка: ${filename}[/INLINE],
      mimeType: "text/markdown"
    }))
  };
});

server.prompt(
  "summarize_notes",
  "Создаёт промпт для саммаризации заметок по теме",
  {
    topic: z.string().describe("Тема для поиска заметок")
  },
  async ({ topic }) => {
    // Ищем релевантные заметки
    const files = await fs.readdir(NOTES_DIR);
    const relevant = [];
    
    for (const file of files) {
      const content = await fs.readFile(
        path.join(NOTES_DIR, file), 
        "utf-8"
      );
      
      if (content.toLowerCase().includes(topic.toLowerCase())) {
        relevant.push(content);
      }
    }
    
    const notesText = relevant.join("\n\n---\n\n");
    
    return {
      messages: [{
        role: "user",
        content: {
          type: "text",
          text: `Проанализируй следующие заметки по теме "${topic}" и составь краткое резюме:
 
${notesText}`
        }
      }]
    };
  }
);

server.tool(
  "update_task_status",
  "Обновляет статус задачи в трекере. Используй когда пользователь хочет изменить состояние задачи.",
  {
    task_id: z.string()
      .regex(/^TASK-\d+$/)
      .describe("Идентификатор задачи в формате TASK-123"),
    status: z.enum(["todo", "in_progress", "review", "done"])
      .describe("Новый статус задачи"),
    comment: z.string()
      .optional()
      .describe("Опциональный комментарий к изменению")
  },
  async ({ task_id, status, comment }) => {
    // Проверяем существование задачи
    const task = await db.tasks.findOne({ id: task_id });
    if (!task) {
      throw new Error(`Задача ${task_id} не найдена`);
    }
    
    // Валидация переходов статуса
    const validTransitions = {
      todo: ["in_progress"],
      in_progress: ["review", "todo"],
      review: ["done", "in_progress"],
      done: []
    };
    
    if (!validTransitions[task.status]?.includes(status)) {
      throw new Error(
        [INLINE]Нельзя перейти из ${task.status} в ${status}[/INLINE]
      );
    }
    
    // Обновляем
    await db.tasks.updateOne(
      { id: task_id },
      { 
        $set: { status },
        $push: { 
          history: {
            timestamp: new Date(),
            from: task.status,
            to: status,
            comment
          }
        }
      }
    );
    
    return {
      content: [{
        type: "text",
        text: [INLINE]Задача ${task_id} переведена в статус ${status}[/INLINE]
      }]
    };
  }
);

// Простое хранилище состояния
interface SessionState {
  dbConnection?: any;
  cache: Map<string, any>;
  lastActivity: number;
}
 
const sessions = new Map<string, SessionState>();
 
function getSession(clientId: string): SessionState {
  if (!sessions.has(clientId)) {
    sessions.set(clientId, {
      cache: new Map(),
      lastActivity: Date.now()
    });
  }
  
  const session = sessions.get(clientId)!;
  session.lastActivity = Date.now();
  return session;
}
 
// Очистка неактивных сессий
setInterval(() => {
  const timeout = 30 * 60 * 1000; // 30 минут
  const now = Date.now();
  
  for (const [id, session] of sessions) {
    if (now - session.lastActivity > timeout) {
      // Закрываем ресурсы
      session.dbConnection?.close();
      sessions.delete(id);
    }
  }
}, 60000);

server.tool("list_recent_files", /* ... */, async ({ count = 5 }) => {
  const files = await getRecentFiles(count);
  
  // Сохраняем список в сессии для следующих запросов
  const session = getSession(currentClientId);
  session.cache.set('last_file_list', files);
  
  return {
    content: [{
      type: "text",
      text: files.map((f, i) => `${i + 1}. ${f.name}`).join('\n')
    }],
    // Метаданные для клиента
    metadata: {
      files: files.map(f => ({ id: f.id, name: f.name }))
    }
  };
});
 
server.tool("open_file_by_index", /* ... */, async ({ index }) => {
  const session = getSession(currentClientId);
  const lastList = session.cache.get('last_file_list');
  
  if (!lastList) {
    throw new Error("Сначала получите список файлов");
  }
  
  const file = lastList[index - 1];
  if (!file) {
    throw new Error(`Файл с индексом ${index} не найден`);
  }
  
  const content = await fs.readFile(file.path, 'utf-8');
  return { content: [{ type: "text", text: content }] };
});

class SizeAwareLRUCache<K, V> {
  private cache = new Map<K, { value: V; size: number; timestamp: number }>();
  private maxBytes: number;
  private currentBytes = 0;
 
  constructor(maxBytes: number) {
    this.maxBytes = maxBytes;
  }
 
  // Грубая оценка размера объекта в байтах
  private estimateSize(value: any): number {
    const json = JSON.stringify(value);
    return json.length * 2; // UTF-16, два байта на символ
  }
 
  set(key: K, value: V): void {
    const size = this.estimateSize(value);
    
    // Выкидываем старые записи пока не поместимся
    while (this.currentBytes + size > this.maxBytes && this.cache.size > 0) {
      const oldest = Array.from(this.cache.entries())
        .sort((a, b) => a[1].timestamp - b[1].timestamp)[0];
      
      this.currentBytes -= oldest[1].size;
      this.cache.delete(oldest[0]);
    }
 
    this.cache.set(key, { value, size, timestamp: Date.now() });
    this.currentBytes += size;
  }
 
  get(key: K): V | undefined {
    const entry = this.cache.get(key);
    if (!entry) return undefined;
 
    // Обновляем timestamp при чтении
    entry.timestamp = Date.now();
    return entry.value;
  }
 
  clear(): void {
    this.cache.clear();
    this.currentBytes = 0;
  }
}
 
// Использование
const cache = new SizeAwareLRUCache<string, any>(50 * 1024 * 1024); // 50MB

import readline from 'readline';
 
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});
 
rl.on('line', (line) => {
  try {
    const message = JSON.parse(line);
    handleMessage(message);
  } catch (error) {
    log('error', 'Failed to parse message', { line, error });
  }
});

const content = await fs.readFile(filepath, { encoding: 'utf8' });
// Явная проверка что это валидный UTF-8
if (Buffer.from(content).toString('utf8') !== content) {
  throw new Error('Invalid UTF-8 encoding in file');
}

class AsyncMutex {
  private locked = false;
  private queue: (() => void)[] = [];
 
  async acquire(): Promise<void> {
    return new Promise(resolve => {
      if (!this.locked) {
        this.locked = true;
        resolve();
      } else {
        this.queue.push(resolve);
      }
    });
  }
 
  release(): void {
    if (this.queue.length > 0) {
      const next = this.queue.shift()!;
      next();
    } else {
      this.locked = false;
    }
  }
}
 
const cacheMutex = new AsyncMutex();
 
async function updateCache(key: string, value: any) {
  await cacheMutex.acquire();
  try {
    cache.set(key, value);
  } finally {
    cacheMutex.release();
  }
}

const isWindows = process.platform === 'win32';
 
function normalizePath(p: string): string {
  const normalized = path.normalize(p);
  return isWindows ? normalized.toLowerCase() : normalized;
}

// Sticky sessions через хэш client_id
upstream mcp_servers {
  ip_hash;  // или hash $http_x_client_id consistent;
  
  server 127.0.0.1:3001;
  server 127.0.0.1:3002;
  server 127.0.0.1:3003;
}
 
// В конфиге nginx
location /mcp {
  proxy_pass [url]http://mcp_servers;[/url]
  proxy_http_version 1.1;
  proxy_set_header Upgrade $http_upgrade;
  proxy_set_header Connection "upgrade";
}

const pool = new Pool({
  host: 'localhost',
  database: 'mcp_data',
  max: 20, // максимум соединений
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});
 
// Запрос с автоматическим возвратом в пул
async function queryDB(sql: string, params: any[]) {
  const client = await pool.connect();
  try {
    const result = await client.query(sql, params);
    return result.rows;
  } finally {
    client.release(); // возвращаем в пул
  }
}

server.tool("delete_note", /* ... */, async ({ filename }) => {
try {
  const filepath = path.join(NOTES_DIR, filename);
  await fs.access(filepath);
  await fs.unlink(filepath);
  
  return { content: [{ type: "text", text: [INLINE]Удалено: ${filename}[/INLINE] }] };
} catch (error: any) {
  // Разные типы ошибок обрабатываем по-разному
  if (error.code === 'ENOENT') {
    throw new Error(`Файл ${filename} не существует`);
  }
  
  if (error.code === 'EACCES') {
    throw new Error(`Нет прав на удаление ${filename}`);
  }
  
  // Неожиданная ошибка - логируем детально
  log('error', 'Delete failed', { filename, error: error.message, stack: error.stack });
  throw new Error(`Ошибка при удалении файла: ${error.message}`);
}
});

async function retryWithBackoff<T>(
fn: () => Promise<T>,
maxAttempts: number = 3
): Promise<T> {
let lastError: Error;
 
for (let attempt = 1; attempt <= maxAttempts; attempt++) {
  try {
    return await fn();
  } catch (error: any) {
    lastError = error;
    
    // Не ретраим некоторые ошибки
    if (error.code === 'ENOENT' || error.message.includes('not found')) {
      throw error;
    }
    
    if (attempt < maxAttempts) {
      const delay = Math.pow(2, attempt - 1) * 1000;
      log('warn', `Attempt ${attempt} failed, retrying in ${delay}ms`, { error: error.message });
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}
 
throw lastError!;
}
 
// Использование
const data = await retryWithBackoff(() => 
fetchFromAPI('https://api.example.com/data')
);

server.onInitialize((params) => {
  const clientCaps = params.capabilities;
  
  // Проверяем нужные нам возможности
  const hasToolsSupport = clientCaps.tools !== undefined;
  const hasResourcesSupport = clientCaps.resources !== undefined;
  
  if (!hasToolsSupport) {
    log('warn', 'Client does not support tools, limited functionality');
    disableToolsFeatures();
  }
  
  // Возвращаем только то что клиент поймёт
  return {
    protocolVersion: params.protocolVersion,
    capabilities: {
      ...(hasToolsSupport && { tools: {} }),
      ...(hasResourcesSupport && { resources: {} })
    }
  };
});

process.on('uncaughtException', (error) => {
  // Логируем в stderr, не в stdout!
  console.error('Fatal error:', error);
  logToFile('uncaught_exception', error);
  process.exit(1);
});
 
process.on('unhandledRejection', (reason) => {
  console.error('Unhandled promise rejection:', reason);
  logToFile('unhandled_rejection', reason);
});

// Схема пропустит, но это опасно
const filename = args.filename; // "../../etc/passwd"
 
// Явная проверка безопасности
if (filename.includes('..') || path.isAbsolute(filename)) {
  throw new Error('Invalid filename: path traversal detected');
}

import { spawn } from 'child_process';
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 
describe('MCP Server Integration', () => {
  let serverProcess: any;
  let messageId = 0;
 
  beforeAll(() => {
    serverProcess = spawn('node', ['./build/index.js']);
  });
 
  afterAll(() => {
    serverProcess.kill();
  });
 
  async function sendRequest(method: string, params: any): Promise<any> {
    const id = ++messageId;
    const request = JSON.stringify({
      jsonrpc: '2.0',
      id,
      method,
      params
    }) + '
';
 
    return new Promise((resolve, reject) => {
      const timeout = setTimeout(() => reject('Timeout'), 5000);
      
      serverProcess.stdout.once('data', (data: Buffer) => {
        clearTimeout(timeout);
        const lines = data.toString().split('
').filter(Boolean);
        const response = JSON.parse(lines[lines.length - 1]);
        
        if (response.error) reject(response.error);
        else resolve(response.result);
      });
 
      serverProcess.stdin.write(request);
    });
  }
 
  it('should initialize correctly', async () => {
    const result = await sendRequest('initialize', {
      protocolVersion: '2024-11-05',
      capabilities: {},
      clientInfo: { name: 'test', version: '1.0' }
    });
 
    expect(result.protocolVersion).toBe('2024-11-05');
    expect(result.capabilities).toBeDefined();
  });
 
  it('should list available tools', async () => {
    const tools = await sendRequest('tools/list', {});
    expect(Array.isArray(tools.tools)).toBe(true);
    expect(tools.tools.length).toBeGreaterThan(0);
  });
 
  it('should call tool with valid params', async () => {
    const result = await sendRequest('tools/call', {
      name: 'create_note',
      arguments: {
        title: 'Test Note',
        content: 'Test content'
      }
    });
 
    expect(result.content).toBeDefined();
    expect(result.content[0].text).toContain('создана');
  });
});

// src/index.ts - главный файл сервера
#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { taskModule } from "./modules/tasks.js";
import { docModule } from "./modules/docs.js";
import { notificationModule } from "./modules/notifications.js";
import { StateManager } from "./state/manager.js";
import { Logger } from "./utils/logger.js";
 
const logger = new Logger('project-mcp');
const state = new StateManager();
 
const server = new McpServer({
  name: "project-management-mcp",
  version: "1.0.0",
  capabilities: {
    tools: {},
    resources: {},
    prompts: {}
  }
});
 
// Регистрируем модули
taskModule.register(server, state, logger);
docModule.register(server, state, logger);
notificationModule.register(server, state, logger);
 
// Глобальная обработка ошибок
process.on('uncaughtException', (error) => {
  logger.error('Uncaught exception', { error: error.message, stack: error.stack });
  process.exit(1);
});
 
process.on('unhandledRejection', (reason) => {
  logger.error('Unhandled rejection', { reason });
});
 
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  
  logger.info('Project Management MCP Server started');
  
  // Периодическая очистка устаревшего состояния
  setInterval(() => {
    state.cleanup();
  }, 60000);
}
 
main().catch((error) => {
  logger.error('Fatal error', { error });
  process.exit(1);
});

// src/modules/tasks.ts
import { z } from "zod";
 
const TaskStatus = z.enum(['backlog', 'todo', 'in_progress', 'review', 'done']);
const TaskPriority = z.enum(['low', 'medium', 'high', 'critical']);
 
export const taskModule = {
  register(server: any, state: any, logger: any) {
    
    server.tool(
      "create_task",
      "Создаёт новую задачу в проекте с указанными параметрами",
      {
        title: z.string().min(3).max(200)
          .describe("Заголовок задачи"),
        description: z.string().optional()
          .describe("Подробное описание задачи"),
        priority: TaskPriority.default('medium')
          .describe("Приоритет: low, medium, high, critical"),
        assignee: z.string().optional()
          .describe("Кому назначена задача"),
        tags: z.array(z.string()).default([])
          .describe("Теги для категоризации")
      },
      async (args) => {
        logger.info('Creating task', { title: args.title });
        
        try {
          const taskId = `TASK-${Date.now()}`;
          const task = {
            id: taskId,
            status: 'backlog',
            createdAt: new Date().toISOString(),
            history: [],
            ...args
          };
          
          // Сохраняем в состояние с кэшированием
          await state.tasks.set(taskId, task);
          
          // Уведомление если назначен исполнитель
          if (args.assignee) {
            await state.notifications.add({
              type: 'task_assigned',
              taskId,
              assignee: args.assignee,
              timestamp: new Date().toISOString()
            });
          }
          
          return {
            content: [{
              type: "text",
              text: `Задача ${taskId} создана успешно
Статус: backlog
Приоритет: ${args.priority}`
            }]
          };
        } catch (error: any) {
          logger.error('Failed to create task', { error: error.message, args });
          throw new Error(`Ошибка создания задачи: ${error.message}`);
        }
      }
    );
 
    server.tool(
      "update_task_status",
      "Обновляет статус задачи с проверкой валидности перехода",
      {
        taskId: z.string()
          .regex(/^TASK-\d+$/)
          .describe("Идентификатор задачи"),
        status: TaskStatus
          .describe("Новый статус задачи"),
        comment: z.string().optional()
          .describe("Комментарий к изменению")
      },
      async (args) => {
        const task = await state.tasks.get(args.taskId);
        
        if (!task) {
          throw new Error(`Задача ${args.taskId} не найдена`);
        }
        
        // Валидация переходов статуса
        const validTransitions: Record<string, string[]> = {
          backlog: ['todo'],
          todo: ['in_progress', 'backlog'],
          in_progress: ['review', 'todo'],
          review: ['done', 'in_progress'],
          done: ['todo']  // реопен
        };
        
        const allowed = validTransitions[task.status] || [];
        if (!allowed.includes(args.status)) {
          throw new Error(
            [INLINE]Нельзя перевести задачу из ${task.status} в ${args.status}. [/INLINE] +
            `Доступны: ${allowed.join(', ')}`
          );
        }
        
        // Записываем в историю
        task.history.push({
          timestamp: new Date().toISOString(),
          from: task.status,
          to: args.status,
          comment: args.comment
        });
        
        task.status = args.status;
        task.updatedAt = new Date().toISOString();
        
        await state.tasks.set(args.taskId, task);
        
        logger.info('Task status updated', { 
          taskId: args.taskId, 
          from: task.history[task.history.length - 1].from,
          to: args.status 
        });
        
        return {
          content: [{
            type: "text",
            text: [INLINE]Статус задачи ${args.taskId} изменён: ${task.status} → ${args.status}[/INLINE]
          }]
        };
      }
    );
 
    // Ресурс для получения полной информации о задаче
    server.resource(
      "task:///{taskId}",
      "Детальная информация о задаче включая историю изменений",
      async (uri: any) => {
        const taskId = uri.path.replace(/^\//, '');
        const task = await state.tasks.get(taskId);
        
        if (!task) {
          throw new Error(`Задача ${taskId} не найдена`);
        }
        
        const content = `# ${task.title}
 
[B]ID:[/B] ${task.id}
[B]Статус:[/B] ${task.status}
[B]Приоритет:[/B] ${task.priority}
[B]Создана:[/B] ${task.createdAt}
${task.assignee ? `[B]Исполнитель:[/B] ${task.assignee}` : ''}
${task.tags.length > 0 ? `[B]Теги:[/B] ${task.tags.join(', ')}` : ''}
 
[H2]Описание[/H2]
 
${task.description || 'Нет описания'}
 
[H2]История изменений[/H2]
 
${task.history.map((h: any) => 
  [INLINE]- ${h.timestamp}: ${h.from} → ${h.to}${h.comment ? [/INLINE] (${h.comment})` : ''}`
).join('
')}`;
        
        return {
          contents: [{
            uri: uri.toString(),
            mimeType: "text/markdown",
            text: content
          }]
        };
      }
    );
  }
};

// src/state/manager.ts
import fs from 'fs/promises';
import path from 'path';
 
export class StateManager {
  private tasks = new Map<string, any>();
  private docs = new Map<string, any>();
  private notifications: any[] = [];
  private cache: any;
  private stateDir = process.env.STATE_DIR || './.mcp-state';
  
  constructor() {
    this.cache = new SizeAwareLRUCache(50 * 1024 * 1024); // 50MB
    this.loadState();
  }
  
  async loadState() {
    try {
      await fs.mkdir(this.stateDir, { recursive: true });
      
      const tasksFile = path.join(this.stateDir, 'tasks.json');
      if (await fs.access(tasksFile).then(() => true).catch(() => false)) {
        const data = await fs.readFile(tasksFile, 'utf-8');
        const tasks = JSON.parse(data);
        Object.entries(tasks).forEach(([id, task]) => {
          this.tasks.set(id, task);
        });
      }
    } catch (error) {
      console.error('Failed to load state:', error);
    }
  }
  
  async saveState() {
    try {
      const tasksFile = path.join(this.stateDir, 'tasks.json');
      const tasksObj = Object.fromEntries(this.tasks.entries());
      await fs.writeFile(tasksFile, JSON.stringify(tasksObj, null, 2));
    } catch (error) {
      console.error('Failed to save state:', error);
    }
  }
  
  get tasks() {
    return {
      get: async (id: string) => {
        // Проверяем кэш сначала
        const cached = this.cache.get(`task:${id}`);
        if (cached) return cached;
        
        const task = this.tasks.get(id);
        if (task) {
          this.cache.set(`task:${id}`, task);
        }
        return task;
      },
      
      set: async (id: string, task: any) => {
        this.tasks.set(id, task);
        this.cache.set(`task:${id}`, task);
        await this.saveState();
      },
      
      list: async (filter?: any) => {
        const allTasks = Array.from(this.tasks.values());
        if (!filter) return allTasks;
        
        return allTasks.filter(task => {
          if (filter.status && task.status !== filter.status) return false;
          if (filter.assignee && task.assignee !== filter.assignee) return false;
          if (filter.priority && task.priority !== filter.priority) return false;
          return true;
        });
      }
    };
  }
  
  cleanup() {
    // Очищаем уведомления старше суток
    const dayAgo = Date.now() - 24 * 60 * 60 * 1000;
    this.notifications = this.notifications.filter(n => 
      new Date(n.timestamp).getTime() > dayAgo
    );
  }
}