obsidian-mcp-server 1.1.0

package/build/tools.js

@@ -0,0 +1,381 @@
+import { encoding_for_model } from "tiktoken";
+import { ObsidianError } from "./types.js";
+const TOOL_NAMES = {
+    LIST_FILES_IN_VAULT: "obsidian_list_files_in_vault",
+    LIST_FILES_IN_DIR: "obsidian_list_files_in_dir",
+    GET_FILE_CONTENTS: "obsidian_get_file_contents",
+    FIND_IN_FILE: "obsidian_find_in_file",
+    APPEND_CONTENT: "obsidian_append_content",
+    PATCH_CONTENT: "obsidian_patch_content",
+    COMPLEX_SEARCH: "obsidian_complex_search"
+};
+// Load token limits from environment or use defaults
+const MAX_TOKENS = parseInt(process.env.MAX_TOKENS ?? '20000');
+const TRUNCATION_MESSAGE = "\n\n[Response truncated due to length]";
+export class BaseToolHandler {
+    name;
+    client;
+    tokenizer = encoding_for_model("gpt-4"); // This is strictly for token counting, not for LLM inference
+    isShuttingDown = false;
+    constructor(name, client) {
+        this.name = name;
+        this.client = client;
+        // Clean up tokenizer when process exits
+        const cleanup = () => {
+            if (!this.isShuttingDown) {
+                this.isShuttingDown = true;
+                if (this.tokenizer) {
+                    this.tokenizer.free();
+                }
+            }
+        };
+        process.on('exit', cleanup);
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        process.on('uncaughtException', cleanup);
+    }
+    countTokens(text) {
+        return this.tokenizer.encode(text).length;
+    }
+    truncateToTokenLimit(text) {
+        const tokens = this.tokenizer.encode(text);
+        if (tokens.length <= MAX_TOKENS) {
+            return text;
+        }
+        // Reserve tokens for truncation message
+        const messageTokens = this.tokenizer.encode(TRUNCATION_MESSAGE);
+        const availableTokens = MAX_TOKENS - messageTokens.length;
+        // Decode truncated tokens back to text
+        const truncatedText = this.tokenizer.decode(tokens.slice(0, availableTokens));
+        return truncatedText + TRUNCATION_MESSAGE;
+    }
+    createResponse(content) {
+        let text;
+        // Handle different content types
+        if (typeof content === 'string') {
+            text = content;
+        }
+        else if (content instanceof Buffer) {
+            text = content.toString('utf-8');
+        }
+        else if (Array.isArray(content) && content.every(item => typeof item === 'string')) {
+            text = content.join('\n');
+        }
+        else if (content instanceof Error) {
+            text = `Error: ${content.message}\n${content.stack || ''}`;
+        }
+        else {
+            try {
+                text = JSON.stringify(content, null, 2);
+            }
+            catch (error) {
+                text = String(content);
+            }
+        }
+        // Count tokens and truncate if necessary
+        const originalTokenCount = this.countTokens(text);
+        const truncatedText = this.truncateToTokenLimit(text);
+        const finalTokenCount = this.countTokens(truncatedText);
+        if (originalTokenCount > MAX_TOKENS) {
+            console.debug(`[${this.name}] Response truncated:`, `original tokens=${originalTokenCount}`, `truncated tokens=${finalTokenCount}`);
+        }
+        return [{
+                type: "text",
+                text: truncatedText
+            }];
+    }
+    handleError(error) {
+        if (error instanceof ObsidianError) {
+            throw error;
+        }
+        if (error instanceof Error) {
+            throw new ObsidianError(`Tool '${this.name}' execution failed: ${error.message}`, 500, { originalError: error.stack });
+        }
+        throw new ObsidianError(`Tool '${this.name}' execution failed with unknown error`, 500, { error });
+    }
+}
+export class ListFilesInVaultToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(TOOL_NAMES.LIST_FILES_IN_VAULT, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Lists all files and directories in the root directory of your Obsidian vault.",
+            examples: [
+                {
+                    description: "List all files in vault",
+                    args: {}
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: []
+            }
+        };
+    }
+    async runTool() {
+        try {
+            const files = await this.client.listFilesInVault();
+            return this.createResponse(files);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class ListFilesInDirToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(TOOL_NAMES.LIST_FILES_IN_DIR, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Lists all files and directories that exist in a specific Obsidian directory.",
+            examples: [
+                {
+                    description: "List files in Documents folder",
+                    args: {
+                        dirpath: "Documents"
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dirpath: {
+                        type: "string",
+                        description: "Path to list files from (relative to your vault root). Note that empty directories will not be returned.",
+                        format: "path"
+                    }
+                },
+                required: ["dirpath"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            const files = await this.client.listFilesInDir(args.dirpath);
+            return this.createResponse(files);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class GetFileContentsToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(TOOL_NAMES.GET_FILE_CONTENTS, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Return the content of a single file in your vault.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filepath: {
+                        type: "string",
+                        description: "Path to the relevant file (relative to your vault root).",
+                        format: "path"
+                    }
+                },
+                required: ["filepath"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            const content = await this.client.getFileContents(args.filepath);
+            return this.createResponse(content);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class FindInFileToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(TOOL_NAMES.FIND_IN_FILE, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Simple search that returns filenames of documents matching a specified text query across all files in the vault.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Text to search for in the vault."
+                    },
+                    contextLength: {
+                        type: "integer",
+                        description: "How much context to use for matching (default: 10)",
+                        default: 10
+                    }
+                },
+                required: ["query"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            const results = await this.client.search(args.query, args.contextLength);
+            // Extract only unique filenames from search results
+            const filenames = [...new Set(results.map(result => result.filename))].sort();
+            return this.createResponse(filenames);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class AppendContentToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(TOOL_NAMES.APPEND_CONTENT, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Append content to a new or existing file in the vault.",
+            examples: [
+                {
+                    description: "Append a new task",
+                    args: {
+                        filepath: "tasks.md",
+                        content: "- [ ] New task to complete"
+                    }
+                },
+                {
+                    description: "Append meeting notes",
+                    args: {
+                        filepath: "meetings/2025-01-23.md",
+                        content: "## Meeting Notes\n\n- Discussed project timeline\n- Assigned tasks"
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filepath: {
+                        type: "string",
+                        description: "Path to the file (relative to vault root)",
+                        format: "path"
+                    },
+                    content: {
+                        type: "string",
+                        description: "Content to append to the file"
+                    }
+                },
+                required: ["filepath", "content"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            await this.client.appendContent(args.filepath, args.content);
+            return this.createResponse({ message: `Successfully appended content to ${args.filepath}` });
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class PatchContentToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(TOOL_NAMES.PATCH_CONTENT, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Update the entire content of an existing note or create a new one.",
+            examples: [
+                {
+                    description: "Update a note's content",
+                    args: {
+                        filepath: "project.md",
+                        content: "# Project Notes\n\nThis will replace the entire content of the note."
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filepath: {
+                        type: "string",
+                        description: "Path to the file (relative to vault root)",
+                        format: "path"
+                    },
+                    content: {
+                        type: "string",
+                        description: "New content for the note (replaces existing content)"
+                    }
+                },
+                required: ["filepath", "content"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            await this.client.updateContent(args.filepath, args.content);
+            return this.createResponse({ message: `Successfully updated content in ${args.filepath}` });
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class ComplexSearchToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(TOOL_NAMES.COMPLEX_SEARCH, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Complex search for documents using a JsonLogic query.",
+            examples: [
+                {
+                    description: "Find all markdown files",
+                    args: {
+                        query: {
+                            "glob": ["*.md", { "var": "path" }]
+                        }
+                    }
+                },
+                {
+                    description: "Find files modified in last week",
+                    args: {
+                        query: {
+                            ">=": [
+                                { "var": "mtime" },
+                                { "date": "-7 days" }
+                            ]
+                        }
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "object",
+                        description: "JsonLogic query object. Example: {\"glob\": [\"*.md\", {\"var\": \"path\"}]} matches all markdown files"
+                    }
+                },
+                required: ["query"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            const results = await this.client.searchJson(args.query);
+            return this.createResponse(results);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+//# sourceMappingURL=tools.js.map

package/build/types.js

@@ -0,0 +1,20 @@
+export const DEFAULT_OBSIDIAN_CONFIG = {
+    protocol: "https",
+    host: "127.0.0.1",
+    port: 27124
+};
+export const DEFAULT_RATE_LIMIT_CONFIG = {
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    maxRequests: 200
+};
+export class ObsidianError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "ObsidianError";
+    }
+}
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "obsidian-mcp-server",
+  "version": "1.1.0",
+  "description": "Model Context Protocol server for Obsidian integration with token-aware response handling",
+  "main": "build/index.js",
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x build/index.js",
+    "start": "node build/index.js",
+    "dev": "tsc -w",
+    "clean": "rm -rf build",
+    "rebuild": "npm run clean && npm run build",
+    "test": "echo \"No tests specified yet\" && exit 0",
+    "lint": "eslint . --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\""
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.4.0",
+    "axios": "^1.7.9",
+    "dotenv": "^16.4.7",
+    "tiktoken": "^1.0.18"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.10",
+    "@typescript-eslint/eslint-plugin": "^8.21.0",
+    "@typescript-eslint/parser": "^8.21.0",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.2.3",
+    "prettier": "^3.4.2",
+    "typescript": "^5.7.3"
+  },
+  "keywords": [
+    "mcp",
+    "obsidian",
+    "llm",
+    "llm-agent",
+    "ai",
+    "claude",
+    "model-context-protocol",
+    "tiktoken"
+  ],
+  "author": "cyanheads",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/cyanheads/obsidian-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cyanheads/obsidian-mcp-server/issues"
+  },
+  "homepage": "https://github.com/cyanheads/obsidian-mcp-server#readme"
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { run } from "./server.js";
+
+// Main entry point
+if (import.meta.url === `file://${process.argv[1]}`) {
+  run().catch((error) => {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  });
+}
+
+export { run };

package/src/obsidian.ts

@@ -0,0 +1,235 @@
+import axios from "axios";
+import type { AxiosInstance, AxiosError, AxiosRequestConfig } from "axios";
+import { ObsidianConfig, ObsidianError, ObsidianFile, SearchResult, DEFAULT_OBSIDIAN_CONFIG, ObsidianServerConfig, JsonLogicQuery } from "./types.js";
+import { Agent } from "node:https";
+import { readFileSync } from "fs";
+import { fileURLToPath } from 'url';
+import { dirname, join } from "path";
+
+// 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 {
+    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
+  }
+})();
+
+export class ObsidianClient {
+  private client: AxiosInstance;
+  private config: Required<ObsidianConfig> & ObsidianServerConfig;
+
+  constructor(config: ObsidianConfig) {
+    if (!config.apiKey) {
+      throw new ObsidianError("API key is required", 401);
+    }
+
+    // Combine defaults with provided config
+    this.config = {
+      ...DEFAULT_OBSIDIAN_CONFIG,
+      verifySSL: config.verifySSL ?? process.env.NODE_ENV === 'production', // Enable SSL verification in production by default
+      apiKey: config.apiKey,
+      timeout: config.timeout ?? 5000,
+      maxContentLength: config.maxContentLength ?? 50 * 1024 * 1024, // 50MB
+      maxBodyLength: config.maxBodyLength ?? 50 * 1024 * 1024 // 50MB
+    };
+
+    // Configure HTTPS agent
+    const httpsAgent = new Agent({
+      rejectUnauthorized: this.config.verifySSL
+    });
+
+    const axiosConfig: AxiosRequestConfig = {
+      baseURL: this.getBaseUrl(),
+      headers: {
+        ...this.getHeaders(),
+        // Security headers
+        'X-Content-Type-Options': 'nosniff',
+        'X-Frame-Options': 'DENY',
+        'X-XSS-Protection': '1; mode=block',
+        'Strict-Transport-Security': 'max-age=31536000; includeSubDomains'
+      },
+      validateStatus: (status) => status >= 200 && status < 300,
+      timeout: this.config.timeout,
+      maxRedirects: 5,
+      maxContentLength: this.config.maxContentLength,
+      maxBodyLength: this.config.maxBodyLength,
+      httpsAgent,
+      // Additional security configurations
+      xsrfCookieName: 'XSRF-TOKEN',
+      xsrfHeaderName: 'X-XSRF-TOKEN',
+      withCredentials: true,
+      decompress: true
+    };
+
+    if (!this.config.verifySSL) {
+      console.warn(
+        "WARNING: SSL verification is disabled. This is not recommended for production use.",
+        process.env.NODE_ENV === 'production' ? "Consider enabling SSL verification." : "This is acceptable for local development only."
+      );
+    }
+
+    this.client = axios.create(axiosConfig);
+  }
+
+  private getBaseUrl(): string {
+    return `${this.config.protocol}://${this.config.host}:${this.config.port}`;
+  }
+
+  private getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      'Accept': 'application/json',
+      'User-Agent': `obsidian-mcp-server/${VERSION}`
+    };
+
+    // Sanitize headers
+    return Object.fromEntries(
+      Object.entries(headers).map(([key, value]) => [
+        key,
+        this.sanitizeHeader(value)
+      ])
+    );
+  }
+
+  private sanitizeHeader(value: string): string {
+    // Remove any potentially harmful characters from header values
+    return value.replace(/[^\w\s\-\._~:/?#\[\]@!$&'()*+,;=]/g, '');
+  }
+
+  private validateFilePath(filepath: string): void {
+    // Prevent path traversal attacks
+    const normalizedPath = filepath.replace(/\\/g, '/');
+    if (normalizedPath.includes('../') || normalizedPath.includes('..\\')) {
+      throw new ObsidianError('Invalid file path: Path traversal not allowed', 400);
+    }
+    
+    // Additional path validations
+    if (normalizedPath.startsWith('/') || /^[a-zA-Z]:/.test(normalizedPath)) {
+      throw new ObsidianError('Invalid file path: Absolute paths not allowed', 400);
+    }
+  }
+
+  private async safeRequest<T>(operation: () => Promise<T>): Promise<T> {
+    try {
+      return await operation();
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const axiosError = error as AxiosError<{ errorCode?: number; message?: string }>;
+        const response = axiosError.response;
+        const errorData = response?.data;
+        const code = errorData?.errorCode ?? response?.status ?? 500;
+        const message = errorData?.message ?? axiosError.message ?? "Unknown error";
+        throw new ObsidianError(message, code, errorData);
+      }
+      throw error;
+    }
+  }
+
+  async listFilesInVault(): Promise<ObsidianFile[]> {
+    return this.safeRequest(async () => {
+      const requestId = crypto.randomUUID();
+      console.debug(`[${requestId}] Listing vault files`);
+      const response = await this.client.get<{ files: ObsidianFile[] }>("/vault/");
+      return response.data.files;
+    });
+  }
+
+  async listFilesInDir(dirpath: string): Promise<ObsidianFile[]> {
+    this.validateFilePath(dirpath);
+    return this.safeRequest(async () => {
+      const requestId = crypto.randomUUID();
+      console.debug(`[${requestId}] Listing files in directory: ${dirpath}`);
+      const response = await this.client.get<{ files: ObsidianFile[] }>(`/vault/${dirpath}/`);
+      return response.data.files;
+    });
+  }
+
+  async getFileContents(filepath: string): Promise<string> {
+    this.validateFilePath(filepath);
+    return this.safeRequest(async () => {
+      const requestId = crypto.randomUUID();
+      console.debug(`[${requestId}] Getting file contents: ${filepath}`);
+      const response = await this.client.get<string>(`/vault/${filepath}`);
+      return response.data;
+    });
+  }
+
+  async search(query: string, contextLength: number = 100): Promise<SearchResult[]> {
+    return this.safeRequest(async () => {
+      const requestId = crypto.randomUUID();
+      console.debug(`[${requestId}] Performing simple search: ${query}`);
+      const response = await this.client.post<SearchResult[]>("/search/simple/", undefined, {
+        params: {
+          query,
+          contextLength
+        }
+      });
+      return response.data;
+    });
+  }
+
+  async appendContent(filepath: string, content: string): Promise<void> {
+    this.validateFilePath(filepath);
+    if (!content || typeof content !== 'string') {
+      throw new ObsidianError('Invalid content: Content must be a non-empty string', 400);
+    }
+    return this.safeRequest(async () => {
+      const requestId = crypto.randomUUID();
+      console.debug(`[${requestId}] Appending content to: ${filepath}`);
+      await this.client.post(
+        `/vault/${filepath}`,
+        content,
+        {
+          headers: {
+            "Content-Type": "text/markdown"
+          }
+        }
+      );
+    });
+  }
+
+  async updateContent(filepath: string, content: string): Promise<void> {
+    this.validateFilePath(filepath);
+    if (!content || typeof content !== 'string') {
+      throw new ObsidianError('Invalid content: Content must be a non-empty string', 400);
+    }
+
+    return this.safeRequest(async () => {
+      const requestId = crypto.randomUUID();
+      console.debug(`[${requestId}] Updating content in: ${filepath}`);
+      await this.client.put(
+        `/vault/${filepath}`,
+        content,
+        { 
+          headers: {
+            "Content-Type": "text/markdown"
+          }
+        }
+      );
+    });
+  }
+
+  async searchJson(query: JsonLogicQuery): Promise<SearchResult[]> {
+    return this.safeRequest(async () => {
+      const requestId = crypto.randomUUID();
+      console.debug(`[${requestId}] Performing complex search with query:`, JSON.stringify(query));
+      const response = await this.client.post<SearchResult[]>(
+        "/search/",
+        query,
+        {
+          headers: {
+            "Content-Type": "application/vnd.olrapi.jsonlogic+json",
+            "Accept": "application/json"
+          }
+        }
+      );
+      return response.data;
+    });
+  }
+}