obsidian-mcp-server 1.2.6 → 1.4.0

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

@@ -1,43 +1,78 @@
+/**
+ * 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 packagePath = join(__dirname, '..', '..', 'package.json');
 const VERSION = (() => {
     try {
+        // Look for package.json in the same directory as the built files
+        const packagePath = join(__dirname, '..', '..', 'package.json');
         const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
         return pkg.version;
     }
     catch (error) {
-        console.warn('Could not read package.json version:', error);
-        return '1.1.0'; // Fallback version
+        // Try alternative location for development
+        try {
+            const devPackagePath = join(__dirname, '..', '..', '..', 'package.json');
+            const pkg = JSON.parse(readFileSync(devPackagePath, 'utf-8'));
+            return pkg.version;
+        }
+        catch (devError) {
+            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
             );
         }
-        // Combine defaults with provided config
+        // Determine if we're in a development environment
+        const isDev = process.env.NODE_ENV === 'development' || !process.env.NODE_ENV;
+        // Read environment variables with fallbacks
+        const envConfig = {
+            protocol: process.env.OBSIDIAN_PROTOCOL || DEFAULT_OBSIDIAN_CONFIG.protocol,
+            host: process.env.OBSIDIAN_HOST || DEFAULT_OBSIDIAN_CONFIG.host,
+            port: parseInt(process.env.OBSIDIAN_PORT || String(DEFAULT_OBSIDIAN_CONFIG.port)),
+            verifySSL: process.env.VERIFY_SSL ? process.env.VERIFY_SSL === 'true' : (isDev ? false : true),
+            timeout: parseInt(process.env.REQUEST_TIMEOUT || '5000'),
+            maxContentLength: parseInt(process.env.MAX_CONTENT_LENGTH || String(50 * 1024 * 1024)),
+            maxBodyLength: parseInt(process.env.MAX_BODY_LENGTH || String(50 * 1024 * 1024))
+        };
+        // Combine defaults with provided config and environment variables
         this.config = {
-            ...DEFAULT_OBSIDIAN_CONFIG,
-            verifySSL: config.verifySSL ?? true, // Default to true as required by Obsidian REST API plugin
+            protocol: envConfig.protocol,
+            host: envConfig.host,
+            port: envConfig.port,
+            verifySSL: config.verifySSL ?? envConfig.verifySSL,
             apiKey: config.apiKey,
-            timeout: config.timeout ?? 5000, // 5 second default timeout
-            maxContentLength: config.maxContentLength ?? 50 * 1024 * 1024, // 50MB
-            maxBodyLength: config.maxBodyLength ?? 50 * 1024 * 1024 // 50MB
+            timeout: config.timeout ?? envConfig.timeout,
+            maxContentLength: config.maxContentLength ?? envConfig.maxContentLength,
+            maxBodyLength: config.maxBodyLength ?? envConfig.maxBodyLength
         };
         // Configure HTTPS agent
         const httpsAgent = new Agent({
@@ -66,15 +101,30 @@ export class ObsidianClient {
             decompress: true
         };
         if (!this.config.verifySSL) {
-            console.warn("WARNING: SSL verification is disabled. The Obsidian REST API plugin requires HTTPS by default.\n" +
-                "Make sure you have configured the certificate as a trusted certificate authority.\n" +
-                "See Obsidian Settings > Local REST API > 'How to Access' for setup instructions.");
+            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" +
+                "3. For Windows users:\n" +
+                "   - Open 'certmgr.msc' (Windows Certificate Manager)\n" +
+                "   - Go to 'Trusted Root Certification Authorities' > 'Certificates'\n" +
+                "   - Right-click > 'All Tasks' > 'Import' and follow the wizard\n" +
+                "   - Select the certificate file you copied from Obsidian\n" +
+                "4. For other systems:\n" +
+                "   - macOS: Add to Keychain Access\n" +
+                "   - Linux: Add to ca-certificates");
         }
         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}`,
@@ -84,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);
@@ -178,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"
@@ -217,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"
@@ -230,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, {
@@ -240,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"
@@ -278,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"
@@ -287,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,
@@ -309,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"
@@ -319,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"
@@ -328,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,
@@ -351,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