@ainote/mcp 1.0.2 → 1.1.0

package/lib/tools/onboarding-tools.js

@@ -0,0 +1,124 @@
+import axios from 'axios';
+import { getConfig } from '../core/config-manager.js';
+import { toErrorContent } from './internal/formatters.js';
+
+/**
+ * Onboarding tools for signup/login without API key.
+ * These tools call the Rails API directly (no auth headers).
+ */
+
+function signupDefinition() {
+  return {
+    name: 'signup_and_get_key',
+    description: `Create a new AI Note account and get an MCP API key. No authentication required.
+Use this if you don't have an account yet. After getting the key, add it to your MCP config and restart.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: { type: 'string', description: 'Email address for the new account' },
+        password: { type: 'string', description: 'Password (minimum 6 characters)' },
+        name: { type: 'string', description: 'Display name (optional)' }
+      },
+      required: ['email', 'password']
+    }
+  };
+}
+
+function loginDefinition() {
+  return {
+    name: 'login_and_get_key',
+    description: `Log in to an existing AI Note account and get an MCP API key. No authentication required.
+Use this if you already have an account but need your MCP key.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: { type: 'string', description: 'Your account email address' },
+        password: { type: 'string', description: 'Your account password' }
+      },
+      required: ['email', 'password']
+    }
+  };
+}
+
+function setupGuideDefinition() {
+  return {
+    name: 'get_setup_guide',
+    description: 'Get instructions for setting up AI Note MCP in Claude Desktop, Cursor, or other MCP clients. Includes CLI signup method (npx @ainote/mcp signup). No authentication required.',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  };
+}
+
+/**
+ * Call Rails MCP API directly without auth headers (for onboarding tools).
+ */
+async function callOnboardingTool(toolName, args = {}) {
+  const config = getConfig();
+  const rpcRequest = {
+    jsonrpc: '2.0',
+    id: Date.now(),
+    method: 'tools/call',
+    params: { name: toolName, arguments: args }
+  };
+
+  const response = await axios.post(`${config.api.url}/api/mcp`, rpcRequest, {
+    headers: { 'Content-Type': 'application/json' },
+    timeout: 30000
+  });
+
+  if (response.data?.data?.error) {
+    const err = response.data.data.error;
+    throw new Error(err.message || 'Onboarding tool call failed');
+  }
+
+  // Rails wraps in { success: true, data: { jsonrpc, id, result } }
+  const rpcResult = response.data?.data?.result;
+  if (rpcResult) {
+    return rpcResult;
+  }
+
+  // Fallback: return the raw response content
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(response.data, null, 2)
+    }]
+  };
+}
+
+export function getOnboardingTools() {
+  return [
+    {
+      definition: signupDefinition(),
+      handler: async (args) => {
+        try {
+          return await callOnboardingTool('signup_and_get_key', args);
+        } catch (error) {
+          return toErrorContent(error);
+        }
+      }
+    },
+    {
+      definition: loginDefinition(),
+      handler: async (args) => {
+        try {
+          return await callOnboardingTool('login_and_get_key', args);
+        } catch (error) {
+          return toErrorContent(error);
+        }
+      }
+    },
+    {
+      definition: setupGuideDefinition(),
+      handler: async () => {
+        try {
+          return await callOnboardingTool('get_setup_guide');
+        } catch (error) {
+          return toErrorContent(error);
+        }
+      }
+    }
+  ];
+}

package/lib/tools/shared-tools.js

@@ -0,0 +1,246 @@
+import { toSuccessContent, enhanceWithStructuredData } from './internal/formatters.js';
+
+function listTasksDefinition() {
+  return {
+    name: 'list_tasks',
+    description: `List tasks from AI Note with natural language support and advanced filtering.
+
+NATURAL LANGUAGE EXAMPLES:
+• Location: "여의도에서", "서울에 있는", "강남 관련"
+• Time: "오늘", "이번 주", "다음 주", "지난달", "1월에"
+• Importance: "중요한", "우선순위 높은", "급한"
+• Status: "완료한", "미완료", "안 끝난"
+• Special: "마감일 지난", "늦어진", "오늘 마감", "알림 설정된"
+• Sort: "마감일 순으로", "최신순으로", "오래된 순으로"
+
+QUERY EXAMPLES:
+1. "여의도에서 이번 주 마감인 중요한 미완료 할일"
+   → {location: "여의도", due_date_start: "2025-01-27", due_date_end: "2025-02-02",
+       is_important: true, status: "pending"}
+
+2. "지난달 완료한 업무 카테고리 할일들을 완료일 순으로"
+   → {category_id: "...", status: "completed",
+       completed_date_start: "2024-12-01", completed_date_end: "2024-12-31",
+       sort_by: "completed_at", sort_order: "asc"}
+
+3. "마감일 지났는데 아직 안 끝난 할일들 마감일 빠른 순으로"
+   → {overdue: true, sort_by: "due_date", sort_order: "asc"}
+
+TIME CALCULATIONS (today = 2025-01-27):
+• "오늘" → due_today: true
+• "이번 주" → due_date_start: "2025-01-27", due_date_end: "2025-02-02"
+• "다음 주" → due_date_start: "2025-02-03", due_date_end: "2025-02-09"
+• "이번 달" → due_date_start: "2025-01-01", due_date_end: "2025-01-31"
+• "지난 주" → completed_date_start: "2025-01-20", completed_date_end: "2025-01-26"
+• "지난 달" → completed_date_start: "2024-12-01", completed_date_end: "2024-12-31"
+
+Returns structured data with all task fields including location, dates, and categories.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: {
+          type: 'string',
+          enum: ['pending', 'completed'],
+          description: 'Filter by task status'
+        },
+        is_important: {
+          type: 'boolean',
+          description: 'Filter by important tasks only'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of tasks to return (default: 25, max: 500)'
+        },
+        search: {
+          type: 'string',
+          description: 'Search keyword in task content'
+        },
+        location: {
+          type: 'string',
+          description: 'Filter by location (partial match, e.g., "여의도", "서울")'
+        },
+        category_id: {
+          type: 'string',
+          description: 'Filter by category UUID'
+        },
+        due_date_start: {
+          type: 'string',
+          description: 'Filter tasks with due_date >= this date (ISO 8601 format)'
+        },
+        due_date_end: {
+          type: 'string',
+          description: 'Filter tasks with due_date <= this date (ISO 8601 format)'
+        },
+        completed_date_start: {
+          type: 'string',
+          description: 'Filter tasks completed >= this date (ISO 8601 format)'
+        },
+        completed_date_end: {
+          type: 'string',
+          description: 'Filter tasks completed <= this date (ISO 8601 format)'
+        },
+        created_date_start: {
+          type: 'string',
+          description: 'Filter tasks created >= this date (ISO 8601 format)'
+        },
+        created_date_end: {
+          type: 'string',
+          description: 'Filter tasks created <= this date (ISO 8601 format)'
+        },
+        overdue: {
+          type: 'boolean',
+          description: 'Filter overdue incomplete tasks (due_date < today)'
+        },
+        due_today: {
+          type: 'boolean',
+          description: 'Filter tasks due today'
+        },
+        has_notification: {
+          type: 'boolean',
+          description: 'Filter by notification enabled status'
+        },
+        sort_by: {
+          type: 'string',
+          enum: ['due_date', 'created_at', 'completed_at', 'updated_at', 'is_important'],
+          description: 'Sort field (default: created_at)'
+        },
+        sort_order: {
+          type: 'string',
+          enum: ['asc', 'desc'],
+          description: 'Sort order (default: desc)'
+        }
+      }
+    }
+  };
+}
+
+function createTaskDefinition() {
+  return {
+    name: 'create_task',
+    description: 'Create a new task in AI Note with optional notification',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'Task content'
+        },
+        is_important: {
+          type: 'boolean',
+          description: 'Mark task as important'
+        },
+        due_date: {
+          type: 'string',
+          description: 'Due date in ISO format'
+        },
+        category_id: {
+          type: 'string',
+          description: 'Category ID'
+        },
+        notification_minutes_before: {
+          type: 'number',
+          description: 'Set notification X minutes before due_date (e.g., 5 for 5 minutes before, 60 for 1 hour before). Requires due_date to be set.'
+        }
+      },
+      required: ['content']
+    }
+  };
+}
+
+function updateTaskDefinition() {
+  return {
+    name: 'update_task',
+    description: 'Update an existing task',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          description: 'Task ID'
+        },
+        content: {
+          type: 'string',
+          description: 'New task content'
+        },
+        is_important: {
+          type: 'boolean',
+          description: 'Update important status'
+        },
+        completed_at: {
+          type: 'string',
+          description: 'Mark as completed (ISO format) or null to uncomplete'
+        }
+      },
+      required: ['id']
+    }
+  };
+}
+
+function deleteTaskDefinition() {
+  return {
+    name: 'delete_task',
+    description: 'Delete a task (soft delete)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          description: 'Task ID to delete'
+        }
+      },
+      required: ['id']
+    }
+  };
+}
+
+function listCategoriesDefinition() {
+  return {
+    name: 'list_categories',
+    description: 'List all categories',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  };
+}
+
+export function getSharedTools() {
+  return [
+    {
+      definition: listTasksDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('list_tasks', args);
+        // Enhance result with parsed structured data
+        return enhanceWithStructuredData(result);
+      }
+    },
+    {
+      definition: createTaskDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('create_task', args);
+        return result;  // Return full result with { content: [...] }
+      }
+    },
+    {
+      definition: updateTaskDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('update_task', args);
+        return result;  // Return full result with { content: [...] }
+      }
+    },
+    {
+      definition: deleteTaskDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('delete_task', args);
+        return result;  // Return full result with { content: [...] }
+      }
+    },
+    {
+      definition: listCategoriesDefinition(),
+      handler: async (_args, { apiClient }) => {
+        const result = await apiClient.callTool('list_categories', {});
+        return result;  // Return full result with { content: [...] }
+      }
+    }
+  ];
+}

package/lib/utils/api-client.js

@@ -0,0 +1,79 @@
+import axios from 'axios';
+import { getConfig } from '../core/config-manager.js';
+
+function buildHeaders(authContext, config) {
+  const headers = {
+    'Content-Type': 'application/json'
+  };
+
+  const contextType = authContext?.type ?? 'mcpKey';
+
+  if (contextType === 'anonymous') {
+    // No auth headers for anonymous mode (onboarding tools)
+    return headers;
+  }
+
+  if (contextType === 'oauth') {
+    const bearerToken = authContext?.token;
+    if (!bearerToken) {
+      throw new Error('OAuth authentication requires a bearer token');
+    }
+    headers.Authorization = `Bearer ${bearerToken}`;
+  } else {
+    const apiKey = authContext?.apiKey ?? config.api.key;
+    if (!apiKey) {
+      throw new Error('AINOTE_API_KEY environment variable is required for MCP authentication');
+    }
+    headers.Authorization = `McpKey ${apiKey}`;
+  }
+
+  return headers;
+}
+
+let requestIdCounter = 1;
+
+/**
+ * JSON-RPC 2.0 요청 생성 헬퍼
+ */
+function createJsonRpcRequest(method, params = {}) {
+  return {
+    jsonrpc: '2.0',
+    id: requestIdCounter++,
+    method,
+    params
+  };
+}
+
+/**
+ * JSON-RPC 2.0 tools/call 요청 생성
+ */
+function createToolCallRequest(toolName, arguments_) {
+  return createJsonRpcRequest('tools/call', {
+    name: toolName,
+    arguments: arguments_
+  });
+}
+
+export function createApiClient(authContext) {
+  const config = getConfig();
+  const headers = buildHeaders(authContext, config);
+
+  const axiosInstance = axios.create({
+    baseURL: config.api.url,
+    headers
+  });
+
+  // JSON-RPC helper 메서드 추가
+  axiosInstance.callTool = async (toolName, arguments_) => {
+    const rpcRequest = createToolCallRequest(toolName, arguments_);
+    const response = await axiosInstance.post('/api/mcp', rpcRequest);
+
+    if (response.data.error) {
+      throw new Error(`JSON-RPC Error [${response.data.error.code}]: ${response.data.error.message}`);
+    }
+
+    return response.data.result;
+  };
+
+  return axiosInstance;
+}

package/package.json

@@ -1,24 +1,36 @@
 {
   "name": "@ainote/mcp",
-  "version": "1.0.2",
-  "description": "MCP server for AI Note - Connect Claude Desktop to your AI Note tasks",
+  "version": "1.1.0",
+  "description": "MCP server for AI Note - Tasks + Dev Docs (CLAUDE.md, Cursor rules, Windsurf rules) management via MCP",
   "main": "index.js",
   "type": "module",
   "bin": {
-    "ainote-mcp": "./index.js"
+    "ainote-mcp": "./index.js",
+    "ainote-mcp-http": "./server.js"
   },
   "scripts": {
     "start": "node index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "start:http": "node server.js",
+    "test": "NODE_ENV=test NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "NODE_ENV=test NODE_OPTIONS=--experimental-vm-modules jest --watch",
+    "test:coverage": "NODE_ENV=test NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+    "test:verbose": "NODE_ENV=test NODE_OPTIONS=--experimental-vm-modules jest --verbose"
   },
   "keywords": [
     "mcp",
     "modelcontextprotocol",
     "model-context-protocol",
     "claude",
+    "claude-code",
     "claude-desktop",
+    "cursor",
+    "windsurf",
+    "copilot",
     "ainote",
     "ai-note",
+    "dev-docs",
+    "claude-md",
+    "memory",
     "tasks",
     "task-management",
     "todo",
@@ -37,14 +49,44 @@
   },
   "homepage": "https://github.com/ainote-dev/ainote-mcp#readme",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "axios": "^1.6.0"
+    "axios": "^1.6.0",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "morgan": "^1.10.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "axios-mock-adapter": "^1.22.0",
+    "jest": "^29.7.0"
+  },
+  "jest": {
+    "transform": {},
+    "testEnvironment": "node",
+    "collectCoverageFrom": [
+      "index.js",
+      "server.js",
+      "lib/**/*.js",
+      "!node_modules/**"
+    ],
+    "coverageDirectory": "coverage",
+    "coverageReporters": [
+      "text",
+      "lcov",
+      "html"
+    ],
+    "testMatch": [
+      "**/__tests__/**/*.test.js",
+      "**/?(*.)+(spec|test).js"
+    ]
   },
   "files": [
     "index.js",
+    "server.js",
+    "lib",
     "README.md",
     "README-ko.md",
     "LICENSE"

package/server.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import express from 'express';
+import cors from 'cors';
+import morgan from 'morgan';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { createChatGptServer } from './lib/core/server-factory.js';
+import { getConfig } from './lib/core/config-manager.js';
+import { resolveAuthContext } from './lib/auth/strategy-factory.js';
+
+const config = getConfig();
+
+if (!config.features.sseTransport) {
+  console.error('[ainote-mcp] SSE transport is disabled. Set AINOTE_ENABLE_SSE_TRANSPORT=true to enable.');
+  process.exit(1);
+}
+
+const app = express();
+const sessions = new Map();
+
+const corsOptions = {
+  origin: config.http.allowedOrigins.length > 0 ? config.http.allowedOrigins : true,
+  credentials: true
+};
+
+app.use(cors(corsOptions));
+app.use(express.json({ limit: '4mb' }));
+app.use(morgan(':method :url :status :response-time ms - :res[content-length]'));
+
+app.get('/health', (_req, res) => {
+  res.json({
+    status: 'ok',
+    transport: 'sse',
+    timestamp: Date.now()
+  });
+});
+
+app.get(config.http.endpoint, async (req, res) => {
+  try {
+    const { server } = createChatGptServer();
+    const transport = new SSEServerTransport(config.http.messageEndpoint, res, {
+      enableDnsRebindingProtection: config.http.allowedHosts.length > 0 || config.http.allowedOrigins.length > 0,
+      allowedHosts: config.http.allowedHosts.length > 0 ? config.http.allowedHosts : undefined,
+      allowedOrigins: config.http.allowedOrigins.length > 0 ? config.http.allowedOrigins : undefined
+    });
+
+    sessions.set(transport.sessionId, { transport, server });
+
+    transport.onclose = async () => {
+      sessions.delete(transport.sessionId);
+      try {
+        await server.close();
+      } catch (closeError) {
+        console.error(`[ainote-mcp] Error while closing server: ${closeError.message}`);
+      }
+    };
+
+    transport.onerror = (error) => {
+      console.error(`[ainote-mcp] SSE transport error: ${error.message}`);
+    };
+
+    await server.connect(transport);
+  } catch (error) {
+    console.error(`[ainote-mcp] Failed to establish SSE connection: ${error.message}`);
+    if (!res.headersSent) {
+      res.status(500).json({ error: 'Failed to establish SSE connection' });
+    }
+  }
+});
+
+app.post(config.http.messageEndpoint, async (req, res) => {
+  const sessionId = req.query.sessionId;
+
+  if (!sessionId) {
+    return res.status(400).json({ error: 'Missing sessionId query parameter' });
+  }
+
+  const session = sessions.get(sessionId);
+
+  if (!session) {
+    return res.status(404).json({ error: `No transport found for sessionId ${sessionId}` });
+  }
+
+  const authContext = resolveAuthContext('sse', req.headers);
+  req.auth = authContext;
+
+  try {
+    await session.transport.handlePostMessage(req, res, req.body);
+  } catch (error) {
+    console.error(`[ainote-mcp] Failed to handle POST message: ${error.message}`);
+    if (!res.headersSent) {
+      res.status(500).json({ error: 'Failed to handle message' });
+    }
+  }
+});
+
+const port = config.http.port;
+app.listen(port, () => {
+  console.error(`AI Note MCP HTTP/SSE server listening on port ${port}`);
+});