obsidian-native-mcp 0.2.0

package/src/mcp/server.ts

@@ -0,0 +1,272 @@
+import type { JSONRPCRequest, JSONRPCResponse, ToolDefinition } from "./protocol";
+import { VaultFileHandler } from "../handlers/tools";
+import { PromptHandler } from "../handlers/prompts";
+import type { VaultRegistry } from "../utils/vaults";
+
+const vaultParam = {
+  vault: {
+    type: "string",
+    description:
+      "Vault name (derived from the directory name). Required when multiple vaults are configured.",
+  },
+};
+
+export interface ServerInstance {
+  toolDefinitions: ToolDefinition[];
+  handleRequest(msg: JSONRPCRequest): Promise<JSONRPCResponse | null>;
+}
+
+export function createServer(registry: VaultRegistry): ServerInstance {
+  const vaultList = registry.list();
+  const vaultNames = vaultList.map((v) => v.name);
+  vaultParam.vault.description = `Vault name. Available: ${vaultNames.join(", ")}`;
+
+  const fileHandler = new VaultFileHandler(registry);
+  const promptHandler = new PromptHandler(registry);
+  const toolHandlers = fileHandler.getHandlers();
+
+  const toolDefinitions: ToolDefinition[] = [
+    {
+      name: "list_vaults",
+      description: "List all configured vaults with their paths.",
+      inputSchema: { type: "object", properties: {} },
+    },
+    {
+      name: "get_vault_info",
+      description: "Get stats for a vault (file count, path, name).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          vault: {
+            type: "string",
+            description: `Vault name. Available: ${vaultNames.join(", ")}`,
+          },
+        },
+      },
+    },
+    {
+      name: "list_files",
+      description: "List files in the root directory or a specified subdirectory of your vault.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          directory: {
+            type: "string",
+            description: "Optional subdirectory path relative to vault root",
+          },
+        },
+      },
+    },
+    {
+      name: "get_file",
+      description: "Get the content of a file from your vault.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: {
+            type: "string",
+            description: "Path to the file relative to vault root",
+          },
+          format: {
+            type: "string",
+            enum: ["markdown", "json"],
+            description: "Return format (json includes frontmatter)",
+          },
+        },
+        required: ["filename"],
+      },
+    },
+    {
+      name: "create_file",
+      description: "Create a new file in your vault or update an existing one.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: {
+            type: "string",
+            description: "Path to the file relative to vault root",
+          },
+          content: { type: "string", description: "File content" },
+        },
+        required: ["filename", "content"],
+      },
+    },
+    {
+      name: "append_to_file",
+      description: "Append content to a new or existing file.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: {
+            type: "string",
+            description: "Path to the file relative to vault root",
+          },
+          content: {
+            type: "string",
+            description: "Content to append",
+          },
+        },
+        required: ["filename", "content"],
+      },
+    },
+    {
+      name: "patch_file",
+      description:
+        "Insert or modify content in a file relative to a heading, block reference, or frontmatter field.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: { type: "string" },
+          operation: {
+            type: "string",
+            enum: ["append", "prepend", "replace"],
+          },
+          targetType: {
+            type: "string",
+            enum: ["heading", "block", "frontmatter"],
+          },
+          target: { type: "string" },
+          content: { type: "string" },
+          contentType: {
+            type: "string",
+            enum: ["text/markdown", "application/json"],
+          },
+          targetDelimiter: { type: "string", default: "::" },
+          trimTargetWhitespace: { type: "boolean", default: true },
+        },
+        required: ["filename", "operation", "targetType", "target", "content"],
+      },
+    },
+    {
+      name: "delete_file",
+      description: "Delete a file from your vault.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          filename: {
+            type: "string",
+            description: "Path to the file relative to vault root",
+          },
+        },
+        required: ["filename"],
+      },
+    },
+    {
+      name: "search",
+      description: "Search for documents matching a text query in your vault.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...vaultParam,
+          query: { type: "string", description: "Text to search for" },
+          directory: {
+            type: "string",
+            description: "Optional directory to scope the search",
+          },
+          contextLength: {
+            type: "number",
+            description: "Characters of context around each match",
+          },
+        },
+        required: ["query"],
+      },
+    },
+  ];
+
+  async function handleRequest(msg: JSONRPCRequest): Promise<JSONRPCResponse | null> {
+    const { method, params, id } = msg;
+
+    switch (method) {
+      case "initialize": {
+        const clientProtocol = params?.protocolVersion;
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: clientProtocol || "2024-11-05",
+            capabilities: { tools: {}, prompts: {} },
+            serverInfo: { name: "obsidian-native-mcp", version: "0.2.0" },
+          },
+        };
+      }
+
+      case "tools/list":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: { tools: toolDefinitions },
+        };
+
+      case "tools/call": {
+        const toolName = params?.name;
+        const args = params?.arguments || {};
+        const handler = toolHandlers[toolName as string];
+        if (!handler) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32601, message: `Unknown tool: ${toolName}` },
+          };
+        }
+        try {
+          const result = await handler(args);
+          return { jsonrpc: "2.0", id, result };
+        } catch (err: any) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32603, message: err.message || String(err) },
+          };
+        }
+      }
+
+      case "prompts/list": {
+        try {
+          const promptVault = params?.arguments?.vault;
+          const promptList = await promptHandler.list(promptVault);
+          return { jsonrpc: "2.0", id, result: { prompts: promptList } };
+        } catch (err: any) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32603, message: err.message || String(err) },
+          };
+        }
+      }
+
+      case "prompts/get": {
+        try {
+          const promptVault = params?.arguments?.vault;
+          const result = await promptHandler.get(params?.name, promptVault);
+          return { jsonrpc: "2.0", id, result };
+        } catch (err: any) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32603, message: err.message || String(err) },
+          };
+        }
+      }
+
+      case "notifications/initialized":
+      case "notifications/cancelled":
+      case "notifications/roots/list_changed":
+        return null;
+
+      default:
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32601, message: `Method not found: ${method}` },
+        };
+    }
+  }
+
+  return { toolDefinitions, handleRequest };
+}

package/src/mcp/stdio-transport.ts

@@ -0,0 +1,43 @@
+import type { JSONRPCRequest, JSONRPCResponse } from "./protocol";
+import { sendMessage, parseMessages } from "./protocol";
+
+export class StdioTransport {
+  private requestHandler: ((request: JSONRPCRequest) => Promise<JSONRPCResponse | null>) | null =
+    null;
+  private stdinBuffer = { buffer: "" };
+
+  onRequest(handler: (request: JSONRPCRequest) => Promise<JSONRPCResponse | null>): void {
+    this.requestHandler = handler;
+  }
+
+  sendMessage(message: JSONRPCResponse): void {
+    sendMessage(message);
+  }
+
+  start(): void {
+    process.stdin.on("data", async (chunk: Buffer) => {
+      this.stdinBuffer.buffer += chunk.toString();
+
+      const { messages, remaining } = parseMessages(this.stdinBuffer.buffer);
+      this.stdinBuffer.buffer = remaining;
+
+      for (const jsonStr of messages) {
+        try {
+          const msg = JSON.parse(jsonStr);
+          if (msg.jsonrpc !== "2.0") continue;
+
+          if ("method" in msg && "id" in msg) {
+            const response = await this.requestHandler?.(msg as JSONRPCRequest);
+            if (response) this.sendMessage(response);
+          }
+        } catch (err: any) {
+          console.error("Error processing message:", err.message);
+        }
+      }
+    });
+  }
+
+  close(): void {
+    process.stdin.removeAllListeners("data");
+  }
+}

package/src/mcp/transport.ts

@@ -0,0 +1,8 @@
+import type { JSONRPCRequest, JSONRPCResponse } from "./protocol";
+
+export interface Transport {
+  sendMessage(message: JSONRPCResponse): void;
+  onRequest(handler: (request: JSONRPCRequest) => Promise<JSONRPCResponse | null>): void;
+  start(): void;
+  close(): void;
+}

package/src/plugin/main.ts

@@ -0,0 +1,91 @@
+import { Plugin } from "obsidian";
+import { HttpTransport } from "../mcp/http-transport";
+import { createServer } from "../mcp/server";
+import { VaultRegistry } from "../utils/vaults";
+import { NativeMcpSettingTab } from "./settings";
+
+interface PluginSettings {
+  selectedVaults: string[];
+}
+
+const DEFAULT_SETTINGS: PluginSettings = {
+  selectedVaults: [],
+};
+
+export default class NativeMcpPlugin extends Plugin {
+  private transport: HttpTransport | null = null;
+  private settings: PluginSettings = DEFAULT_SETTINGS;
+  private registry = new VaultRegistry();
+
+  async onload(): Promise<void> {
+    await this.loadSettings();
+
+    const allVaults = VaultRegistry.discoverFromObsidian();
+
+    if (this.settings.selectedVaults.length > 0) {
+      const selected = allVaults.filter((v) => this.settings.selectedVaults.includes(v.name));
+      if (selected.length > 0) {
+        this.registry.configure(selected);
+      }
+    }
+
+    if (this.registry.list().length > 0) {
+      await this.startServer();
+    }
+
+    this.addSettingTab(new NativeMcpSettingTab(this.app, this));
+  }
+
+  async startServer(): Promise<void> {
+    this.transport?.close();
+
+    const server = createServer(this.registry);
+    this.transport = new HttpTransport();
+    this.transport.onRequest(async (msg) => server.handleRequest(msg));
+    await this.transport.start();
+  }
+
+  restartServer(): void {
+    this.startServer();
+  }
+
+  getServerUrl(): string | null {
+    return this.transport?.url ?? null;
+  }
+
+  getRegistry(): VaultRegistry {
+    return this.registry;
+  }
+
+  async loadSettings(): Promise<void> {
+    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+  }
+
+  async saveSettings(): Promise<void> {
+    await this.saveData(this.settings);
+  }
+
+  getSettings(): PluginSettings {
+    return this.settings;
+  }
+
+  async updateSelectedVaults(names: string[]): Promise<void> {
+    this.settings.selectedVaults = names;
+    await this.saveSettings();
+
+    const allVaults = VaultRegistry.discoverFromObsidian();
+    const selected = allVaults.filter((v) => names.includes(v.name));
+    this.registry.configure(selected);
+
+    if (selected.length > 0) {
+      await this.startServer();
+    } else {
+      this.transport?.close();
+      this.transport = null;
+    }
+  }
+
+  onunload(): void {
+    this.transport?.close();
+  }
+}

package/src/plugin/settings.ts

@@ -0,0 +1,69 @@
+import { App, PluginSettingTab, Setting } from "obsidian";
+import { VaultRegistry } from "../utils/vaults";
+import type NativeMcpPlugin from "./main";
+
+export class NativeMcpSettingTab extends PluginSettingTab {
+  private plugin: NativeMcpPlugin;
+
+  constructor(app: App, plugin: NativeMcpPlugin) {
+    super(app, plugin);
+    this.plugin = plugin;
+  }
+
+  display(): void {
+    const { containerEl } = this;
+    containerEl.empty();
+
+    containerEl.createEl("h2", { text: "Obsidian Native MCP" });
+
+    const url = this.plugin.getServerUrl();
+    if (url) {
+      new Setting(containerEl)
+        .setName("MCP Server URL")
+        .setDesc("Add this URL to your Claude Desktop config")
+        .addText((text) => {
+          text.setValue(url).setDisabled(true);
+          text.inputEl.style.width = "100%";
+        })
+        .addButton((btn) => {
+          btn.setButtonText("Copy").onClick(async () => {
+            await (navigator as any).clipboard.writeText(url);
+            btn.setButtonText("Copied!");
+            setTimeout(() => btn.setButtonText("Copy"), 2000);
+          });
+        });
+    } else {
+      new Setting(containerEl)
+        .setName("Server inactive")
+        .setDesc("Select at least one vault below to start the MCP server.");
+    }
+
+    containerEl.createEl("h3", { text: "Vaults" });
+
+    const allVaults = VaultRegistry.discoverFromObsidian();
+    const selected = this.plugin.getSettings().selectedVaults;
+
+    if (allVaults.length === 0) {
+      containerEl.createEl("p", {
+        text: "No Obsidian vaults found. Make sure Obsidian has been started at least once.",
+      });
+      return;
+    }
+
+    for (const vault of allVaults) {
+      const isSelected = selected.includes(vault.name);
+      new Setting(containerEl)
+        .setName(vault.name)
+        .setDesc(vault.path)
+        .addToggle((toggle) =>
+          toggle.setValue(isSelected).onChange(async (value) => {
+            const newSelected = value
+              ? [...selected, vault.name]
+              : selected.filter((n) => n !== vault.name);
+            await this.plugin.updateSelectedVaults(newSelected);
+            this.display();
+          }),
+        );
+    }
+  }
+}