obsidian-mcp-server 1.4.0 → 1.5.0

package/build/tools/search/complex.js

@@ -1,8 +1,30 @@
 import { PropertyManager } from "../properties/manager.js";
 import { BaseToolHandler } from "../base.js";
-import { createLogger } from "../../utils/logging.js";
+import { createLogger, ErrorCategoryType } from "../../utils/logging.js";
 // Create a logger for complex search operations
 const logger = createLogger('ComplexSearchTools');
+/**
+ * Helper function to safely convert any error to an object
+ */
+function errorToObject(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+            errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+        };
+    }
+    else if (typeof error === 'object' && error !== null) {
+        return error;
+    }
+    else {
+        return {
+            error: String(error),
+            errorCategory: ErrorCategoryType.CATEGORY_UNKNOWN
+        };
+    }
+}
 /**
  * Tool name for complex search
  */
@@ -49,8 +71,11 @@ export class ComplexSearchToolHandler extends BaseToolHandler {
         };
     }
     async runTool(args) {
+        logger.startTimer('complex_search');
         try {
-            logger.debug(`Executing complex search with query: ${JSON.stringify(args.query)}`);
+            logger.debug(`Executing complex search with query: ${JSON.stringify(args.query)}`, {
+                queryType: Object.keys(args.query)[0]
+            });
             // Perform search
             const results = await this.client.searchJson(args.query);
             // Format response based on result type
@@ -71,6 +96,11 @@ export class ComplexSearchToolHandler extends BaseToolHandler {
                     };
                 }
             });
+            const elapsedMs = logger.endTimer('complex_search');
+            logger.logOperationResult(true, 'complex_search', elapsedMs, {
+                resultCount: results.length,
+                queryType: Object.keys(args.query)[0]
+            });
             logger.debug(`Complex search found ${results.length} results`);
             return this.createResponse({
                 message: `Found ${results.length} result(s)`,
@@ -78,7 +108,11 @@ export class ComplexSearchToolHandler extends BaseToolHandler {
             });
         }
         catch (error) {
-            logger.error(`Complex search error: ${error}`);
+            const elapsedMs = logger.endTimer('complex_search');
+            logger.logOperationResult(false, 'complex_search', elapsedMs, {
+                queryType: Object.keys(args.query)[0]
+            });
+            logger.error(`Complex search error`, errorToObject(error));
             return this.handleError(error);
         }
     }
@@ -142,6 +176,8 @@ export class GetTagsToolHandler extends BaseToolHandler {
         };
     }
     async runTool(args) {
+        const operationId = `get_tags_${args.path || 'vault'}`;
+        logger.startTimer(operationId);
         try {
             logger.debug(`Getting tags${args.path ? ` in path: ${args.path}` : ' in whole vault'}`);
             const tagMap = new Map();
@@ -151,6 +187,7 @@ export class GetTagsToolHandler extends BaseToolHandler {
                 : { "glob": ["**/*.md", { "var": "path" }] };
             const results = await this.client.searchJson(query);
             let scannedFiles = 0;
+            let processedSuccessfully = 0;
             // Process each file to extract tags from frontmatter
             for (const result of results) {
                 if (!('filename' in result))
@@ -171,14 +208,23 @@ export class GetTagsToolHandler extends BaseToolHandler {
                             tagMap.get(cleanTag).add(result.filename);
                         }
                     }
+                    processedSuccessfully++;
                 }
                 catch (error) {
-                    logger.error(`Failed to process file ${result.filename}:`, error);
+                    logger.error(`Failed to process file ${result.filename}:`, errorToObject(error));
                 }
             }
             // Calculate total occurrences
             const totalOccurrences = Array.from(tagMap.values())
                 .reduce((sum, files) => sum + files.size, 0);
+            const elapsedMs = logger.endTimer(operationId);
+            logger.logOperationResult(true, 'get_tags', elapsedMs, {
+                uniqueTags: tagMap.size,
+                totalOccurrences,
+                scannedFiles,
+                processedSuccessfully,
+                searchPath: args.path || 'vault'
+            });
             return this.createResponse({
                 tags: Array.from(tagMap.entries())
                     .map(([name, files]) => ({
@@ -196,6 +242,11 @@ export class GetTagsToolHandler extends BaseToolHandler {
             });
         }
         catch (error) {
+            const elapsedMs = logger.endTimer(operationId);
+            logger.logOperationResult(false, 'get_tags', elapsedMs, {
+                searchPath: args.path || 'vault',
+                error: errorToObject(error)
+            });
             return this.handleError(error);
         }
     }

package/build/utils/logging.js

@@ -1,17 +1,66 @@
 /**
- * Logging utilities for the Obsidian MCP Server
+ * Standardized Logging System for the Obsidian MCP Server
+ *
+ * This module provides structured logging capabilities aligned with MCP best practices.
+ * It supports categorized errors, severity levels, context tracking, performance
+ * monitoring, and secure logging patterns.
+ *
+ * @module utils/logging
  */
+import fs from "fs";
+import path from "path";
+import process from "process";
+import winston from "winston";
 /**
- * Log levels
+ * Error categories following MCP standards
+ */
+export var ErrorCategoryType;
+(function (ErrorCategoryType) {
+    ErrorCategoryType["CATEGORY_VALIDATION"] = "VALIDATION";
+    ErrorCategoryType["CATEGORY_AUTHENTICATION"] = "AUTHENTICATION";
+    ErrorCategoryType["CATEGORY_AUTHORIZATION"] = "AUTHORIZATION";
+    ErrorCategoryType["CATEGORY_BUSINESS_LOGIC"] = "BUSINESS_LOGIC";
+    ErrorCategoryType["CATEGORY_DATA_ACCESS"] = "DATA_ACCESS";
+    ErrorCategoryType["CATEGORY_EXTERNAL_SERVICE"] = "EXTERNAL_SERVICE";
+    ErrorCategoryType["CATEGORY_SYSTEM"] = "SYSTEM";
+    ErrorCategoryType["CATEGORY_UNKNOWN"] = "UNKNOWN";
+})(ErrorCategoryType || (ErrorCategoryType = {}));
+/**
+ * Log levels aligned with MCP's ErrorSeverityLevel
  */
 export var LogLevel;
 (function (LogLevel) {
+    /** Critical errors that require immediate attention */
     LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    /** Potentially harmful situations that should be reviewed */
     LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    /** General informational messages about system operation */
     LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    /** Detailed information for debugging purposes */
     LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    /** Highly detailed tracing information */
     LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
 })(LogLevel || (LogLevel = {}));
+/**
+ * Maps LogLevel to MCP severity level for integration with MCP error handling
+ */
+export const logLevelToMcpSeverity = {
+    [LogLevel.ERROR]: 3, // SEVERITY_ERROR
+    [LogLevel.WARN]: 2, // SEVERITY_WARN
+    [LogLevel.INFO]: 1, // SEVERITY_INFO
+    [LogLevel.DEBUG]: 0, // SEVERITY_DEBUG
+    [LogLevel.TRACE]: 0 // Also maps to SEVERITY_DEBUG
+};
+/**
+ * Winston-compatible log levels
+ */
+const winstonLogLevels = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    trace: 4
+};
 /**
  * Default logger configuration
  */
@@ -20,100 +69,349 @@ const DEFAULT_CONFIG = {
         ? LogLevel.INFO
         : LogLevel.DEBUG,
     includeTimestamps: true,
-    includeLevel: true
+    includeLevel: true,
+    maskSensitiveData: true,
+    sensitiveFields: ['password', 'token', 'secret', 'key', 'auth', 'credential'],
+    logDir: "logs",
+    files: true,
+    fileNames: {
+        combined: "combined.log",
+        error: "error.log",
+        warn: "warn.log",
+        info: "info.log",
+        debug: "debug.log"
+    }
 };
 /**
- * Simple logger for MCP server operations
+ * Enhanced logger for MCP server operations with structured logging support
+ * Implements file-based logging with zero console output
  */
 export class Logger {
     name;
     config;
+    timers = new Map();
+    logger;
+    /**
+     * Creates a new logger instance
+     *
+     * @param name - Component name for this logger
+     * @param config - Optional configuration overrides
+     */
     constructor(name, config = {}) {
         this.name = name;
-        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+            fileNames: {
+                ...DEFAULT_CONFIG.fileNames,
+                ...config.fileNames
+            }
+        };
+        // Initialize logger with silent transport as fallback
+        this.logger = winston.createLogger({
+            levels: winstonLogLevels,
+            defaultMeta: { component: this.name },
+            transports: [
+                // Silent transport to prevent "no transports" warning
+                new winston.transports.Console({
+                    silent: true
+                })
+            ]
+        });
+        this.initializeLogger();
     }
     /**
-     * Internal method to format and output a log message
+     * Initialize or reinitialize the Winston logger
      */
-    log(level, message, ...args) {
-        if (level > this.config.level)
-            return;
-        const parts = [];
-        // Add timestamp if configured
-        if (this.config.includeTimestamps) {
-            parts.push(`[${new Date().toISOString()}]`);
+    initializeLogger() {
+        if (this.config.files && this.config.logDir) {
+            if (!fs.existsSync(this.config.logDir)) {
+                try {
+                    fs.mkdirSync(this.config.logDir, { recursive: true });
+                }
+                catch (error) {
+                    // Silently continue - we have a silent transport as fallback
+                }
+            }
         }
-        // Add level if configured
-        if (this.config.includeLevel) {
-            const levelStr = LogLevel[level] || 'UNKNOWN';
-            parts.push(`[${levelStr}]`);
+        // Create log format
+        const logFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json());
+        // Initialize transports array with a silent transport to avoid "no transports" warning
+        const transports = [
+            new winston.transports.Console({
+                silent: true, // Silent transport that doesn't output logs
+                format: logFormat
+            })
+        ];
+        // Add file transports if enabled
+        if (this.config.files && this.config.logDir) {
+            try {
+                const fileNames = this.config.fileNames || DEFAULT_CONFIG.fileNames;
+                // Combined log file
+                if (fileNames?.combined) {
+                    transports.push(new winston.transports.File({
+                        filename: path.join(this.config.logDir, fileNames.combined),
+                        format: logFormat
+                    }));
+                }
+                // Level-specific log files
+                if (fileNames?.error) {
+                    transports.push(new winston.transports.File({
+                        filename: path.join(this.config.logDir, fileNames.error),
+                        level: 'error',
+                        format: logFormat
+                    }));
+                }
+                if (fileNames?.warn) {
+                    transports.push(new winston.transports.File({
+                        filename: path.join(this.config.logDir, fileNames.warn),
+                        level: 'warn',
+                        format: logFormat
+                    }));
+                }
+                if (fileNames?.info) {
+                    transports.push(new winston.transports.File({
+                        filename: path.join(this.config.logDir, fileNames.info),
+                        level: 'info',
+                        format: logFormat
+                    }));
+                }
+                if (fileNames?.debug) {
+                    transports.push(new winston.transports.File({
+                        filename: path.join(this.config.logDir, fileNames.debug),
+                        level: 'debug',
+                        format: logFormat
+                    }));
+                }
+            }
+            catch (error) {
+                // Silently continue with just the silent transport if file transports fail
+            }
         }
-        // Add component name
-        parts.push(`[${this.name}]`);
-        // Add message
-        parts.push(message);
-        // Output to console
-        const output = parts.join(' ');
-        switch (level) {
-            case LogLevel.ERROR:
-                console.error(output, ...args);
-                break;
-            case LogLevel.WARN:
-                console.warn(output, ...args);
-                break;
-            case LogLevel.INFO:
-                console.info(output, ...args);
-                break;
-            case LogLevel.DEBUG:
-            case LogLevel.TRACE:
-            default:
-                console.debug(output, ...args);
-                break;
+        // Replace logger configuration
+        this.logger.configure({
+            levels: winstonLogLevels,
+            level: LogLevel[this.config.level].toLowerCase(),
+            defaultMeta: { component: this.name },
+            transports
+        });
+    }
+    /**
+     * Maps internal LogLevel to Winston log level
+     */
+    levelToWinstonLevel(level) {
+        const levelName = LogLevel[level].toLowerCase();
+        return levelName === 'trace' ? 'debug' : levelName;
+    }
+    /**
+     * Creates a standardized error object for MCP compatibility
+     *
+     * @param message - Human-readable error description
+     * @param code - Machine-readable error identifier
+     * @param category - Type of error
+     * @param context - Additional error context
+     * @returns Standardized error object
+     */
+    createStandardizedError(message, code, category = ErrorCategoryType.CATEGORY_UNKNOWN, context) {
+        return {
+            errorMessage: message,
+            errorCode: code,
+            errorCategory: category,
+            errorSeverity: LogLevel.ERROR,
+            errorTimestamp: new Date().toISOString(),
+            errorContext: context ? this.processSensitiveData(context) : undefined,
+            errorStack: new Error().stack
+        };
+    }
+    /**
+     * Wraps an exception as a standardized error
+     *
+     * @param error - Original error object
+     * @param message - Optional override message
+     * @param category - Error category
+     * @returns Standardized error object
+     */
+    wrapExceptionAsStandardizedError(error, message, category = ErrorCategoryType.CATEGORY_UNKNOWN) {
+        const errorObject = error instanceof Error ? error : new Error(String(error));
+        return {
+            errorMessage: message || errorObject.message,
+            errorCode: errorObject.name || 'UNKNOWN_ERROR',
+            errorCategory: category,
+            errorSeverity: LogLevel.ERROR,
+            errorTimestamp: new Date().toISOString(),
+            errorStack: errorObject.stack
+        };
+    }
+    /**
+     * Masks sensitive data in objects before logging
+     *
+     * @param data - Data object to process
+     * @returns Processed data with sensitive fields masked
+     */
+    processSensitiveData(data) {
+        if (!this.config.maskSensitiveData)
+            return data;
+        const result = {};
+        const sensitiveFields = this.config.sensitiveFields;
+        for (const [key, value] of Object.entries(data)) {
+            // Check if key contains any sensitive field name
+            const isSensitive = sensitiveFields.some(field => key.toLowerCase().includes(field.toLowerCase()));
+            if (isSensitive) {
+                // Mask sensitive values
+                result[key] = '********';
+            }
+            else if (value && typeof value === 'object' && !Array.isArray(value)) {
+                // Recursively process nested objects
+                result[key] = this.processSensitiveData(value);
+            }
+            else {
+                // Pass through non-sensitive values
+                result[key] = value;
+            }
         }
+        return result;
     }
     /**
-     * Log an error message
+     * Internal method to log a message using Winston
+     *
+     * @param level - Log level
+     * @param message - Log message
+     * @param context - Optional context data
      */
-    error(message, ...args) {
-        this.log(LogLevel.ERROR, message, ...args);
+    log(level, message, context) {
+        if (level > this.config.level)
+            return;
+        const winstonLevel = this.levelToWinstonLevel(level);
+        const processedContext = context ? this.processSensitiveData(context) : undefined;
+        this.logger.log(winstonLevel, message, { context: processedContext });
+    }
+    /**
+     * Log an error message with optional error object and context
+     *
+     * @param message - Error message
+     * @param errorOrContext - Error object or context
+     * @param context - Additional context
+     */
+    error(message, errorOrContext, context) {
+        if (errorOrContext instanceof Error) {
+            const errorObj = this.wrapExceptionAsStandardizedError(errorOrContext);
+            const combinedContext = {
+                ...(context || {}),
+                error: errorObj
+            };
+            this.log(LogLevel.ERROR, message, combinedContext);
+        }
+        else {
+            this.log(LogLevel.ERROR, message, errorOrContext || context);
+        }
     }
     /**
      * Log a warning message
+     *
+     * @param message - Warning message
+     * @param context - Optional context data
      */
-    warn(message, ...args) {
-        this.log(LogLevel.WARN, message, ...args);
+    warn(message, context) {
+        this.log(LogLevel.WARN, message, context);
     }
     /**
      * Log an info message
+     *
+     * @param message - Info message
+     * @param context - Optional context data
      */
-    info(message, ...args) {
-        this.log(LogLevel.INFO, message, ...args);
+    info(message, context) {
+        this.log(LogLevel.INFO, message, context);
     }
     /**
      * Log a debug message
+     *
+     * @param message - Debug message
+     * @param context - Optional context data
      */
-    debug(message, ...args) {
-        this.log(LogLevel.DEBUG, message, ...args);
+    debug(message, context) {
+        this.log(LogLevel.DEBUG, message, context);
     }
     /**
      * Log a trace message
+     *
+     * @param message - Trace message
+     * @param context - Optional context data
      */
-    trace(message, ...args) {
-        this.log(LogLevel.TRACE, message, ...args);
+    trace(message, context) {
+        this.log(LogLevel.TRACE, message, context);
     }
     /**
      * Set the log level
+     *
+     * @param level - New log level
      */
     setLevel(level) {
         this.config.level = level;
+        this.logger.level = this.levelToWinstonLevel(level);
+    }
+    /**
+     * Start a timer for performance tracking
+     *
+     * @param id - Timer identifier
+     */
+    startTimer(id) {
+        this.timers.set(id, performance.now());
+    }
+    /**
+     * End a timer and log the elapsed time
+     *
+     * @param id - Timer identifier
+     * @param message - Log message prefix
+     * @param level - Log level for the timing message
+     */
+    endTimer(id, message = 'Operation completed', level = LogLevel.DEBUG) {
+        const startTime = this.timers.get(id);
+        if (startTime === undefined) {
+            this.warn(`Timer "${id}" does not exist`, { action: 'endTimer' });
+            return 0;
+        }
+        const endTime = performance.now();
+        const elapsedMs = endTime - startTime;
+        this.log(level, `${message} in ${elapsedMs.toFixed(2)}ms`, {
+            timerId: id,
+            processingTimeMs: elapsedMs
+        });
+        this.timers.delete(id);
+        return elapsedMs;
+    }
+    /**
+     * Log the result of an operation with timing information
+     *
+     * @param success - Whether the operation was successful
+     * @param operation - Operation name
+     * @param elapsedMs - Processing time in milliseconds
+     * @param context - Optional operation context
+     */
+    logOperationResult(success, operation, elapsedMs, context) {
+        const level = success ? LogLevel.INFO : LogLevel.ERROR;
+        const status = success ? 'succeeded' : 'failed';
+        this.log(level, `Operation ${operation} ${status}`, {
+            ...(context || {}),
+            operation,
+            success,
+            processingTimeMs: elapsedMs
+        });
     }
 }
 /**
  * Create and return a namespaced logger
+ *
+ * @param name - Component name for the logger
+ * @param config - Optional configuration overrides
+ * @returns Configured logger instance
  */
 export function createLogger(name, config) {
     return new Logger(name, config);
 }
 // Create a global root logger
-export const rootLogger = createLogger('mcp-server');
+export const rootLogger = createLogger('obsidian-mcp-server', {
+    files: true,
+    logDir: "logs"
+});
 //# sourceMappingURL=logging.js.map

package/debug.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+// Debug script to run the server with verbose logging
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+// Get current directory from import.meta
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Create logs directory if it doesn't exist
+const logsDir = path.join(__dirname, 'logs');
+if (!fs.existsSync(logsDir)) {
+  fs.mkdirSync(logsDir, { recursive: true });
+}
+
+// Create log file stream
+const logFile = path.join(logsDir, `debug-server-${new Date().toISOString().replace(/[:.]/g, '-')}.log`);
+const logStream = fs.createWriteStream(logFile, { flags: 'a' });
+
+console.log(`Starting Obsidian MCP Server in debug mode...`);
+console.log(`Logs will be written to: ${logFile}`);
+
+// Environment variables from MCP settings
+const env = {
+  ...process.env,
+  DEBUG_JSONRPC: 'true',
+  NODE_ENV: 'development',
+  // Required environment variables from MCP settings
+  OBSIDIAN_API_KEY: '9bde5e9fb07951daa75819a1704ce75fd597955205141d3b39e5e1423ddbc97c',
+  VERIFY_SSL: 'false',
+  OBSIDIAN_PROTOCOL: 'https',
+  OBSIDIAN_HOST: '127.0.0.1',
+  OBSIDIAN_PORT: '27124',
+  REQUEST_TIMEOUT: '5000',
+  MAX_CONTENT_LENGTH: String(50 * 1024 * 1024),
+  MAX_BODY_LENGTH: String(50 * 1024 * 1024),
+  RATE_LIMIT_WINDOW_MS: '900000',
+  RATE_LIMIT_MAX_REQUESTS: '200',
+  TOOL_TIMEOUT_MS: '60000'
+};
+
+// Start the server process
+const serverProcess = spawn('node', ['build/index.js'], {
+  env,
+  stdio: ['pipe', 'pipe', 'pipe']
+});
+
+// Log process output
+serverProcess.stdout.on('data', (data) => {
+  const output = data.toString();
+  process.stdout.write(output);
+  logStream.write(`[STDOUT] ${output}`);
+});
+
+serverProcess.stderr.on('data', (data) => {
+  const output = data.toString();
+  process.stderr.write(output);
+  logStream.write(`[STDERR] ${output}`);
+});
+
+// Handle process exit
+serverProcess.on('exit', (code) => {
+  const message = `Server process exited with code ${code}`;
+  console.log(message);
+  logStream.write(`${message}\n`);
+  logStream.end();
+});
+
+// Handle errors
+serverProcess.on('error', (err) => {
+  const message = `Error starting server: ${err.message}`;
+  console.error(message);
+  logStream.write(`[ERROR] ${message}\n`);
+  logStream.end();
+});
+
+// Handle uncaught exceptions
+process.on('uncaughtException', (err) => {
+  const message = `Uncaught exception: ${err.message}\n${err.stack}`;
+  console.error(message);
+  logStream.write(`[UNCAUGHT] ${message}\n`);
+  logStream.end();
+  process.exit(1);
+});
+
+// Set up cleanup
+const cleanup = () => {
+  if (serverProcess && !serverProcess.killed) {
+    serverProcess.kill();
+  }
+  logStream.end();
+};
+
+process.on('SIGINT', cleanup);
+process.on('SIGTERM', cleanup);