@ainote/mcp 1.0.2 → 1.1.0

package/lib/cli/signup.js

@@ -0,0 +1,118 @@
+import * as readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import axios from 'axios';
+import { getConfig } from '../core/config-manager.js';
+
+/**
+ * Interactive CLI signup for AI Note MCP.
+ * Usage: ainote-mcp signup
+ */
+export async function runSignup() {
+  const config = getConfig();
+  const rl = readline.createInterface({ input, output });
+
+  console.log('\n  AI Note MCP — Sign Up\n');
+
+  try {
+    const email = await rl.question('  Email: ');
+    const password = await rl.question('  Password (min 6 chars): ');
+    const name = await rl.question('  Name (optional, press Enter to skip): ');
+
+    if (!email.trim() || !password.trim()) {
+      console.error('\n  Error: Email and password are required.\n');
+      process.exit(1);
+    }
+
+    if (password.trim().length < 6) {
+      console.error('\n  Error: Password must be at least 6 characters.\n');
+      process.exit(1);
+    }
+
+    console.log('\n  Creating account...');
+
+    const rpcRequest = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: {
+        name: 'signup_and_get_key',
+        arguments: {
+          email: email.trim(),
+          password: password.trim(),
+          ...(name.trim() ? { name: name.trim() } : {})
+        }
+      }
+    };
+
+    const response = await axios.post(`${config.api.url}/api/mcp`, rpcRequest, {
+      headers: { 'Content-Type': 'application/json' },
+      timeout: 30000
+    });
+
+    const data = response.data?.data;
+
+    // Check for JSON-RPC error
+    if (data?.error) {
+      console.error(`\n  Error: ${data.error.message}`);
+      if (data.error.data?.suggestion) {
+        console.log(`  Hint: ${data.error.data.suggestion}`);
+      }
+      console.log();
+      process.exit(1);
+    }
+
+    // Extract MCP key from structured resource data
+    const content = data?.result?.content;
+    let mcpKey = null;
+
+    if (Array.isArray(content)) {
+      for (const item of content) {
+        if (item.type === 'resource' && item.resource?.text) {
+          try {
+            const resourceData = JSON.parse(item.resource.text);
+            mcpKey = resourceData.mcp_key;
+          } catch { /* ignore */ }
+        }
+      }
+    }
+
+    if (mcpKey) {
+      console.log('\n  Account created successfully!\n');
+      console.log(`  Your MCP API Key:\n`);
+      console.log(`    ${mcpKey}\n`);
+      console.log('  Add this to your MCP config:\n');
+      console.log('  {');
+      console.log('    "mcpServers": {');
+      console.log('      "ainote": {');
+      console.log('        "command": "npx",');
+      console.log('        "args": ["-y", "@ainote/mcp"],');
+      console.log('        "env": {');
+      console.log(`          "AINOTE_API_KEY": "${mcpKey}"`);
+      console.log('        }');
+      console.log('      }');
+      console.log('    }');
+      console.log('  }\n');
+      console.log('  Then restart Claude Desktop.\n');
+    } else {
+      // Fallback: print text content
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item.type === 'text') {
+            console.log(`\n${item.text}\n`);
+          }
+        }
+      } else {
+        console.log('\n  Account created! Check the response for your API key.\n');
+      }
+    }
+  } catch (error) {
+    if (error.response?.data) {
+      console.error(`\n  Error: ${JSON.stringify(error.response.data)}\n`);
+    } else {
+      console.error(`\n  Error: ${error.message}\n`);
+    }
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}

package/lib/core/api-client.js

@@ -0,0 +1 @@
+export * from '../utils/api-client.js';

package/lib/core/config-manager.js

@@ -0,0 +1,67 @@
+const DEFAULT_API_URL = 'https://ainote-5muq.onrender.com';
+const DEFAULT_HTTP_PORT = 3030;
+
+const parseBoolean = (value, fallback) => {
+  if (value === undefined) {
+    return fallback;
+  }
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  const normalized = `${value}`.trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) {
+    return true;
+  }
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+};
+
+const parseNumber = (value, fallback) => {
+  if (value === undefined) {
+    return fallback;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+
+const parseList = (value) => {
+  if (!value) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value
+    .split(',')
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+};
+
+export function getConfig() {
+  const features = {
+    chatgptSupport: parseBoolean(process.env.AINOTE_ENABLE_CHATGPT_SUPPORT, true),
+    oauthAuth: parseBoolean(process.env.AINOTE_ENABLE_OAUTH_AUTH, false),
+    sseTransport: parseBoolean(process.env.AINOTE_ENABLE_SSE_TRANSPORT, true)
+  };
+
+  return {
+    api: {
+      key: process.env.AINOTE_API_KEY,
+      url: process.env.AINOTE_API_URL || DEFAULT_API_URL
+    },
+    http: {
+      port: parseNumber(process.env.AINOTE_MCP_HTTP_PORT, DEFAULT_HTTP_PORT),
+      endpoint: process.env.AINOTE_MCP_HTTP_ENDPOINT || '/sse',
+      messageEndpoint: process.env.AINOTE_MCP_HTTP_MESSAGES_ENDPOINT || '/messages',
+      allowedOrigins: parseList(process.env.AINOTE_MCP_ALLOWED_ORIGINS),
+      allowedHosts: parseList(process.env.AINOTE_MCP_ALLOWED_HOSTS)
+    },
+    features
+  };
+}
+
+export function getFeatureFlags() {
+  return getConfig().features;
+}

package/lib/core/config.js

@@ -0,0 +1 @@
+export * from './config-manager.js';

package/lib/core/mcp-server.js

@@ -0,0 +1,2 @@
+// Deprecated: use server-factory instead.
+export { createClaudeServer, createChatGptServer, createServerForProfile } from './server-factory.js';

package/lib/core/server-factory.js

@@ -0,0 +1,82 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ToolRegistry } from './tool-registry.js';
+import { getConfig } from './config-manager.js';
+import { createApiClient } from '../utils/api-client.js';
+import { getSharedTools } from '../tools/shared-tools.js';
+import { getChatGptTools } from '../tools/chatgpt-tools.js';
+import { getDevDocTools } from '../tools/dev-doc-tools.js';
+import { getOnboardingTools } from '../tools/onboarding-tools.js';
+import { toErrorContent } from '../tools/internal/formatters.js';
+
+function buildServerInfo(profile) {
+  return {
+    name: `ainote-mcp-${profile}`,
+    version: '1.1.0'
+  };
+}
+
+function registerTools(registry, { includeChatGpt }) {
+  // Onboarding tools are always registered (work without API key)
+  registry.registerMany(getOnboardingTools());
+  registry.registerMany(getSharedTools());
+  registry.registerMany(getDevDocTools());
+
+  if (includeChatGpt) {
+    registry.registerMany(getChatGptTools());
+  }
+}
+
+function createServer({ profile, defaultAuthContext } = {}) {
+  const config = getConfig();
+  const includeChatGpt = profile === 'chatgpt' && config.features.chatgptSupport;
+  const registry = new ToolRegistry();
+
+  registerTools(registry, { includeChatGpt });
+
+  const server = new Server(buildServerInfo(profile), {
+    capabilities: {
+      tools: {}
+    }
+  });
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: registry.listDefinitions()
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    try {
+      const { name, arguments: args } = request.params;
+      console.error(`[MCP] Calling tool: ${name}`, JSON.stringify(args));
+
+      const authContext = extra?.authInfo ?? defaultAuthContext;
+      const apiClient = createApiClient(authContext);
+
+      const result = await registry.execute(name, args, {
+        apiClient,
+        request,
+        extra
+      });
+
+      console.error(`[MCP] Tool ${name} completed successfully`);
+      return result;
+    } catch (error) {
+      console.error(`[MCP] Tool error:`, error);
+      return toErrorContent(error);
+    }
+  });
+
+  return { server, registry };
+}
+
+export function createClaudeServer(options = {}) {
+  return createServer({ profile: 'claude', ...options });
+}
+
+export function createChatGptServer(options = {}) {
+  return createServer({ profile: 'chatgpt', ...options });
+}
+
+export function createServerForProfile(profile, options = {}) {
+  return createServer({ profile, ...options });
+}

package/lib/core/tool-registry.js

@@ -0,0 +1,31 @@
+export class ToolRegistry {
+  constructor() {
+    this.tools = new Map();
+  }
+
+  register(tool) {
+    if (!tool?.definition?.name) {
+      throw new Error('Invalid tool registration: missing tool name');
+    }
+
+    this.tools.set(tool.definition.name, tool);
+  }
+
+  registerMany(tools = []) {
+    tools.forEach((tool) => this.register(tool));
+  }
+
+  listDefinitions() {
+    return Array.from(this.tools.values()).map((tool) => tool.definition);
+  }
+
+  async execute(name, args, context) {
+    const tool = this.tools.get(name);
+
+    if (!tool) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return tool.handler(args ?? {}, context ?? {});
+  }
+}

package/lib/tools/chatgpt-tools.js

@@ -0,0 +1,93 @@
+import { toSuccessContent } from './internal/formatters.js';
+
+const MAX_RESULTS = 20;
+
+function searchDefinition() {
+  return {
+    name: 'search',
+    description: 'Search tasks and categories in AI Note',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Search query for tasks content, categories, or due dates'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of search results (default: 20)'
+        }
+      },
+      required: ['query']
+    }
+  };
+}
+
+function fetchDefinition() {
+  return {
+    name: 'fetch',
+    description: 'Fetch detailed information about a specific task',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          description: 'Task ID to fetch detailed information'
+        }
+      },
+      required: ['id']
+    }
+  };
+}
+
+export function getChatGptTools() {
+  return [
+    {
+      definition: searchDefinition(),
+      handler: async (args, { apiClient }) => {
+        const limit = typeof args.limit === 'number' ? Math.min(args.limit, MAX_RESULTS) : MAX_RESULTS;
+        const response = await apiClient.get('/api/mcp/tasks', {
+          params: {
+            search: args.query,
+            limit
+          }
+        });
+
+        const results = Array.isArray(response.data?.tasks)
+          ? response.data.tasks.map((task) => ({
+              id: task.id,
+              title: task.content,
+              due_date: task.due_date,
+              is_important: task.is_important,
+              url: task.url ?? `https://app.ainote.dev/tasks/${task.id}`,
+              category: task.category
+            }))
+          : response.data;
+
+        return toSuccessContent({
+          results,
+          meta: {
+            source: 'ai-note',
+            query: args.query,
+            limit
+          }
+        });
+      }
+    },
+    {
+      definition: fetchDefinition(),
+      handler: async (args, { apiClient }) => {
+        const response = await apiClient.get(`/api/mcp/tasks/${args.id}`);
+        const task = response.data?.task ?? response.data;
+
+        return toSuccessContent({
+          task,
+          meta: {
+            source: 'ai-note',
+            fetched_at: new Date().toISOString()
+          }
+        });
+      }
+    }
+  ];
+}

package/lib/tools/dev-doc-tools.js

@@ -0,0 +1,166 @@
+import { toSuccessContent } from './internal/formatters.js';
+
+function listDevDocsDefinition() {
+  return {
+    name: 'list_dev_docs',
+    description: `List dev documents under dev/ category hierarchy. Manage AI coding tool configs (CLAUDE.md, .cursorrules, etc.) and dev docs centrally.
+
+Categories: claude, cursor, windsurf, copilot, docs, or custom subcategories.
+Supports markdown, json, yaml content types.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: {
+          type: 'string',
+          description: 'Subcategory filter (claude, cursor, windsurf, copilot, docs, etc.)'
+        },
+        search: {
+          type: 'string',
+          description: 'Search keyword in document title'
+        },
+        content_type: {
+          type: 'string',
+          enum: ['markdown', 'json', 'yaml', 'text'],
+          description: 'Filter by content type'
+        }
+      }
+    }
+  };
+}
+
+function getDevDocDefinition() {
+  return {
+    name: 'get_dev_doc',
+    description: 'Get a single dev document by title or id. Returns full content.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Document title (e.g., project-a-memory.md)' },
+        id: { type: 'string', description: 'Document UUID' },
+        category: { type: 'string', description: 'Subcategory (claude, cursor, etc.) to disambiguate' },
+        include_versions: { type: 'boolean', description: 'Include version history (default: false)' }
+      }
+    }
+  };
+}
+
+function createDevDocDefinition() {
+  return {
+    name: 'create_dev_doc',
+    description: `Create a new dev document under dev/ category. Auto-creates subcategory if needed.
+
+Use this to store CLAUDE.md content, cursor rules, windsurf rules, API specs, architecture docs, etc.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Document title (e.g., project-a-claude.md)' },
+        content: { type: 'string', description: 'Document content (markdown, json, yaml)' },
+        category: {
+          type: 'string',
+          description: 'Subcategory (claude, cursor, windsurf, copilot, docs). Default: docs'
+        },
+        content_type: {
+          type: 'string',
+          enum: ['markdown', 'json', 'yaml', 'text'],
+          description: 'Content type. Auto-detected from title extension if omitted.'
+        }
+      },
+      required: ['title', 'content']
+    }
+  };
+}
+
+function updateDevDocDefinition() {
+  return {
+    name: 'update_dev_doc',
+    description: 'Update a dev document. Supports replace, append, or prepend modes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Document title' },
+        id: { type: 'string', description: 'Document UUID' },
+        category: { type: 'string', description: 'Subcategory to disambiguate' },
+        content: { type: 'string', description: 'New content' },
+        mode: {
+          type: 'string',
+          enum: ['replace', 'append', 'prepend'],
+          description: 'Update mode (default: replace)'
+        }
+      },
+      required: ['content']
+    }
+  };
+}
+
+function deleteDevDocDefinition() {
+  return {
+    name: 'delete_dev_doc',
+    description: 'Delete a dev document (soft delete).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Document title' },
+        id: { type: 'string', description: 'Document UUID' },
+        category: { type: 'string', description: 'Subcategory to disambiguate' }
+      }
+    }
+  };
+}
+
+function listDevCategoriesDefinition() {
+  return {
+    name: 'list_dev_categories',
+    description: 'List all subcategories under dev/. Shows document count per category.',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  };
+}
+
+export function getDevDocTools() {
+  return [
+    {
+      definition: listDevDocsDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('list_dev_docs', args);
+        return result;
+      }
+    },
+    {
+      definition: getDevDocDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('get_dev_doc', args);
+        return result;
+      }
+    },
+    {
+      definition: createDevDocDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('create_dev_doc', args);
+        return result;
+      }
+    },
+    {
+      definition: updateDevDocDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('update_dev_doc', args);
+        return result;
+      }
+    },
+    {
+      definition: deleteDevDocDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('delete_dev_doc', args);
+        return result;
+      }
+    },
+    {
+      definition: listDevCategoriesDefinition(),
+      handler: async (_args, { apiClient }) => {
+        const result = await apiClient.callTool('list_dev_categories', {});
+        return result;
+      }
+    }
+  ];
+}

package/lib/tools/index.js

@@ -0,0 +1,5 @@
+export { getSharedTools } from './shared-tools.js';
+export { getChatGptTools } from './chatgpt-tools.js';
+export { getDevDocTools } from './dev-doc-tools.js';
+export { getOnboardingTools } from './onboarding-tools.js';
+export { toSuccessContent, toErrorContent } from './internal/formatters.js';

package/lib/tools/internal/formatters.js

@@ -0,0 +1,80 @@
+export function toSuccessContent(payload, options = {}) {
+  const { pretty = true } = options;
+  const text = pretty ? JSON.stringify(payload, null, 2) : JSON.stringify(payload);
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text
+      }
+    ]
+  };
+}
+
+export function toErrorContent(error) {
+  const message = error?.message ?? String(error);
+  const details = error?.response?.data;
+  const textParts = [`Error: ${message}`];
+
+  if (details) {
+    try {
+      textParts.push(JSON.stringify(details, null, 2));
+    } catch (stringifyError) {
+      textParts.push(String(details));
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: textParts.join('\n')
+      }
+    ],
+    isError: true
+  };
+}
+
+/**
+ * Parse structured data from MCP response
+ * Looks for JSON resource in content array and extracts structured data
+ */
+export function parseStructuredData(result) {
+  if (!result?.content || !Array.isArray(result.content)) {
+    return null;
+  }
+
+  // Look for resource content with JSON data
+  for (const item of result.content) {
+    if (item.type === 'resource' && item.resource?.mimeType === 'application/json') {
+      try {
+        return JSON.parse(item.resource.text);
+      } catch (error) {
+        console.error('Failed to parse structured data:', error);
+        return null;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Enhance result with structured data annotation
+ * Adds structured data to the response while preserving original text
+ */
+export function enhanceWithStructuredData(result) {
+  const structuredData = parseStructuredData(result);
+
+  if (structuredData) {
+    // Add metadata about structured data availability
+    return {
+      ...result,
+      _structuredData: structuredData,
+      _hasStructuredData: true
+    };
+  }
+
+  return result;
+}