obsidian-mcp-server 1.4.0 → 1.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "obsidian-mcp-server",
-  "version": "1.4.0",
-  "description": "Model Context Protocol server for Obsidian integration with token-aware response handling",
+  "version": "1.5.0",
+  "description": "Model Context Protocol (MCP) server designed for LLMs to interact with Obsidian vaults. Provides secure, token-aware tools for seamless knowledge base management through a standardized interface.",
   "main": "build/index.js",
   "type": "module",
   "engines": {
@@ -19,22 +19,21 @@
     "format": "prettier --write \"src/**/*.ts\""
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.4.1",
-    "axios": "^1.7.9",
+    "@modelcontextprotocol/sdk": "^1.7.0",
+    "axios": "^1.8.3",
     "dotenv": "^16.4.7",
-    "tiktoken": "^1.0.18",
+    "tiktoken": "^1.0.20",
     "yaml": "^2.7.0",
-    "zod": "^3.24.1"
-  },
-  "devDependencies": {
-    "@types/node": "^22.10.10",
-    "@typescript-eslint/eslint-plugin": "^8.21.0",
-    "@typescript-eslint/parser": "^8.21.0",
-    "eslint": "^9.19.0",
-    "eslint-config-prettier": "^10.0.1",
+    "zod": "^3.24.2",
+    "winston": "^3.17.0",
+    "@types/node": "^22.13.10",
+    "@typescript-eslint/eslint-plugin": "^8.26.1",
+    "@typescript-eslint/parser": "^8.26.1",
+    "eslint": "^9.22.0",
+    "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-prettier": "^5.2.3",
-    "prettier": "^3.4.2",
-    "typescript": "^5.7.3"
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.2"
   },
   "keywords": [
     "mcp",

package/src/mcp/handlers.ts

@@ -13,13 +13,47 @@ 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 { 
+  createLogger, 
+  ErrorCategoryType
+} from "../utils/logging.js";
+import { 
+  DEFAULT_TIMEOUT_CONFIG, 
+  McpErrorCode,
+  createFailureResult, 
+  createSuccessResult
+} from "./types.js";
 import { BaseToolHandler } from "../tools/base.js";
 
 // Create a logger for request handlers
 const logger = createLogger('McpHandlers');
 
+/**
+ * Helper function to safely mask sensitive data
+ */
+function maskSensitiveData(data: Record<string, unknown> | undefined): Record<string, unknown> {
+  if (!data) return {};
+  
+  const sensitiveFields = ['password', 'token', 'secret', 'key', 'auth', 'credential'];
+  const result: Record<string, unknown> = {};
+  
+  for (const [key, value] of Object.entries(data)) {
+    const isSensitive = sensitiveFields.some(field => 
+      key.toLowerCase().includes(field.toLowerCase())
+    );
+    
+    if (isSensitive) {
+      result[key] = '********';
+    } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+      result[key] = maskSensitiveData(value as Record<string, unknown>);
+    } else {
+      result[key] = value;
+    }
+  }
+  
+  return result;
+}
+
 /**
  * Set up tool listing handler
  * @param server The MCP server instance
@@ -31,11 +65,29 @@ export function setupToolListingHandler(
 ): void {
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     logger.debug('Handling ListToolsRequest');
-    const tools: Tool[] = [];
-    for (const handler of toolHandlers.values()) {
-      tools.push(handler.getToolDescription());
+    // Start performance timing
+    logger.startTimer('list_tools');
+    
+    try {
+      const tools: Tool[] = [];
+      for (const handler of toolHandlers.values()) {
+        tools.push(handler.getToolDescription());
+      }
+      
+      // Log success and timing information
+      const elapsedMs = logger.endTimer('list_tools', 'Listed tools');
+      logger.logOperationResult(true, 'list_tools', elapsedMs, {
+        toolCount: tools.length
+      });
+      
+      return { tools };
+    } catch (error) {
+      // Log failure with timing information
+      const elapsedMs = logger.endTimer('list_tools', 'Failed to list tools');
+      logger.logOperationResult(false, 'list_tools', elapsedMs);
+      logger.error('Failed to list available tools', error instanceof Error ? error : undefined);
+      throw error;
     }
-    return { tools };
   });
 }
 
@@ -50,28 +102,71 @@ export function setupToolCallingHandler(
 ): void {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    logger.debug(`Handling CallToolRequest for tool: ${name}`);
-
+    const operationId = `call_tool_${name}_${Date.now()}`;
+    logger.debug(`Handling CallToolRequest for tool: ${name}`, { 
+      toolName: name,
+      operationId
+    });
+    
+    // Start performance timing
+    logger.startTimer(operationId);
+    
+    // Handle unknown tool
     const handler = toolHandlers.get(name);
     if (!handler) {
-      logger.error(`Unknown tool requested: ${name}`);
-      throw new ObsidianError(`Unknown tool: ${name}`, 40400); // 40400 = Not found
+      const errorInfo = {
+        toolName: name,
+        errorCode: McpErrorCode.NOT_FOUND,
+        errorCategory: ErrorCategoryType.CATEGORY_VALIDATION
+      };
+      
+      logger.error(`Unknown tool requested: ${name}`, errorInfo);
+      const elapsedMs = logger.endTimer(operationId);
+      logger.logOperationResult(false, 'call_tool', elapsedMs, errorInfo);
+      
+      throw new ObsidianError(
+        `Unknown tool: ${name}`, 
+        McpErrorCode.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;
+      const errorInfo = {
+        toolName: name,
+        errorCode: McpErrorCode.RATE_LIMIT_EXCEEDED,
+        errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+      };
+      
+      logger.warn(`Rate limit exceeded for tool: ${name}`, errorInfo);
+      const elapsedMs = logger.endTimer(operationId);
+      logger.logOperationResult(false, 'call_tool', elapsedMs, errorInfo);
+      
+      throw new ObsidianError(
+        `Rate limit exceeded for tool: ${name}`, 
+        McpErrorCode.RATE_LIMIT_EXCEEDED
+      );
     }
 
     // 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
+        const errorInfo = {
+          toolName: name,
+          timeoutMs,
+          errorCode: McpErrorCode.TIMEOUT,
+          errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+        };
+        
+        logger.error(`Tool execution timed out after ${timeoutMs}ms`, errorInfo);
+        
+        reject(new ObsidianError(
+          `Tool execution timed out after ${timeoutMs}ms`, 
+          McpErrorCode.TIMEOUT
+        ));
       }, timeoutMs);
     });
 
@@ -80,15 +175,29 @@ export function setupToolCallingHandler(
       const toolDescription = handler.getToolDescription();
       const validationResult = validateToolArguments(args, toolDescription.inputSchema);
       if (!validationResult.valid) {
-        logger.error(`Invalid tool arguments for ${name}:`, validationResult.errors);
+        const errorInfo = { 
+          toolName: name, 
+          validationErrors: validationResult.errors,
+          providedArgs: maskSensitiveData(args),
+          errorCode: McpErrorCode.BAD_REQUEST,
+          errorCategory: ErrorCategoryType.CATEGORY_VALIDATION
+        };
+        
+        logger.error(`Invalid tool arguments for ${name}:`, errorInfo);
+        const elapsedMs = logger.endTimer(operationId);
+        logger.logOperationResult(false, 'call_tool', elapsedMs, errorInfo);
+        
         throw new ObsidianError(
-          `Invalid tool arguments: ${validationResult.errors.join(', ')}`,
-          40000 // 40000 = Bad request
+          `Invalid tool arguments: ${validationResult.errors.join(', ')}`, 
+          McpErrorCode.BAD_REQUEST
         );
       }
 
       // Log the tool execution
-      logger.info(`Executing tool: ${name}`);
+      logger.info(`Executing tool: ${name}`, { 
+        toolName: name,
+        args: maskSensitiveData(args)
+      });
 
       // Race between tool execution and timeout
       const content = await Promise.race([
@@ -96,13 +205,27 @@ export function setupToolCallingHandler(
         timeoutPromise
       ]);
       
-      logger.debug(`Tool execution completed successfully: ${name}`);
+      // Log successful execution
+      const elapsedMs = logger.endTimer(operationId);
+      logger.logOperationResult(true, 'call_tool', elapsedMs, { 
+        toolName: name,
+        contentLength: content.reduce((sum, item) => {
+          return sum + (item.type === 'text' ? item.text.length : 0);
+        }, 0)
+      });
       
       return { content };
     } catch (error) {
+      // Handle ObsidianError
       if (error instanceof ObsidianError) {
         // Check if the operation actually succeeded despite the error
-        if (error.errorCode === 20400) { // 20400 = Success with no content
+        if (error.errorCode === McpErrorCode.SUCCESS_NO_CONTENT) {
+          const elapsedMs = logger.endTimer(operationId);
+          logger.logOperationResult(true, 'call_tool', elapsedMs, { 
+            toolName: name,
+            status: 'success_no_content'
+          });
+          
           return {
             content: [{
               type: "text",
@@ -110,29 +233,41 @@ export function setupToolCallingHandler(
             }]
           };
         }
+        
+        // Log failure for other ObsidianErrors
+        const errorInfo = {
+          toolName: name,
+          errorMessage: error.message,
+          errorCode: error.errorCode,
+          errorCategory: ErrorCategoryType.CATEGORY_BUSINESS_LOGIC,
+          details: error.details ? JSON.stringify(error.details) : undefined
+        };
+        
+        const elapsedMs = logger.endTimer(operationId);
+        logger.logOperationResult(false, 'call_tool', elapsedMs, errorInfo);
+        
         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 }
-        );
-      }
+      // Enhanced error logging for other errors
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? error.stack : undefined;
       
+      const errorInfo = {
+        toolName: name,
+        errorMessage,
+        errorStack,
+        errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+      };
+      
+      logger.error("Tool execution error:", errorInfo);
+      const elapsedMs = logger.endTimer(operationId);
+      logger.logOperationResult(false, 'call_tool', elapsedMs, errorInfo);
+
       throw new ObsidianError(
-        "Tool execution failed with unknown error",
-        50000, // 50000 = Internal server error
-        { error }
+        `Tool '${name}' execution failed: ${errorMessage}`,
+        McpErrorCode.INTERNAL_SERVER_ERROR,
+        { originalError: errorMessage, stack: errorStack }
       );
     }
   });
@@ -149,10 +284,27 @@ export function setupResourceListingHandler(
 ): void {
   server.setRequestHandler(ListResourcesRequestSchema, async () => {
     logger.debug('Handling ListResourcesRequest');
-    return {
-      resources: Object.values(resources).map(resource => 
-        resource.getResourceDescription())
-    };
+    // Start performance timing
+    logger.startTimer('list_resources');
+    
+    try {
+      const resourceList = Object.values(resources).map(resource => 
+        resource.getResourceDescription());
+      
+      // Log success with timing information
+      const elapsedMs = logger.endTimer('list_resources', 'Listed resources');
+      logger.logOperationResult(true, 'list_resources', elapsedMs, {
+        resourceCount: resourceList.length
+      });
+      
+      return { resources: resourceList };
+    } catch (error) {
+      // Log failure with timing information
+      const elapsedMs = logger.endTimer('list_resources', 'Failed to list resources');
+      logger.logOperationResult(false, 'list_resources', elapsedMs);
+      logger.error('Failed to list available resources', error instanceof Error ? error : undefined);
+      throw error;
+    }
   });
 }
 
@@ -167,17 +319,67 @@ export function setupResourceReadingHandler(
 ): void {
   server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     const uri = request.params.uri;
-    logger.debug(`Handling ReadResourceRequest for URI: ${uri}`);
+    const operationId = `read_resource_${Date.now()}`;
+    
+    logger.debug(`Handling ReadResourceRequest for URI: ${uri}`, { 
+      resourceUri: uri,
+      operationId
+    });
+    
+    // Start performance timing
+    logger.startTimer(operationId);
     
     const resource = resources[uri];
-    if (resource) {
-      logger.debug(`Found resource for URI: ${uri}`);
-      return {
-        contents: await resource.getContent()
+    if (!resource) {
+      const errorInfo = {
+        resourceUri: uri,
+        errorCode: McpErrorCode.NOT_FOUND,
+        errorCategory: ErrorCategoryType.CATEGORY_DATA_ACCESS
       };
+      
+      logger.error(`Resource not found: ${uri}`, errorInfo);
+      const elapsedMs = logger.endTimer(operationId);
+      logger.logOperationResult(false, 'read_resource', elapsedMs, errorInfo);
+      
+      throw new ObsidianError(
+        `Resource not found: ${uri}`, 
+        McpErrorCode.NOT_FOUND
+      );
     }
     
-    logger.error(`Resource not found: ${uri}`);
-    throw new ObsidianError(`Resource not found: ${uri}`, 40400); // 40400 = Not found
+    try {
+      logger.debug(`Found resource for URI: ${uri}`);
+      const contents = await resource.getContent();
+      
+      // Log success with timing information
+      const elapsedMs = logger.endTimer(operationId);
+      logger.logOperationResult(true, 'read_resource', elapsedMs, {
+        resourceUri: uri,
+        contentItems: contents.length
+      });
+      
+      return { contents };
+    } catch (error) {
+      // Log failure with timing information
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? error.stack : undefined;
+      
+      const errorInfo = {
+        resourceUri: uri,
+        errorMessage,
+        errorStack,
+        errorCategory: ErrorCategoryType.CATEGORY_DATA_ACCESS
+      };
+      
+      logger.error(`Error reading resource: ${uri}`, errorInfo);
+      const elapsedMs = logger.endTimer(operationId);
+      logger.logOperationResult(false, 'read_resource', elapsedMs, errorInfo);
+      
+      throw new ObsidianError(
+        `Failed to read resource: ${errorMessage}`,
+        McpErrorCode.INTERNAL_SERVER_ERROR,
+        { originalError: errorMessage, stack: errorStack }
+      );
+    }
   });
 }