obsidian-mcp-server 1.3.0 → 1.4.1

package/build/{obsidian.js → obsidian/client.js}

@@ -1,42 +1,54 @@
+/**
+ * Obsidian REST API client implementation
+ */
 import axios from "axios";
-import { ObsidianError, DEFAULT_OBSIDIAN_CONFIG } from "./types.js";
 import { Agent } from "node:https";
 import { readFileSync } from "fs";
 import { fileURLToPath } from 'url';
 import { dirname, join } from "path";
+import { createLogger } from '../utils/logging.js';
+import { ObsidianError } from '../utils/errors.js';
+import { validateFilePath, sanitizeHeader } from '../utils/validation.js';
+import { DEFAULT_OBSIDIAN_CONFIG } from './types.js';
+import { createMissingAPIKeyMessage, handleAxiosError } from './errors.js';
+// Logger for the ObsidianClient
+const logger = createLogger('ObsidianClient');
 // Get package version for user agent
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const VERSION = (() => {
     try {
         // Look for package.json in the same directory as the built files
-        const packagePath = join(__dirname, '..', 'package.json');
+        const packagePath = join(__dirname, '..', '..', 'package.json');
         const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
         return pkg.version;
     }
     catch (error) {
         // Try alternative location for development
         try {
-            const devPackagePath = join(__dirname, '..', '..', 'package.json');
+            const devPackagePath = join(__dirname, '..', '..', '..', 'package.json');
             const pkg = JSON.parse(readFileSync(devPackagePath, 'utf-8'));
             return pkg.version;
         }
         catch (devError) {
-            console.warn('Could not read package.json version, using fallback');
+            logger.warn('Could not read package.json version, using fallback');
             return '1.1.0'; // Fallback version
         }
     }
 })();
+/**
+ * Client for interacting with the Obsidian Local REST API
+ */
 export class ObsidianClient {
     client;
     config;
+    /**
+     * Create a new ObsidianClient
+     * @param config Configuration for the client
+     */
     constructor(config) {
         if (!config.apiKey) {
-            throw new ObsidianError("Missing API key. To fix this:\n" +
-                "1. Install the 'Local REST API' plugin in Obsidian\n" +
-                "2. Enable the plugin in Obsidian Settings\n" +
-                "3. Copy your API key from Obsidian Settings > Local REST API\n" +
-                "4. Provide the API key in your configuration", 40100 // Unauthorized
+            throw new ObsidianError(createMissingAPIKeyMessage(), 40100 // Unauthorized
             );
         }
         // Determine if we're in a development environment
@@ -89,7 +101,7 @@ export class ObsidianClient {
             decompress: true
         };
         if (!this.config.verifySSL) {
-            console.warn("WARNING: SSL verification is disabled. While this works for development, it's not recommended for production.\n" +
+            logger.warn("WARNING: SSL verification is disabled. While this works for development, it's not recommended for production.\n" +
                 "To properly configure SSL certificates:\n" +
                 "1. Go to Obsidian Settings > Local REST API\n" +
                 "2. Under 'How to Access', copy the certificate\n" +
@@ -104,9 +116,15 @@ export class ObsidianClient {
         }
         this.client = axios.create(axiosConfig);
     }
+    /**
+     * Get the base URL for the Obsidian API
+     */
     getBaseUrl() {
         return `${this.config.protocol}://${this.config.host}:${this.config.port}`;
     }
+    /**
+     * Get headers for requests to the Obsidian API
+     */
     getHeaders() {
         const headers = {
             Authorization: `Bearer ${this.config.apiKey}`,
@@ -116,93 +134,19 @@ export class ObsidianClient {
         // Sanitize headers
         return Object.fromEntries(Object.entries(headers).map(([key, value]) => [
             key,
-            this.sanitizeHeader(value)
+            sanitizeHeader(value)
         ]));
     }
-    sanitizeHeader(value) {
-        // Remove any potentially harmful characters from header values
-        return value.replace(/[^\w\s\-\._~:/?#\[\]@!$&'()*+,;=]/g, '');
-    }
-    validateFilePath(filepath) {
-        // Prevent path traversal attacks
-        const normalizedPath = filepath.replace(/\\/g, '/');
-        if (normalizedPath.includes('../') || normalizedPath.includes('..\\')) {
-            throw new ObsidianError('Invalid file path: Path traversal not allowed', 40001);
-        }
-        // Additional path validations
-        if (normalizedPath.startsWith('/') || /^[a-zA-Z]:/.test(normalizedPath)) {
-            throw new ObsidianError('Invalid file path: Absolute paths not allowed', 40002);
-        }
-    }
-    getErrorCode(status) {
-        switch (status) {
-            case 400: return 40000; // Bad request
-            case 401: return 40100; // Unauthorized
-            case 403: return 40300; // Forbidden
-            case 404: return 40400; // Not found
-            case 405: return 40500; // Method not allowed
-            case 409: return 40900; // Conflict
-            case 429: return 42900; // Too many requests
-            case 500: return 50000; // Internal server error
-            case 501: return 50100; // Not implemented
-            case 502: return 50200; // Bad gateway
-            case 503: return 50300; // Service unavailable
-            case 504: return 50400; // Gateway timeout
-            default:
-                if (status >= 400 && status < 500)
-                    return 40000 + (status - 400) * 100;
-                if (status >= 500 && status < 600)
-                    return 50000 + (status - 500) * 100;
-                return 50000;
-        }
-    }
+    /**
+     * Safely execute an API request with error handling
+     */
     async safeRequest(operation) {
         try {
             return await operation();
         }
         catch (error) {
             if (axios.isAxiosError(error)) {
-                const axiosError = error;
-                const response = axiosError.response;
-                const errorData = response?.data;
-                // Handle common connection errors with helpful messages
-                if (error.code === 'DEPTH_ZERO_SELF_SIGNED_CERT' || error.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE') {
-                    throw new ObsidianError(`SSL certificate verification failed. You have two options:\n\n` +
-                        `Option 1 - Enable HTTP (not recommended for production):\n` +
-                        `1. Go to Obsidian Settings > Local REST API\n` +
-                        `2. Enable "Enable Non-encrypted (HTTP) Server"\n` +
-                        `3. Update your client config to use "http" protocol\n\n` +
-                        `Option 2 - Configure HTTPS (recommended):\n` +
-                        `1. Go to Obsidian Settings > Local REST API\n` +
-                        `2. Under 'How to Access', copy the certificate\n` +
-                        `3. Add the certificate to your system's trusted certificates:\n` +
-                        `   - On macOS: Add to Keychain Access\n` +
-                        `   - On Windows: Add to Certificate Manager\n` +
-                        `   - On Linux: Add to ca-certificates\n` +
-                        `   For development only: Set verifySSL: false in client config\n\n` +
-                        `Original error: ${error.message}`, 50001, // SSL error code
-                    { code: error.code, config: { verifySSL: this.config.verifySSL } });
-                }
-                if (error.code === 'ECONNREFUSED') {
-                    throw new ObsidianError(`Connection refused. To fix this:\n` +
-                        `1. Ensure Obsidian is running\n` +
-                        `2. Verify the 'Local REST API' plugin is enabled in Obsidian Settings\n` +
-                        `3. Check that you're using the correct host (${this.config.host}) and port (${this.config.port})\n` +
-                        `4. Make sure HTTPS is enabled in the plugin settings`, 50002, // Connection refused
-                    { code: error.code });
-                }
-                if (response?.status === 401) {
-                    throw new ObsidianError(`Authentication failed. To fix this:\n` +
-                        `1. Go to Obsidian Settings > Local REST API\n` +
-                        `2. Copy your API key from the settings\n` +
-                        `3. Update your configuration with the new API key\n` +
-                        `Note: The API key changes when you regenerate certificates`, 40100, // Unauthorized
-                    { code: error.code });
-                }
-                // For other errors, use API error code if available
-                const errorCode = errorData?.errorCode ?? this.getErrorCode(response?.status ?? 500);
-                const message = errorData?.message ?? axiosError.message ?? "Unknown error";
-                throw new ObsidianError(message, errorCode, errorData);
+                throw handleAxiosError(error, this.config.host, this.config.port);
             }
             if (error instanceof Error) {
                 throw new ObsidianError(error.message, 50000, error);
@@ -210,38 +154,58 @@ export class ObsidianClient {
             throw new ObsidianError("Unknown error occurred", 50000, error);
         }
     }
+    /**
+     * List all files in the vault
+     */
     async listFilesInVault() {
         return this.safeRequest(async () => {
+            logger.debug('Listing all files in vault');
             const response = await this.client.get("/vault/");
             return response.data.files;
         });
     }
+    /**
+     * List files in a specific directory
+     */
     async listFilesInDir(dirpath) {
-        this.validateFilePath(dirpath);
+        validateFilePath(dirpath);
         return this.safeRequest(async () => {
+            logger.debug(`Listing files in directory: ${dirpath}`);
             const response = await this.client.get(`/vault/${dirpath}/`);
             return response.data.files;
         });
     }
+    /**
+     * Get the contents of a file
+     */
     async getFileContents(filepath) {
-        this.validateFilePath(filepath);
+        validateFilePath(filepath);
         return this.safeRequest(async () => {
+            logger.debug(`Getting contents of file: ${filepath}`);
             const response = await this.client.get(`/vault/${filepath}`);
             return response.data;
         });
     }
+    /**
+     * Search for a string across all files
+     */
     async search(query, contextLength = 100) {
         return this.safeRequest(async () => {
+            logger.debug(`Searching for: ${query} with context length: ${contextLength}`);
             const response = await this.client.post("/search/simple/", null, { params: { query, contextLength } });
             return response.data;
         });
     }
+    /**
+     * Append content to a file
+     */
     async appendContent(filepath, content) {
-        this.validateFilePath(filepath);
+        validateFilePath(filepath);
         if (!content || typeof content !== 'string') {
             throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003);
         }
         return this.safeRequest(async () => {
+            logger.debug(`Appending content to file: ${filepath}`);
             await this.client.post(`/vault/${filepath}`, content, {
                 headers: {
                     "Content-Type": "text/markdown"
@@ -249,12 +213,16 @@ export class ObsidianClient {
             });
         });
     }
+    /**
+     * Update the entire content of a file
+     */
     async updateContent(filepath, content) {
-        this.validateFilePath(filepath);
+        validateFilePath(filepath);
         if (!content || typeof content !== 'string') {
             throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003);
         }
         return this.safeRequest(async () => {
+            logger.debug(`Updating content of file: ${filepath}`);
             await this.client.put(`/vault/${filepath}`, content, {
                 headers: {
                     "Content-Type": "text/markdown"
@@ -262,8 +230,12 @@ export class ObsidianClient {
             });
         });
     }
+    /**
+     * Execute a complex search using JsonLogic query
+     */
     async searchJson(query) {
         return this.safeRequest(async () => {
+            logger.debug(`Executing JSON search with query: ${JSON.stringify(query)}`);
             const isTagSearch = JSON.stringify(query).includes('"contains"') &&
                 JSON.stringify(query).includes('"#"');
             const response = await this.client.post("/search/", query, {
@@ -272,36 +244,56 @@ export class ObsidianClient {
                     "Accept": "application/vnd.olrapi.note+json"
                 }
             });
-            return isTagSearch ? response.data : response.data;
+            return response.data;
         });
     }
+    /**
+     * Get server status
+     */
     async getStatus() {
         return this.safeRequest(async () => {
+            logger.debug('Getting server status');
             const response = await this.client.get("/");
             return response.data;
         });
     }
+    /**
+     * List available commands
+     */
     async listCommands() {
         return this.safeRequest(async () => {
+            logger.debug('Listing commands');
             const response = await this.client.get("/commands/");
             return response.data.commands;
         });
     }
+    /**
+     * Execute a command by ID
+     */
     async executeCommand(commandId) {
         return this.safeRequest(async () => {
+            logger.debug(`Executing command: ${commandId}`);
             await this.client.post(`/commands/${commandId}/`);
         });
     }
+    /**
+     * Open a file in Obsidian
+     */
     async openFile(filepath, newLeaf = false) {
-        this.validateFilePath(filepath);
+        validateFilePath(filepath);
         return this.safeRequest(async () => {
+            logger.debug(`Opening file: ${filepath}, newLeaf: ${newLeaf}`);
             await this.client.post(`/open/${filepath}`, null, {
                 params: { newLeaf }
             });
         });
     }
+    /**
+     * Get the currently active file
+     */
     async getActiveFile() {
         return this.safeRequest(async () => {
+            logger.debug('Getting active file');
             const response = await this.client.get("/active/", {
                 headers: {
                     "Accept": "application/vnd.olrapi.note+json"
@@ -310,8 +302,12 @@ export class ObsidianClient {
             return response.data;
         });
     }
+    /**
+     * Update the active file
+     */
     async updateActiveFile(content) {
         return this.safeRequest(async () => {
+            logger.debug('Updating active file');
             await this.client.put("/active/", content, {
                 headers: {
                     "Content-Type": "text/markdown"
@@ -319,13 +315,21 @@ export class ObsidianClient {
             });
         });
     }
+    /**
+     * Delete the active file
+     */
     async deleteActiveFile() {
         return this.safeRequest(async () => {
+            logger.debug('Deleting active file');
             await this.client.delete("/active/");
         });
     }
+    /**
+     * Patch the active file
+     */
     async patchActiveFile(operation, targetType, target, content, options) {
         return this.safeRequest(async () => {
+            logger.debug(`Patching active file: ${operation} ${targetType} "${target}"`);
             const headers = {
                 "Operation": operation,
                 "Target-Type": targetType,
@@ -341,8 +345,12 @@ export class ObsidianClient {
             await this.client.patch("/active/", content, { headers });
         });
     }
+    /**
+     * Get a periodic note (e.g., daily, weekly)
+     */
     async getPeriodicNote(period) {
         return this.safeRequest(async () => {
+            logger.debug(`Getting ${period} periodic note`);
             const response = await this.client.get(`/periodic/${period}/`, {
                 headers: {
                     "Accept": "application/vnd.olrapi.note+json"
@@ -351,8 +359,12 @@ export class ObsidianClient {
             return response.data;
         });
     }
+    /**
+     * Update a periodic note
+     */
     async updatePeriodicNote(period, content) {
         return this.safeRequest(async () => {
+            logger.debug(`Updating ${period} periodic note`);
             await this.client.put(`/periodic/${period}/`, content, {
                 headers: {
                     "Content-Type": "text/markdown"
@@ -360,13 +372,21 @@ export class ObsidianClient {
             });
         });
     }
+    /**
+     * Delete a periodic note
+     */
     async deletePeriodicNote(period) {
         return this.safeRequest(async () => {
+            logger.debug(`Deleting ${period} periodic note`);
             await this.client.delete(`/periodic/${period}/`);
         });
     }
+    /**
+     * Patch a periodic note
+     */
     async patchPeriodicNote(period, operation, targetType, target, content, options) {
         return this.safeRequest(async () => {
+            logger.debug(`Patching ${period} periodic note: ${operation} ${targetType} "${target}"`);
             const headers = {
                 "Operation": operation,
                 "Target-Type": targetType,
@@ -383,4 +403,4 @@ export class ObsidianClient {
         });
     }
 }
-//# sourceMappingURL=obsidian.js.map
+//# sourceMappingURL=client.js.map

package/build/obsidian/errors.js

@@ -0,0 +1,75 @@
+import { ObsidianError, getErrorCodeFromStatus } from '../utils/errors.js';
+/**
+ * Helper function to create a descriptive error message for SSL certificate issues
+ */
+export function createSSLErrorMessage(error, config) {
+    return (`SSL certificate verification failed. You have two options:\n\n` +
+        `Option 1 - Enable HTTP (not recommended for production):\n` +
+        `1. Go to Obsidian Settings > Local REST API\n` +
+        `2. Enable "Enable Non-encrypted (HTTP) Server"\n` +
+        `3. Update your client config to use "http" protocol\n\n` +
+        `Option 2 - Configure HTTPS (recommended):\n` +
+        `1. Go to Obsidian Settings > Local REST API\n` +
+        `2. Under 'How to Access', copy the certificate\n` +
+        `3. Add the certificate to your system's trusted certificates:\n` +
+        `   - On macOS: Add to Keychain Access\n` +
+        `   - On Windows: Add to Certificate Manager\n` +
+        `   - On Linux: Add to ca-certificates\n` +
+        `   For development only: Set verifySSL: false in client config\n\n` +
+        `Original error: ${error.message}`);
+}
+/**
+ * Helper function to create a descriptive error message for connection refused issues
+ */
+export function createConnectionRefusedMessage(host, port) {
+    return (`Connection refused. To fix this:\n` +
+        `1. Ensure Obsidian is running\n` +
+        `2. Verify the 'Local REST API' plugin is enabled in Obsidian Settings\n` +
+        `3. Check that you're using the correct host (${host}) and port (${port})\n` +
+        `4. Make sure HTTPS is enabled in the plugin settings`);
+}
+/**
+ * Helper function to create a descriptive error message for authentication failures
+ */
+export function createAuthFailedMessage() {
+    return (`Authentication failed. To fix this:\n` +
+        `1. Go to Obsidian Settings > Local REST API\n` +
+        `2. Copy your API key from the settings\n` +
+        `3. Update your configuration with the new API key\n` +
+        `Note: The API key changes when you regenerate certificates`);
+}
+/**
+ * Helper function to create a descriptive error message for missing API key
+ */
+export function createMissingAPIKeyMessage() {
+    return (`Missing API key. To fix this:\n` +
+        `1. Install the 'Local REST API' plugin in Obsidian\n` +
+        `2. Enable the plugin in Obsidian Settings\n` +
+        `3. Copy your API key from Obsidian Settings > Local REST API\n` +
+        `4. Provide the API key in your configuration`);
+}
+/**
+ * Helper function to handle Axios errors consistently
+ */
+export function handleAxiosError(error, host, port) {
+    const response = error.response;
+    const errorData = response?.data;
+    // Handle common connection errors with helpful messages
+    if (error.code === 'DEPTH_ZERO_SELF_SIGNED_CERT' || error.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE') {
+        return new ObsidianError(createSSLErrorMessage(error, { verifySSL: true }), 50001, // SSL error code
+        { code: error.code });
+    }
+    if (error.code === 'ECONNREFUSED') {
+        return new ObsidianError(createConnectionRefusedMessage(host, port), 50002, // Connection refused
+        { code: error.code });
+    }
+    if (response?.status === 401) {
+        return new ObsidianError(createAuthFailedMessage(), 40100, // Unauthorized
+        { code: error.code });
+    }
+    // For other errors, use API error code if available
+    const errorCode = errorData?.errorCode ?? getErrorCodeFromStatus(response?.status ?? 500);
+    const message = errorData?.message ?? error.message ?? "Unknown error";
+    return new ObsidianError(message, errorCode, errorData);
+}
+//# sourceMappingURL=errors.js.map

package/build/obsidian/index.js

@@ -0,0 +1,7 @@
+/**
+ * Exports for the Obsidian module
+ */
+export * from './client.js';
+export * from './types.js';
+export * from './errors.js';
+//# sourceMappingURL=index.js.map

package/build/obsidian/types.js

@@ -0,0 +1,12 @@
+/**
+ * Type definitions for Obsidian client
+ */
+/**
+ * Default configuration for Obsidian server
+ */
+export const DEFAULT_OBSIDIAN_CONFIG = {
+    protocol: "https", // HTTPS required by default in Obsidian REST API plugin
+    host: "127.0.0.1",
+    port: 27124
+};
+//# sourceMappingURL=types.js.map

package/build/resources/index.js

@@ -0,0 +1,15 @@
+/**
+ * Resources module exports
+ */
+export * from './types.js';
+export * from './tags.js';
+import { TagResource } from './tags.js';
+/**
+ * Create and return the tag resource
+ * @param client The ObsidianClient instance
+ * @returns The tag resource
+ */
+export function createTagResource(client) {
+    return new TagResource(client);
+}
+//# sourceMappingURL=index.js.map

package/build/{resources.js → resources/tags.js}

@@ -1,5 +1,11 @@
-import { PropertyManager } from "./properties.js";
+import { PropertyManager } from "../tools/properties/manager.js";
 import { sep } from "path";
+import { createLogger } from "../utils/logging.js";
+// Create a logger for tag resources
+const logger = createLogger('TagResource');
+/**
+ * Resource for providing tags used in the Obsidian vault
+ */
 export class TagResource {
     client;
     tagCache = new Map();
@@ -12,6 +18,9 @@ export class TagResource {
         this.propertyManager = new PropertyManager(client);
         this.initializeCache();
     }
+    /**
+     * Get resource description for the MCP server
+     */
     getResourceDescription() {
         return {
             uri: "obsidian://tags",
@@ -20,8 +29,12 @@ export class TagResource {
             mimeType: "application/json"
         };
     }
+    /**
+     * Initialize the tag cache
+     */
     async initializeCache() {
         try {
+            logger.info('Initializing tag cache');
             // Get all markdown files using platform-agnostic path pattern
             const query = {
                 "glob": [`**${sep}*.md`.replace(/\\/g, '/'), { "var": "path" }]
@@ -43,32 +56,44 @@ export class TagResource {
                     }
                 }
                 catch (error) {
-                    console.error(`Failed to process file ${result.filename}:`, error);
+                    logger.error(`Failed to process file ${result.filename}:`, error);
                 }
             }
             this.isInitialized = true;
             this.lastUpdate = Date.now();
+            logger.info(`Tag cache initialized with ${this.tagCache.size} unique tags`);
         }
         catch (error) {
-            console.error("Failed to initialize tag cache:", error);
+            logger.error("Failed to initialize tag cache:", error);
             throw error;
         }
     }
+    /**
+     * Add a tag to the cache
+     */
     addTag(tag, filepath) {
         if (!this.tagCache.has(tag)) {
             this.tagCache.set(tag, new Set());
         }
         this.tagCache.get(tag).add(filepath);
     }
+    /**
+     * Update the cache if needed
+     */
     async updateCacheIfNeeded() {
         const now = Date.now();
         if (now - this.lastUpdate > this.updateInterval) {
+            logger.debug('Tag cache needs update, refreshing...');
             await this.initializeCache();
         }
     }
+    /**
+     * Get the content for the resource
+     */
     async getContent() {
         try {
             if (!this.isInitialized) {
+                logger.info('Tag cache not initialized, initializing now');
                 await this.initializeCache();
             }
             else {
@@ -91,6 +116,7 @@ export class TagResource {
                     lastUpdate: this.lastUpdate
                 }
             };
+            logger.debug(`Returning tag resource with ${response.tags.length} tags`);
             return [{
                     type: "text",
                     text: JSON.stringify(response, null, 2),
@@ -98,9 +124,9 @@ export class TagResource {
                 }];
         }
         catch (error) {
-            console.error("Failed to get tags:", error);
+            logger.error("Failed to get tags:", error);
             throw error;
         }
     }
 }
-//# sourceMappingURL=resources.js.map
+//# sourceMappingURL=tags.js.map

package/build/resources/types.js

@@ -0,0 +1,5 @@
+/**
+ * Resource types for the MCP server
+ */
+export {};
+//# sourceMappingURL=types.js.map