obsidian-mcp-server 1.2.6 → 1.4.0

package/src/mcp/handlers.ts

@@ -0,0 +1,183 @@
+/**
+ * MCP server request handlers
+ */
+import {
+  Tool,
+  TextContent,
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ObsidianError } from "../utils/errors.js";
+import { validateToolArguments } from "../utils/validation.js";
+import { rateLimiter } from "../utils/rate-limiting.js";
+import { createLogger } from "../utils/logging.js";
+import { DEFAULT_TIMEOUT_CONFIG } from "./types.js";
+import { BaseToolHandler } from "../tools/base.js";
+
+// Create a logger for request handlers
+const logger = createLogger('McpHandlers');
+
+/**
+ * Set up tool listing handler
+ * @param server The MCP server instance
+ * @param toolHandlers The tool handlers to register
+ */
+export function setupToolListingHandler(
+  server: Server,
+  toolHandlers: Map<string, BaseToolHandler<any>>
+): void {
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    logger.debug('Handling ListToolsRequest');
+    const tools: Tool[] = [];
+    for (const handler of toolHandlers.values()) {
+      tools.push(handler.getToolDescription());
+    }
+    return { tools };
+  });
+}
+
+/**
+ * Set up tool calling handler
+ * @param server The MCP server instance
+ * @param toolHandlers The tool handlers to register
+ */
+export function setupToolCallingHandler(
+  server: Server,
+  toolHandlers: Map<string, BaseToolHandler<any>>
+): void {
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    logger.debug(`Handling CallToolRequest for tool: ${name}`);
+
+    const handler = toolHandlers.get(name);
+    if (!handler) {
+      logger.error(`Unknown tool requested: ${name}`);
+      throw new ObsidianError(`Unknown tool: ${name}`, 40400); // 40400 = Not found
+    }
+
+    // Check rate limit
+    try {
+      rateLimiter.enforceRateLimit(name);
+    } catch (error) {
+      // If rate limit is exceeded, log and rethrow the error
+      logger.warn(`Rate limit exceeded for tool: ${name}`);
+      throw error;
+    }
+
+    // Add timeout handling
+    const timeoutMs = DEFAULT_TIMEOUT_CONFIG.toolExecutionMs;
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => {
+        reject(new ObsidianError(`Tool execution timed out after ${timeoutMs}ms`, 40800)); // 40800 = Request timeout
+      }, timeoutMs);
+    });
+
+    try {
+      // Validate arguments against tool's schema
+      const toolDescription = handler.getToolDescription();
+      const validationResult = validateToolArguments(args, toolDescription.inputSchema);
+      if (!validationResult.valid) {
+        logger.error(`Invalid tool arguments for ${name}:`, validationResult.errors);
+        throw new ObsidianError(
+          `Invalid tool arguments: ${validationResult.errors.join(', ')}`,
+          40000 // 40000 = Bad request
+        );
+      }
+
+      // Log the tool execution
+      logger.info(`Executing tool: ${name}`);
+
+      // Race between tool execution and timeout
+      const content = await Promise.race([
+        handler.runTool(args),
+        timeoutPromise
+      ]);
+      
+      logger.debug(`Tool execution completed successfully: ${name}`);
+      
+      return { content };
+    } catch (error) {
+      if (error instanceof ObsidianError) {
+        // Check if the operation actually succeeded despite the error
+        if (error.errorCode === 20400) { // 20400 = Success with no content
+          return {
+            content: [{
+              type: "text",
+              text: "Operation completed successfully"
+            }]
+          };
+        }
+        throw error;
+      }
+      
+      // Enhanced error logging
+      logger.error("Tool execution error:", {
+        name: error instanceof Error ? error.name : 'Unknown',
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+        toolName: name
+      });
+
+      if (error instanceof Error) {
+        throw new ObsidianError(
+          `Tool '${name}' execution failed: ${error.message}`,
+          50000, // 50000 = Internal server error
+          { originalError: error.stack }
+        );
+      }
+      
+      throw new ObsidianError(
+        "Tool execution failed with unknown error",
+        50000, // 50000 = Internal server error
+        { error }
+      );
+    }
+  });
+}
+
+/**
+ * Set up resource listing handler
+ * @param server The MCP server instance
+ * @param resources The resources to register
+ */
+export function setupResourceListingHandler(
+  server: Server,
+  resources: Record<string, any>
+): void {
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    logger.debug('Handling ListResourcesRequest');
+    return {
+      resources: Object.values(resources).map(resource => 
+        resource.getResourceDescription())
+    };
+  });
+}
+
+/**
+ * Set up resource reading handler
+ * @param server The MCP server instance
+ * @param resources The resources to register
+ */
+export function setupResourceReadingHandler(
+  server: Server,
+  resources: Record<string, any>
+): void {
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    logger.debug(`Handling ReadResourceRequest for URI: ${uri}`);
+    
+    const resource = resources[uri];
+    if (resource) {
+      logger.debug(`Found resource for URI: ${uri}`);
+      return {
+        contents: await resource.getContent()
+      };
+    }
+    
+    logger.error(`Resource not found: ${uri}`);
+    throw new ObsidianError(`Resource not found: ${uri}`, 40400); // 40400 = Not found
+  });
+}

package/src/mcp/index.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP module exports
+ */
+export * from './types.js';
+export * from './handlers.js';
+export * from './server.js';

package/src/mcp/server.ts

@@ -0,0 +1,162 @@
+/**
+ * MCP server implementation
+ */
+import { config } from "dotenv";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createLogger } from "../utils/logging.js";
+import { rateLimiter } from "../utils/rate-limiting.js";
+import { createTagResource } from "../resources/index.js";
+import { createToolHandlers, createToolHandlerMap } from "../tools/index.js";
+import { ObsidianClient } from "../obsidian/client.js";
+import { 
+  setupToolListingHandler, 
+  setupToolCallingHandler, 
+  setupResourceListingHandler, 
+  setupResourceReadingHandler 
+} from "./handlers.js";
+import { McpServerConfig, ResourceMap } from "./types.js";
+
+// Create a logger for the server
+const logger = createLogger('McpServer');
+
+// Load environment variables
+config();
+
+/**
+ * Initialize MCP server components
+ */
+export async function initializeServer(): Promise<Server> {
+  // Verify API key exists
+  const API_KEY = process.env.OBSIDIAN_API_KEY;
+  if (!API_KEY) {
+    throw new Error("OBSIDIAN_API_KEY environment variable is required");
+  }
+
+  // Initialize Obsidian client with environment configuration
+  logger.info('Initializing Obsidian client');
+  const client = new ObsidianClient({
+    apiKey: API_KEY,
+    verifySSL: process.env.VERIFY_SSL === 'true',
+    timeout: parseInt(process.env.REQUEST_TIMEOUT || '5000'),
+    maxContentLength: parseInt(process.env.MAX_CONTENT_LENGTH || String(50 * 1024 * 1024)),
+    maxBodyLength: parseInt(process.env.MAX_BODY_LENGTH || String(50 * 1024 * 1024))
+  });
+
+  // Initialize tool handlers
+  logger.info('Initializing tool handlers');
+  const toolHandlers = createToolHandlers(client);
+  const toolHandlerMap = createToolHandlerMap(toolHandlers);
+
+  // Initialize resources
+  logger.info('Initializing resources');
+  const tagResource = createTagResource(client);
+  const resources: ResourceMap = {
+    [tagResource.getResourceDescription().uri]: tagResource
+  };
+
+  // Create MCP server
+  const serverConfig: McpServerConfig = {
+    name: "obsidian-mcp-server",
+    version: process.env.npm_package_version ?? "1.1.0" // Use version from package.json
+  };
+
+  logger.info(`Creating MCP server: ${serverConfig.name} v${serverConfig.version}`);
+  const server = new Server(
+    serverConfig,
+    {
+      capabilities: {
+        tools: {},
+        resources
+      }
+    }
+  );
+
+  // Set up request handlers
+  setupToolListingHandler(server, toolHandlerMap);
+  setupToolCallingHandler(server, toolHandlerMap);
+  setupResourceListingHandler(server, resources);
+  setupResourceReadingHandler(server, resources);
+
+  // Set up error handler
+  server.onerror = (error) => {
+    logger.error("[MCP Error]", error);
+  };
+
+  return server;
+}
+
+/**
+ * Set up graceful shutdown handling
+ * @param server The MCP server instance
+ * @param cleanupHandlers Additional cleanup handlers to run on shutdown
+ */
+export function setupShutdownHandling(
+  server: Server,
+  cleanupHandlers: (() => Promise<void> | void)[] = []
+): void {
+  // Cleanup function for graceful shutdown
+  const cleanup = async () => {
+    logger.info('Shutting down server...');
+    
+    // Run cleanup handlers
+    for (const handler of cleanupHandlers) {
+      try {
+        await handler();
+      } catch (error) {
+        logger.error('Error during cleanup:', error);
+      }
+    }
+    
+    // Dispose rate limiter
+    rateLimiter.dispose();
+    
+    // Close server
+    await server.close();
+    
+    process.exit(0);
+  };
+
+  // Handle various termination signals
+  process.on('SIGINT', cleanup);  // Ctrl+C on all platforms
+  process.on('SIGTERM', cleanup); // Termination request
+  
+  if (process.platform === 'win32') {
+    // Windows-specific handling
+    process.on('SIGHUP', cleanup);  // Terminal closed
+  } else {
+    // Unix-specific signals
+    process.on('SIGUSR1', cleanup);
+    process.on('SIGUSR2', cleanup);
+  }
+
+  // Handle uncaught errors
+  process.on('uncaughtException', async (error) => {
+    logger.error('Uncaught exception:', error);
+    await cleanup();
+  });
+
+  process.on('unhandledRejection', async (error) => {
+    logger.error('Unhandled rejection:', error);
+    await cleanup();
+  });
+}
+
+/**
+ * Run the MCP server
+ */
+export async function run(): Promise<void> {
+  try {
+    const server = await initializeServer();
+    setupShutdownHandling(server, []);
+    
+    // Connect to transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    
+    logger.info("Obsidian MCP server running on stdio");
+  } catch (error) {
+    logger.error("Failed to start server:", error);
+    process.exit(1);
+  }
+}

package/src/mcp/types.ts

@@ -0,0 +1,46 @@
+/**
+ * MCP server type definitions
+ */
+import { TextContent, Tool } from "@modelcontextprotocol/sdk/types.js";
+import { BaseToolHandler } from "../tools/base.js";
+import { TagResource } from "../resources/tags.js";
+
+/**
+ * MCP server configuration
+ */
+export interface McpServerConfig extends Record<string, unknown> {
+  name: string;
+  version: string;
+}
+
+/**
+ * Timeout configuration for tool execution
+ */
+export interface TimeoutConfig {
+  toolExecutionMs: number; // Default: 60000 (60 seconds)
+}
+
+/**
+ * Map of resources by URI
+ */
+export interface ResourceMap {
+  [uri: string]: {
+    getContent(): Promise<TextContent[]>;
+    getResourceDescription(): any;
+  };
+}
+
+/**
+ * Server capabilities configuration
+ */
+export interface ServerCapabilities {
+  tools: Record<string, Tool>;
+  resources: ResourceMap;
+}
+
+/**
+ * Default timeout configuration
+ */
+export const DEFAULT_TIMEOUT_CONFIG: TimeoutConfig = {
+  toolExecutionMs: parseInt(process.env.TOOL_TIMEOUT_MS ?? '60000') // 60 second default timeout
+};