obsidian-mcp-server 1.5.0 → 1.5.2

package/README.md

@@ -1,8 +1,8 @@
 # Obsidian MCP Server
 
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue.svg)](https://www.typescriptlang.org/)
-[![Model Context Protocol](https://img.shields.io/badge/MCP-1.7.0-green.svg)](https://modelcontextprotocol.io/)
-[![Version](https://img.shields.io/badge/Version-1.5.0-blue.svg)]()
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.8.3-blue.svg)](https://www.typescriptlang.org/)
+[![Model Context Protocol](https://img.shields.io/badge/MCP-1.8.0-green.svg)](https://modelcontextprotocol.io/)
+[![Version](https://img.shields.io/badge/Version-1.5.2-blue.svg)]()
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Status](https://img.shields.io/badge/Status-Stable-green.svg)]()
 [![GitHub](https://img.shields.io/github/stars/cyanheads/obsidian-mcp-server?style=social)](https://github.com/cyanheads/obsidian-mcp-server)

package/build/mcp/handlers.js

@@ -57,8 +57,14 @@ export function setupToolListingHandler(server, toolHandlers) {
             // 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;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to list available tools', {
+                error: errorMessage,
+                stack: error instanceof Error ? error.stack : undefined,
+                errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+            });
+            // Wrap in ObsidianError
+            throw new ObsidianError(`Failed to list tools: ${errorMessage}`, McpErrorCode.INTERNAL_SERVER_ERROR, { originalError: errorMessage });
         }
     });
 }
@@ -107,8 +113,10 @@ export function setupToolCallingHandler(server, toolHandlers) {
         }
         // Add timeout handling
         const timeoutMs = DEFAULT_TIMEOUT_CONFIG.toolExecutionMs;
+        let timeoutId = null; // Variable to hold the timeout ID
         const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => {
+            timeoutId = setTimeout(() => {
+                timeoutId = null; // Clear the ID reference once the timeout executes
                 const errorInfo = {
                     toolName: name,
                     timeoutMs,
@@ -199,6 +207,13 @@ export function setupToolCallingHandler(server, toolHandlers) {
             logger.logOperationResult(false, 'call_tool', elapsedMs, errorInfo);
             throw new ObsidianError(`Tool '${name}' execution failed: ${errorMessage}`, McpErrorCode.INTERNAL_SERVER_ERROR, { originalError: errorMessage, stack: errorStack });
         }
+        finally {
+            // Ensure the timeout is cleared regardless of the outcome
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                logger.debug(`Cleared timeout for tool: ${name}`, { operationId });
+            }
+        }
     });
 }
 /**
@@ -224,8 +239,14 @@ export function setupResourceListingHandler(server, resources) {
             // 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;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to list available resources', {
+                error: errorMessage,
+                stack: error instanceof Error ? error.stack : undefined,
+                errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+            });
+            // Wrap in ObsidianError
+            throw new ObsidianError(`Failed to list resources: ${errorMessage}`, McpErrorCode.INTERNAL_SERVER_ERROR, { originalError: errorMessage });
         }
     });
 }

package/build/mcp/server.js

@@ -4,6 +4,7 @@
 import { config } from "dotenv";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ObsidianError } from "../utils/errors.js"; // Import ObsidianError
 import { createLogger, ErrorCategoryType } from "../utils/logging.js";
 import { rateLimiter } from "../utils/rate-limiting.js";
 import { createTagResource } from "../resources/index.js";
@@ -29,7 +30,8 @@ export async function initializeServer() {
                 errorCategory: ErrorCategoryType.CATEGORY_AUTHENTICATION,
                 errorCode: McpErrorCode.UNAUTHORIZED
             });
-            throw new Error("OBSIDIAN_API_KEY environment variable is required");
+            // Use ObsidianError for consistency
+            throw new ObsidianError("OBSIDIAN_API_KEY environment variable is required", McpErrorCode.UNAUTHORIZED);
         }
         // Initialize Obsidian client with environment configuration
         logger.info('Initializing Obsidian client', {
@@ -141,20 +143,11 @@ export function setupShutdownHandling(server, cleanupHandlers = []) {
         logger.startTimer('server_shutdown');
         logger.info('Shutting down server...', { signal });
         try {
-            // Run cleanup handlers
+            // Run cleanup handlers sequentially, stopping on error
             logger.debug('Running cleanup handlers', { handlersCount: cleanupHandlers.length });
             for (const handler of cleanupHandlers) {
-                try {
-                    await handler();
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    logger.error('Error during cleanup handler execution', {
-                        error: errorMessage,
-                        stack: error instanceof Error ? error.stack : undefined,
-                        errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
-                    });
-                }
+                // No try-catch here; let errors propagate to the main catch block
+                await handler();
             }
             // Dispose rate limiter
             logger.debug('Disposing rate limiter');

package/build/resources/tags.js

@@ -1,3 +1,4 @@
+import pLimit from 'p-limit'; // Import p-limit
 import { PropertyManager } from "../tools/properties/manager.js";
 import { sep } from "path";
 import { createLogger, ErrorCategoryType } from "../utils/logging.js";
@@ -33,6 +34,7 @@ export class TagResource {
     tagCache = new Map();
     propertyManager;
     isInitialized = false;
+    isUpdating = false; // Flag to prevent concurrent updates
     lastUpdate = 0;
     updateInterval = 5000; // 5 seconds
     constructor(client) {
@@ -64,24 +66,45 @@ export class TagResource {
             };
             const results = await this.client.searchJson(query);
             this.tagCache.clear();
-            // Process each file
-            for (const result of results) {
-                if (!('filename' in result))
-                    continue;
+            // Create a limiter with a concurrency of 3 (reduced from 10)
+            const limit = pLimit(3);
+            // Create promises for processing each file with concurrency limiting
+            const processingPromises = results
+                .filter(result => 'filename' in result) // Ensure filename exists
+                .map((result) => limit(async () => {
+                const filename = result.filename;
                 try {
-                    const content = await this.client.getFileContents(result.filename);
+                    // This call is now rate-limited
+                    const content = await this.client.getFileContents(filename);
                     // Only extract tags from frontmatter YAML
                     const properties = this.propertyManager.parseProperties(content);
-                    if (properties.tags) {
-                        properties.tags.forEach((tag) => {
-                            this.addTag(tag, result.filename);
+                    return { filename, tags: properties.tags || [] };
+                }
+                catch (error) {
+                    logger.error(`Failed to process file ${filename}:`, errorToObject(error));
+                    return { filename, error: true }; // Mark as failed
+                }
+            })); // Close the limiter wrapper
+            // Execute promises in parallel and wait for all to settle
+            const processedResults = await Promise.allSettled(processingPromises);
+            // Populate the cache from settled results
+            processedResults.forEach(settledResult => {
+                // Check if the promise was fulfilled and didn't encounter a processing error
+                if (settledResult.status === 'fulfilled' && !settledResult.value.error) {
+                    const { filename, tags } = settledResult.value;
+                    // Ensure tags is an array before iterating
+                    if (tags && Array.isArray(tags)) {
+                        tags.forEach((tag) => {
+                            this.addTag(tag, filename);
                         });
                     }
                 }
-                catch (error) {
-                    logger.error(`Failed to process file ${result.filename}:`, errorToObject(error));
+                else if (settledResult.status === 'rejected') {
+                    // Log unexpected rejections from the async map function itself
+                    logger.error(`Unexpected error during file processing setup:`, errorToObject(settledResult.reason));
                 }
-            }
+                // Errors during getFileContents/parseProperties are already logged within the map function
+            });
             this.isInitialized = true;
             this.lastUpdate = Date.now();
             const elapsedMs = logger.endTimer('init_tag_cache');
@@ -108,13 +131,47 @@ export class TagResource {
         this.tagCache.get(tag).add(filepath);
     }
     /**
-     * Update the cache if needed
+     * Update the cache if needed, preventing race conditions.
      */
     async updateCacheIfNeeded() {
         const now = Date.now();
-        if (now - this.lastUpdate > this.updateInterval) {
-            logger.debug('Tag cache needs update, refreshing...');
-            await this.initializeCache();
+        // Check if cache is fresh enough
+        if (now - this.lastUpdate <= this.updateInterval) {
+            return; // Cache is up-to-date
+        }
+        // Check if an update is already in progress
+        if (this.isUpdating) {
+            logger.debug('Cache update already in progress, skipping redundant update.');
+            // Optionally, wait for the ongoing update instead of returning immediately
+            // For now, we return to avoid complexity, potentially serving slightly stale data.
+            return;
+        }
+        // Acquire the update lock
+        this.isUpdating = true;
+        logger.debug('Acquired cache update lock.');
+        try {
+            // Double-check the update condition after acquiring the lock
+            // to handle cases where another process finished updating
+            // while this one was waiting for the lock (though less likely with a simple flag).
+            const nowAfterLock = Date.now();
+            if (nowAfterLock - this.lastUpdate > this.updateInterval) {
+                logger.info('Tag cache needs update, refreshing...');
+                await this.initializeCache(); // This method updates this.lastUpdate internally
+            }
+            else {
+                logger.debug('Cache was updated by another process while waiting for lock.');
+            }
+        }
+        catch (error) {
+            // Log error during update, but don't necessarily block other operations
+            logger.error('Error during cache update:', errorToObject(error));
+            // Decide if the error should be re-thrown or handled gracefully
+            // For now, we log and continue, allowing the lock to be released.
+        }
+        finally {
+            // Release the update lock
+            this.isUpdating = false;
+            logger.debug('Released cache update lock.');
         }
     }
     /**

package/build/tools/properties/manager.js

@@ -29,19 +29,26 @@ export class PropertyManager {
                 return {};
             }
             const frontmatter = match[1];
-            const properties = parse(frontmatter);
-            // Handle tags - don't add # prefix in frontmatter
-            if (properties.tags && Array.isArray(properties.tags)) {
-                properties.tags = properties.tags.map((tag) => tag.startsWith('#') ? tag.substring(1) : tag);
+            // Parse YAML first
+            const rawProperties = parse(frontmatter);
+            // Validate the raw parsed object against the schema
+            const validationResult = ObsidianPropertiesSchema.safeParse(rawProperties);
+            if (!validationResult.success) {
+                // Log validation errors and return empty if invalid
+                logger.warn('Frontmatter validation failed:', {
+                    validationError: validationResult.error.flatten()
+                });
+                return {}; // Return empty object for invalid frontmatter
             }
-            // Validate against schema
-            const result = ObsidianPropertiesSchema.safeParse(properties);
-            if (!result.success) {
-                logger.warn('Property validation warnings:', { validationError: result.error });
-                // Return the properties with fixed tags
-                return properties;
+            // Use the validated data from now on
+            const validatedProperties = validationResult.data;
+            // Handle tags transformation on validated data
+            if (validatedProperties.tags && Array.isArray(validatedProperties.tags)) {
+                // Create a new array to avoid modifying the validated data directly if needed elsewhere
+                validatedProperties.tags = validatedProperties.tags.map((tag) => tag.startsWith('#') ? tag.substring(1) : tag);
             }
-            return result.data;
+            // Return the validated (and potentially transformed) properties
+            return validatedProperties;
         }
         catch (error) {
             logger.error('Error parsing properties:', error instanceof Error ? error : { error: String(error) });

package/build/utils/idGenerator.js

@@ -0,0 +1,21 @@
+import { nanoid } from 'nanoid';
+/**
+ * Generates a unique, URL-friendly, 6-character alphanumeric ID.
+ * Uses nanoid's default alphabet (A-Za-z0-9_-).
+ *
+ * @returns A 6-character string ID.
+ */
+export function generateShortId() {
+    return nanoid(6);
+}
+/**
+ * Generates a unique ID with a specified prefix and length.
+ *
+ * @param prefix - The prefix for the ID (e.g., 'prj', 'tsk', 'knw').
+ * @param length - The desired length of the random part of the ID (default: 10).
+ * @returns A prefixed ID string (e.g., 'prj_aBcDeFgHiJ').
+ */
+export function generatePrefixedId(prefix, length = 10) {
+    return `${prefix}_${nanoid(length)}`;
+}
+//# sourceMappingURL=idGenerator.js.map

package/build/utils/tokenization.js

@@ -11,20 +11,27 @@ export const TRUNCATION_MESSAGE = "\n\n[Response truncated due to length]";
 export class TokenCounter {
     tokenizer = encoding_for_model("gpt-4"); // This is strictly for token counting, not for LLM inference
     isShuttingDown = false;
+    cleanupListener;
     constructor() {
-        // Clean up tokenizer when process exits
-        const cleanup = () => {
+        // Define the cleanup logic
+        this.cleanupListener = () => {
             if (!this.isShuttingDown) {
                 this.isShuttingDown = true;
                 if (this.tokenizer) {
                     this.tokenizer.free();
+                    // No need to explicitly set this.tokenizer to null,
+                    // but ensure it's not used after free()
                 }
+                // Remove listeners after execution to prevent multiple calls
+                // and potential leaks if cleanup is called manually before exit
+                this.removeListeners();
             }
         };
-        process.on('exit', cleanup);
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
-        process.on('uncaughtException', cleanup);
+        // Attach listeners
+        process.on('exit', this.cleanupListener);
+        process.on('SIGINT', this.cleanupListener);
+        process.on('SIGTERM', this.cleanupListener);
+        process.on('uncaughtException', this.cleanupListener);
     }
     /**
      * Count the number of tokens in a string
@@ -48,13 +55,19 @@ export class TokenCounter {
         return truncatedText + TRUNCATION_MESSAGE;
     }
     /**
-     * Clean up resources
+     * Clean up resources and remove listeners
      */
     cleanup() {
-        if (this.tokenizer && !this.isShuttingDown) {
-            this.isShuttingDown = true;
-            this.tokenizer.free();
-        }
+        this.cleanupListener(); // Call the main cleanup logic
+    }
+    /**
+     * Remove process event listeners
+     */
+    removeListeners() {
+        process.off('exit', this.cleanupListener);
+        process.off('SIGINT', this.cleanupListener);
+        process.off('SIGTERM', this.cleanupListener);
+        process.off('uncaughtException', this.cleanupListener);
     }
 }
 // Export a singleton instance

package/build/utils/validation.js

@@ -1,6 +1,8 @@
 /**
  * Validation utilities for the Obsidian MCP Server
  */
+import { McpErrorCode } from "../mcp/types.js";
+import { ObsidianError } from "./errors.js";
 /**
  * Validates a file path to prevent path traversal attacks and other security issues
  * @param filepath The path to validate
@@ -10,11 +12,13 @@ export function validateFilePath(filepath) {
     // Prevent path traversal attacks
     const normalizedPath = filepath.replace(/\\/g, '/');
     if (normalizedPath.includes('../') || normalizedPath.includes('..\\')) {
-        throw new Error('Invalid file path: Path traversal not allowed');
+        // Use ObsidianError for consistency
+        throw new ObsidianError('Invalid file path: Path traversal not allowed', McpErrorCode.BAD_REQUEST);
     }
-    // Additional path validations
+    // Additional path validations (check for absolute paths Unix or Windows style)
     if (normalizedPath.startsWith('/') || /^[a-zA-Z]:/.test(normalizedPath)) {
-        throw new Error('Invalid file path: Absolute paths not allowed');
+        // Use ObsidianError for consistency
+        throw new ObsidianError('Invalid file path: Absolute paths not allowed', McpErrorCode.BAD_REQUEST);
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-mcp-server",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "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",
@@ -19,21 +19,23 @@
     "format": "prettier --write \"src/**/*.ts\""
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.7.0",
-    "axios": "^1.8.3",
+    "@modelcontextprotocol/sdk": "^1.8.0",
+    "@types/node": "^22.14.0",
+    "@typescript-eslint/eslint-plugin": "^8.29.0",
+    "@typescript-eslint/parser": "^8.29.0",
+    "axios": "^1.8.4",
     "dotenv": "^16.4.7",
-    "tiktoken": "^1.0.20",
-    "yaml": "^2.7.0",
-    "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": "^9.24.0",
     "eslint-config-prettier": "^10.1.1",
-    "eslint-plugin-prettier": "^5.2.3",
+    "eslint-plugin-prettier": "^5.2.6",
+    "nanoid": "^5.1.5",
+    "p-limit": "^6.2.0",
     "prettier": "^3.5.3",
-    "typescript": "^5.8.2"
+    "tiktoken": "^1.0.20",
+    "typescript": "^5.8.3",
+    "winston": "^3.17.0",
+    "yaml": "^2.7.1",
+    "zod": "^3.24.2"
   },
   "keywords": [
     "mcp",

package/repomix.config.json

@@ -0,0 +1,20 @@
+{
+  "output": {
+    "filePath": "repomix-output.xml",
+    "style": "xml",
+    "removeComments": false,
+    "removeEmptyLines": false,
+    "topFilesLength": 5,
+    "showLineNumbers": false,
+    "copyToClipboard": false
+  },
+  "include": [],
+  "ignore": {
+    "useGitignore": true,
+    "useDefaultPatterns": true,
+    "customPatterns": []
+  },
+  "security": {
+    "enableSecurityCheck": true
+  }
+}

package/src/mcp/handlers.ts

@@ -85,8 +85,18 @@ export function setupToolListingHandler(
       // 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;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error('Failed to list available tools', { 
+        error: errorMessage, 
+        stack: error instanceof Error ? error.stack : undefined,
+        errorCategory: ErrorCategoryType.CATEGORY_SYSTEM 
+      });
+      // Wrap in ObsidianError
+      throw new ObsidianError(
+        `Failed to list tools: ${errorMessage}`,
+        McpErrorCode.INTERNAL_SERVER_ERROR,
+        { originalError: errorMessage }
+      );
     }
   });
 }
@@ -152,8 +162,10 @@ export function setupToolCallingHandler(
 
     // Add timeout handling
     const timeoutMs = DEFAULT_TIMEOUT_CONFIG.toolExecutionMs;
+    let timeoutId: NodeJS.Timeout | null = null; // Variable to hold the timeout ID
     const timeoutPromise = new Promise<never>((_, reject) => {
-      setTimeout(() => {
+      timeoutId = setTimeout(() => {
+        timeoutId = null; // Clear the ID reference once the timeout executes
         const errorInfo = {
           toolName: name,
           timeoutMs,
@@ -269,6 +281,12 @@ export function setupToolCallingHandler(
         McpErrorCode.INTERNAL_SERVER_ERROR,
         { originalError: errorMessage, stack: errorStack }
       );
+    } finally {
+      // Ensure the timeout is cleared regardless of the outcome
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        logger.debug(`Cleared timeout for tool: ${name}`, { operationId });
+      }
     }
   });
 }
@@ -302,8 +320,18 @@ export function setupResourceListingHandler(
       // 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;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error('Failed to list available resources', { 
+        error: errorMessage, 
+        stack: error instanceof Error ? error.stack : undefined,
+        errorCategory: ErrorCategoryType.CATEGORY_SYSTEM 
+      });
+      // Wrap in ObsidianError
+      throw new ObsidianError(
+        `Failed to list resources: ${errorMessage}`,
+        McpErrorCode.INTERNAL_SERVER_ERROR,
+        { originalError: errorMessage }
+      );
     }
   });
 }
@@ -382,4 +410,4 @@ export function setupResourceReadingHandler(
       );
     }
   });
-}
+}

package/src/mcp/server.ts

@@ -4,6 +4,7 @@
 import { config } from "dotenv";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ObsidianError } from "../utils/errors.js"; // Import ObsidianError
 import { createLogger, ErrorCategoryType } from "../utils/logging.js";
 import { rateLimiter } from "../utils/rate-limiting.js";
 import { createTagResource } from "../resources/index.js";
@@ -40,11 +41,15 @@ export async function initializeServer(): Promise<Server> {
     if (!API_KEY) {
       logger.error("Missing API key", {
         errorCategory: ErrorCategoryType.CATEGORY_AUTHENTICATION,
-        errorCode: McpErrorCode.UNAUTHORIZED
-      });
-      throw new Error("OBSIDIAN_API_KEY environment variable is required");
-    }
-
+         errorCode: McpErrorCode.UNAUTHORIZED
+       });
+       // Use ObsidianError for consistency
+       throw new ObsidianError(
+         "OBSIDIAN_API_KEY environment variable is required",
+         McpErrorCode.UNAUTHORIZED
+       );
+     }
+ 
     // Initialize Obsidian client with environment configuration
     logger.info('Initializing Obsidian client', {
       verifySSL: process.env.VERIFY_SSL === 'true',
@@ -174,19 +179,11 @@ export function setupShutdownHandling(
     logger.info('Shutting down server...', { signal });
     
     try {
-      // Run cleanup handlers
+      // Run cleanup handlers sequentially, stopping on error
       logger.debug('Running cleanup handlers', { handlersCount: cleanupHandlers.length });
       for (const handler of cleanupHandlers) {
-        try {
-          await handler();
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          logger.error('Error during cleanup handler execution', {
-            error: errorMessage,
-            stack: error instanceof Error ? error.stack : undefined,
-            errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
-          });
-        }
+        // No try-catch here; let errors propagate to the main catch block
+        await handler(); 
       }
       
       // Dispose rate limiter
@@ -288,4 +285,4 @@ export async function run(): Promise<void> {
     
     process.exit(1);
   }
-}
+}