mcp-obsidian-cli 1.1.0 → 1.3.0

package/README.md

@@ -37,7 +37,7 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
 ## Requirements
 
 - Obsidian running with the CLI plugin active
-- `obsidian` on your PATH
+- `obsidian-cli` on your PATH (typically `/Applications/Obsidian.app/Contents/MacOS/obsidian-cli` on macOS)
 - Node.js >= 18
 
 ## How it works
@@ -67,7 +67,7 @@ The generic `obsidian` tool means the MCP server never falls behind the CLI —
 | Variable | Default | Description |
 |---|---|---|
 | `OBSIDIAN_VAULT` | _(none)_ | Target vault by name |
-| `OBSIDIAN_CLI_PATH` | `obsidian` | Path to CLI binary |
+| `OBSIDIAN_CLI_PATH` | `obsidian-cli` | Path to CLI binary |
 | `OBSIDIAN_TIMEOUT_MS` | `15000` | Command timeout |
 | `XDG_CONFIG_HOME` | `~/.config` | Base path for config file |
 
@@ -81,7 +81,7 @@ The server can read settings from a YAML config file:
 Config file format:
 ```yaml
 vault: "my-vault"
-cliPath: "obsidian"
+cliPath: "obsidian-cli"
 timeoutMs: 15000
 ```
 

package/lib/helpers.js

@@ -0,0 +1,122 @@
+/**
+ * Pure helper functions extracted from server.js for testability.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { basename } from "node:path";
+import { load as yamlLoad } from "js-yaml";
+
+/**
+ * Load config from YAML file with env var overrides.
+ * @param {string} configFile - Path to the YAML config file.
+ * @returns {{ vault: string, cliPath: string, timeoutMs: number }}
+ */
+export function loadConfig(configFile) {
+  const defaults = { vault: "", cliPath: "obsidian-cli", timeoutMs: 15000 };
+  let config = { ...defaults };
+
+  if (existsSync(configFile)) {
+    try {
+      const content = readFileSync(configFile, "utf8");
+      const fileConfig = yamlLoad(content);
+      if (fileConfig) {
+        if (fileConfig.vault) config.vault = fileConfig.vault;
+        if (fileConfig.cliPath) config.cliPath = fileConfig.cliPath;
+        if (fileConfig.timeoutMs) config.timeoutMs = fileConfig.timeoutMs;
+      }
+    } catch (err) {
+      console.error("Warning: failed to load config file:", err.message);
+    }
+  }
+
+  if (process.env.OBSIDIAN_VAULT) config.vault = process.env.OBSIDIAN_VAULT;
+  if (process.env.OBSIDIAN_CLI_PATH) config.cliPath = process.env.OBSIDIAN_CLI_PATH;
+  if (process.env.OBSIDIAN_TIMEOUT_MS) config.timeoutMs = parseInt(process.env.OBSIDIAN_TIMEOUT_MS, 10);
+
+  return config;
+}
+
+/**
+ * Minimal arg parser: splits on whitespace but respects key="value with spaces".
+ */
+export function parseArgs(str) {
+  const args = [];
+  const re = /(?:[^\s"]+|"[^"]*")+/g;
+  let m;
+  while ((m = re.exec(str)) !== null) {
+    args.push(m[0].replace(/"([^"]*)"/g, "$1"));
+  }
+  return args;
+}
+
+/**
+ * Build CLI argv with vault= prepended when configured. Caller-supplied
+ * `vault=` (must be first token) wins — the configured vault is skipped so
+ * per-call overrides through the generic `obsidian` tool remain reachable.
+ */
+export function buildCliArgs(input, vault) {
+  const args = Array.isArray(input) ? [...input] : parseArgs(input);
+  if (vault && !args[0]?.startsWith("vault=")) {
+    args.unshift(`vault=${vault}`);
+  }
+  return args;
+}
+
+/**
+ * Load the set of vault names Obsidian knows about by parsing the desktop
+ * app's registry file. Returns an empty Set if the file is missing or
+ * unreadable (non-macOS, fresh install, etc.) — callers should treat that
+ * case as "no validation possible, trust the configured vault".
+ *
+ * @param {string} obsidianJsonPath - Path to Obsidian's vaults registry.
+ * @returns {Set<string>} basenames of known vault paths.
+ */
+export function loadKnownVaults(obsidianJsonPath) {
+  if (!existsSync(obsidianJsonPath)) return new Set();
+  try {
+    const content = readFileSync(obsidianJsonPath, "utf8");
+    const data = JSON.parse(content);
+    const vaults = data?.vaults || {};
+    const names = new Set();
+    for (const v of Object.values(vaults)) {
+      if (v?.path) names.add(basename(v.path));
+    }
+    return names;
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * If the first token of args is `vault=NAME`, return NAME. Otherwise null.
+ * Mirrors the CLI's requirement that `vault=` be the first positional token
+ * when overriding the focused vault.
+ *
+ * @param {string[]} args - Parsed CLI args.
+ * @returns {string|null}
+ */
+export function extractLeadingVault(args) {
+  const first = args[0];
+  if (typeof first === "string" && first.startsWith("vault=")) {
+    return first.slice("vault=".length);
+  }
+  return null;
+}
+
+/** ENOENT error string for a missing CLI binary. */
+export function cliNotFoundMessage(cli) {
+  return `Obsidian CLI not found at: ${cli}. Set OBSIDIAN_CLI_PATH or ensure '${cli}' is on PATH.`;
+}
+
+/** Standard MCP text result. */
+export function text(content) {
+  return { content: [{ type: "text", text: content }] };
+}
+
+/** Standard MCP error result. */
+export function errorResult(content, code = "EXECUTION_ERROR") {
+  return {
+    content: [{ type: "text", text: content }],
+    isError: true,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-obsidian-cli",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "type": "module",
   "description": "MCP server wrapping the Obsidian CLI — full native API access over Model Context Protocol",
   "main": "server.js",
@@ -9,11 +9,12 @@
   },
   "files": [
     "server.js",
+    "lib/",
     "prompts/"
   ],
   "scripts": {
     "start": "node server.js",
-    "test": "node --test test/run.test.js"
+    "test": "node --test test/*.test.js"
   },
   "engines": {
     "node": ">=18"

package/server.js

@@ -7,7 +7,7 @@
  * common operations (read, search, daily, tasks, properties, etc.).
  *
  * Environment variables:
- *   OBSIDIAN_CLI_PATH    - Path to the obsidian CLI binary (default: "obsidian")
+ *   OBSIDIAN_CLI_PATH    - Path to the obsidian CLI binary (default: "obsidian-cli")
  *   OBSIDIAN_VAULT       - Vault name to use (default: "")
  *   OBSIDIAN_TIMEOUT_MS  - Command timeout in ms (default: 15000)
  *
@@ -22,12 +22,21 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { readFileSync, mkdirSync, existsSync } from "node:fs";
-import { load as yamlLoad } from "js-yaml";
+import { readFileSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { exec } from "node:child_process";
+import {
+  loadConfig,
+  text,
+  errorResult,
+  buildCliArgs,
+  cliNotFoundMessage,
+  loadKnownVaults,
+  extractLeadingVault,
+  parseArgs,
+} from "./lib/helpers.js";
 
 const execFileAsync = promisify(execFile);
 const execAsync = promisify(exec);
@@ -46,42 +55,19 @@ const configBase = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
 const CONFIG_DIR = join(configBase, "mcp-obsidian-cli");
 const CONFIG_FILE = join(CONFIG_DIR, "config.yaml");
 
-function loadConfig() {
-  const defaults = { vault: "", cliPath: "obsidian", timeoutMs: 15000 };
-  let config = { ...defaults };
-
-  if (existsSync(CONFIG_FILE)) {
-    try {
-      const content = readFileSync(CONFIG_FILE, "utf8");
-      const fileConfig = yamlLoad(content);
-      if (fileConfig) {
-        if (fileConfig.vault) config.vault = fileConfig.vault;
-        if (fileConfig.cliPath) config.cliPath = fileConfig.cliPath;
-        if (fileConfig.timeoutMs) config.timeoutMs = fileConfig.timeoutMs;
-      }
-    } catch (err) {
-      console.error("Warning: failed to load config file:", err.message);
-    }
-  }
-
-  if (process.env.OBSIDIAN_VAULT) config.vault = process.env.OBSIDIAN_VAULT;
-  if (process.env.OBSIDIAN_CLI_PATH) config.cliPath = process.env.OBSIDIAN_CLI_PATH;
-  if (process.env.OBSIDIAN_TIMEOUT_MS) config.timeoutMs = parseInt(process.env.OBSIDIAN_TIMEOUT_MS, 10);
-
-  return config;
-}
 
 const KNOWN_CLI_PATHS = [
-  "/Applications/Obsidian.app/Contents/MacOS/obsidian",
-  join(homedir(), "Applications/Obsidian.app/Contents/MacOS/obsidian"),
+  "/Applications/Obsidian.app/Contents/MacOS/obsidian-cli",
+  join(homedir(), "Applications/Obsidian.app/Contents/MacOS/obsidian-cli"),
 ];
 
 async function resolveCliPath(configured) {
-  if (configured !== "obsidian") return configured;
+  if (configured !== "obsidian-cli") return configured;
 
   try {
-    await execAsync("which obsidian", { timeout: 2000 });
-    return configured;
+    const { stdout } = await execFileAsync("which", ["obsidian-cli"], { timeout: 2000 });
+    const resolved = stdout.trim();
+    if (resolved) return resolved;
   } catch { /* not on PATH */ }
 
   for (const p of KNOWN_CLI_PATHS) {
@@ -89,47 +75,77 @@ async function resolveCliPath(configured) {
   }
 
   try {
-    const { stdout } = await execAsync(
-      "ps aux | grep -i obsidian | grep -v grep | grep -v Helper",
+    const { stdout } = await execFileAsync(
+      "pgrep",
+      ["-lf", "/Applications/Obsidian.app/Contents/MacOS/Obsidian$"],
       { timeout: 2000 }
     );
-    const match = stdout.match(/(\S*\/Contents\/MacOS\/obsidian)/i);
-    if (match && existsSync(match[1])) return match[1];
+    const match = stdout.match(/(\S*\/Contents\/MacOS\/)Obsidian/i);
+    if (match) {
+      const cliPath = `${match[1]}obsidian-cli`;
+      if (existsSync(cliPath)) return cliPath;
+    }
   } catch { /* no running process */ }
 
   return configured;
 }
 
-const config = loadConfig();
+const config = loadConfig(CONFIG_FILE);
 const CLI = await resolveCliPath(config.cliPath);
-const VAULT = config.vault;
 const TIMEOUT_MS = config.timeoutMs;
 
+const OBSIDIAN_REGISTRY = join(
+  homedir(),
+  "Library/Application Support/obsidian/obsidian.json"
+);
+const KNOWN_VAULTS = loadKnownVaults(OBSIDIAN_REGISTRY);
+
+// Runtime vault selection. Held in process memory only — not persisted.
+// Initialized from config/env when that value names a known vault; otherwise
+// null, which triggers the prompt-on-first-use flow. Caller-supplied
+// `vault=NAME` in a generic `obsidian` call overrides + caches.
+let runtimeVault = null;
+if (config.vault) {
+  if (KNOWN_VAULTS.size === 0 || KNOWN_VAULTS.has(config.vault)) {
+    runtimeVault = config.vault;
+  } else {
+    console.error(
+      `Warning: configured OBSIDIAN_VAULT='${config.vault}' is not in Obsidian's known vaults ` +
+      `(${[...KNOWN_VAULTS].join(", ") || "<none detected>"}). ` +
+      `Server will ask which vault to use on first tool call.`
+    );
+  }
+}
+
+function vaultPromptResponse() {
+  const list = [...KNOWN_VAULTS].sort().map((v) => `  - ${v}`).join("\n");
+  return text(
+    `No vault selected. Available vaults:\n${list}\n\n` +
+    `Ask the user which vault to use, then either:\n` +
+    `  - retry through the generic \`obsidian\` tool with \`vault=NAME\` as the first token (e.g. \`vault=tyee read file="My Note"\`), or\n` +
+    `  - retry any convenience tool — the server will cache the vault from the first \`vault=\` override and reuse it for subsequent calls.\n\n` +
+    `If the user named a vault in conversation (e.g. "save this in tyee"), prepend \`vault=tyee\` automatically.`
+  );
+}
+
+const OBSIDIAN_PROCESS_PATTERN = "/Applications/Obsidian.app/Contents/MacOS/Obsidian$";
+const RUNNING_CACHE_TTL_MS = 5000;
+let runningCache = { value: null, at: 0 };
+
 async function checkObsidianRunning() {
+  const now = Date.now();
+  if (runningCache.value !== null && now - runningCache.at < RUNNING_CACHE_TTL_MS) {
+    return runningCache.value;
+  }
+  let running = false;
   try {
-    const { stdout: psOut } = await execAsync("ps aux | grep -i obsidian | grep -v grep | grep -v Helper", { timeout: 2000 });
-    const obsidianRunning = psOut.includes("/Applications/Obsidian.app");
-    if (!obsidianRunning) {
-      return { running: false, version: null };
-    }
-    const { stdout } = await execFileAsync(CLI, ["version"], { timeout: 2000 });
-    const hasStartupMsg = stdout.includes("Loaded updated app package") || 
-                          stdout.includes("Checking for update") ||
-                          stdout.includes("App is up to date") ||
-                          stdout.includes("Latest version is");
-    if (hasStartupMsg) {
-      return { running: false, version: null };
-    }
-    if (stdout.includes("(installer")) {
-      const match = stdout.match(/(\d+\.\d+\.\d+)/);
-      if (match) {
-        return { running: true, version: match[1] };
-      }
-    }
-    return { running: false, version: null };
-  } catch (err) {
-    return { running: false, version: null };
+    await execFileAsync("pgrep", ["-f", OBSIDIAN_PROCESS_PATTERN], { timeout: 2000 });
+    running = true;
+  } catch {
+    running = false;
   }
+  runningCache = { value: running, at: now };
+  return running;
 }
 
 // ---------------------------------------------------------------------------
@@ -140,9 +156,8 @@ async function checkObsidianRunning() {
  * Run the Obsidian CLI with the given argument string.
  * Returns { stdout, stderr } or throws on non-zero exit / timeout.
  */
-async function run(argString) {
-  const args = parseArgs(argString);
-  if (VAULT) args.push(`vault=${VAULT}`);
+async function run(input) {
+  const args = buildCliArgs(input, runtimeVault);
 
   try {
     const { stdout, stderr } = await execFileAsync(CLI, args, {
@@ -158,7 +173,7 @@ async function run(argString) {
         stderr: '',
         error: {
           type: 'CLI_NOT_FOUND',
-          message: `Obsidian CLI not found at: ${CLI}. Set OBSIDIAN_CLI_PATH or ensure 'obsidian' is on PATH.`
+          message: cliNotFoundMessage(CLI),
         }
       };
     }
@@ -177,35 +192,33 @@ async function run(argString) {
   }
 }
 
-/**
- * Minimal arg parser: splits on whitespace but respects key="value with spaces".
- */
-function parseArgs(str) {
-  const args = [];
-  const re = /(?:[^\s"]+|"[^"]*")+/g;
-  let m;
-  while ((m = re.exec(str)) !== null) {
-    args.push(m[0]);
-  }
-  return args;
-}
 
-/** Standard MCP text result. */
-function text(content) {
-  return { content: [{ type: "text", text: content }] };
-}
+/** Run CLI, return MCP result. Accepts a command string or an args array. */
+async function runTool(input) {
+  if (!(await checkObsidianRunning())) {
+    return errorResult(
+      "Obsidian.app is not running. Open Obsidian and retry — no Claude Desktop restart needed.",
+      "OBSIDIAN_NOT_RUNNING"
+    );
+  }
 
-/** Standard MCP error result. */
-function errorResult(content, code = "EXECUTION_ERROR") {
-  return {
-    content: [{ type: "text", text: content }],
-    isError: true,
-  };
-}
+  // Cache caller-supplied vault override so subsequent convenience-tool calls
+  // route to the same vault without the caller having to repeat it.
+  const parsed = Array.isArray(input) ? input : parseArgs(input);
+  const callerVault = extractLeadingVault(parsed);
+  if (callerVault) {
+    if (KNOWN_VAULTS.size > 0 && !KNOWN_VAULTS.has(callerVault)) {
+      return errorResult(
+        `Unknown vault '${callerVault}'. Known vaults: ${[...KNOWN_VAULTS].sort().join(", ")}.`,
+        "VAULT_NOT_FOUND"
+      );
+    }
+    runtimeVault = callerVault;
+  } else if (!runtimeVault && KNOWN_VAULTS.size > 0) {
+    return vaultPromptResponse();
+  }
 
-/** Run CLI, return MCP result. */
-async function runTool(argString) {
-  const { stdout, stderr, error } = await run(argString);
+  const { stdout, stderr, error } = await run(input);
   if (error) {
     return errorResult(error.message, error.type);
   }
@@ -221,7 +234,7 @@ async function runTool(argString) {
 
 const server = new McpServer({
   name: "obsidian-mcp",
-  version: "1.1.0",
+  version: "1.3.0",
   capabilities: { tools: {} },
 });
 
@@ -231,6 +244,16 @@ server.tool(
   "obsidian",
   `Run any Obsidian CLI command. Pass the full command string exactly as you
 would on the terminal (minus the leading 'obsidian' binary name).
+
+IMPORTANT: when multiple vaults are loaded, the CLI's vault= argument must
+be the FIRST token. The server auto-prepends vault=<runtimeVault> once a
+vault has been selected; if you include vault= manually in this command
+string, put it first or the CLI silently routes to the focused vault.
+
+VAULT ROUTING: if the user names a vault in conversation (e.g. "save this
+in tyee", "scarp note"), prepend \`vault=NAME \` as the first token. The
+server caches that selection in memory for subsequent calls.
+
 Examples:
   "daily:read"
   "search:context query=\"meeting notes\" limit=5"
@@ -238,6 +261,7 @@ Examples:
   "tags counts sort=count"
   "tasks daily"
   "property:read name=status path=\"1p/my-project/my-project.md\""
+  "vault=tyee read file=\"My Note\""   # explicit vault override, first
   "help search"`,
   { command: z.string().describe("CLI command and arguments") },
   async ({ command }) => runTool(command),
@@ -263,7 +287,7 @@ server.tool(
   "obsidian_daily_append",
   "Append content to today's daily note.\n\nParameters:\n  content (required) — markdown text to append at the end of today's daily note\n\nExamples:\n  obsidian_daily_append({ content: \"- Meeting with team at 3pm\" })\n  obsidian_daily_append({ content: \"> [!tip] Remember\\n> Review PR before EOD\" })",
   { content: z.string().describe("Content to append") },
-  async ({ content }) => runTool(`daily:append content="${content.replace(/"/g, '\\"')}"`),
+  async ({ content }) => runTool(["daily:append", `content=${content}`]),
 );
 
 server.tool(
@@ -275,8 +299,10 @@ server.tool(
   },
   async ({ file, path }) => {
     if (!file && !path) return text("Error: provide file= or path=");
-    const arg = file ? `file="${file}"` : `path="${path}"`;
-    return runTool(`read ${arg}`);
+    const args = ["read"];
+    if (file) args.push(`file=${file}`);
+    if (path) args.push(`path=${path}`);
+    return runTool(args);
   },
 );
 
@@ -289,10 +315,10 @@ server.tool(
     limit: z.number().optional().describe("Max files to return"),
   },
   async ({ query, path, limit }) => {
-    let cmd = `search:context query="${query.replace(/"/g, '\\"')}"`;
-    if (path) cmd += ` path="${path}"`;
-    if (limit) cmd += ` limit=${limit}`;
-    return runTool(cmd);
+    const args = ["search:context", `query=${query}`];
+    if (path) args.push(`path=${path}`);
+    if (limit) args.push(`limit=${limit}`);
+    return runTool(args);
   },
 );
 
@@ -303,9 +329,9 @@ server.tool(
     sort: z.enum(["name", "count"]).optional().describe("Sort order"),
   },
   async ({ sort }) => {
-    let cmd = "tags counts";
-    if (sort) cmd += ` sort=${sort}`;
-    return runTool(cmd);
+    const args = ["tags", "counts"];
+    if (sort) args.push(`sort=${sort}`);
+    return runTool(args);
   },
 );
 
@@ -319,12 +345,12 @@ server.tool(
     path: z.string().optional().describe("Filter by file path"),
   },
   async ({ daily, todo, done, path }) => {
-    let cmd = "tasks";
-    if (daily) cmd += " daily";
-    if (todo) cmd += " todo";
-    if (done) cmd += " done";
-    if (path) cmd += ` path="${path}"`;
-    return runTool(cmd);
+    const args = ["tasks"];
+    if (daily) args.push("daily");
+    if (todo) args.push("todo");
+    if (done) args.push("done");
+    if (path) args.push(`path=${path}`);
+    return runTool(args);
   },
 );
 
@@ -338,15 +364,16 @@ server.tool(
   },
   async ({ file, path, name }) => {
     if (name && (file || path)) {
-      // Read a specific property from a specific file
-      const target = file ? `file="${file}"` : `path="${path}"`;
-      return runTool(`property:read name="${name}" ${target}`);
+      const args = ["property:read", `name=${name}`];
+      if (file) args.push(`file=${file}`);
+      if (path) args.push(`path=${path}`);
+      return runTool(args);
     }
-    let cmd = "properties";
-    if (file) cmd += ` file="${file}"`;
-    if (path) cmd += ` path="${path}"`;
-    cmd += " counts";
-    return runTool(cmd);
+    const args = ["properties"];
+    if (file) args.push(`file=${file}`);
+    if (path) args.push(`path=${path}`);
+    args.push("counts");
+    return runTool(args);
   },
 );
 
@@ -360,12 +387,12 @@ server.tool(
     template: z.string().optional().describe("Template to use"),
   },
   async ({ name, path, content, template }) => {
-    let cmd = "create";
-    if (name) cmd += ` name="${name}"`;
-    if (path) cmd += ` path="${path}"`;
-    if (template) cmd += ` template="${template}"`;
-    if (content) cmd += ` content="${content.replace(/"/g, '\\"')}"`;
-    return runTool(cmd);
+    const args = ["create"];
+    if (name) args.push(`name=${name}`);
+    if (path) args.push(`path=${path}`);
+    if (template) args.push(`template=${template}`);
+    if (content) args.push(`content=${content}`);
+    return runTool(args);
   },
 );
 
@@ -379,9 +406,11 @@ server.tool(
     path: z.string().optional().describe("File path"),
   },
   async ({ name, value, file, path: filePath }) => {
-    const target = file ? `file="${file}"` : filePath ? `path="${filePath}"` : "";
-    if (!target) return text("Error: provide file= or path=");
-    return runTool(`property:set name="${name}" value="${value.replace(/"/g, '\\"')}" ${target}`);
+    if (!file && !filePath) return text("Error: provide file= or path=");
+    const args = ["property:set", `name=${name}`, `value=${value}`];
+    if (file) args.push(`file=${file}`);
+    if (filePath) args.push(`path=${filePath}`);
+    return runTool(args);
   },
 );
 
@@ -393,8 +422,11 @@ server.tool(
     path: z.string().optional().describe("File path"),
   },
   async ({ file, path }) => {
-    const target = file ? `file="${file}"` : path ? `path="${path}"` : "";
-    return runTool(`backlinks ${target} counts`);
+    const args = ["backlinks"];
+    if (file) args.push(`file=${file}`);
+    if (path) args.push(`path=${path}`);
+    args.push("counts");
+    return runTool(args);
   },
 );
 
@@ -406,10 +438,10 @@ server.tool(
     ext: z.string().optional().describe("Filter by extension"),
   },
   async ({ folder, ext }) => {
-    let cmd = "files";
-    if (folder) cmd += ` folder="${folder}"`;
-    if (ext) cmd += ` ext=${ext}`;
-    return runTool(cmd);
+    const args = ["files"];
+    if (folder) args.push(`folder=${folder}`);
+    if (ext) args.push(`ext=${ext}`);
+    return runTool(args);
   },
 );
 
@@ -464,13 +496,14 @@ for (const [name, content] of Object.entries(promptContent)) {
 // ---- Start ---------------------------------------------------------------
 
 async function main() {
-  const { running, version } = await checkObsidianRunning();
+  const running = await checkObsidianRunning();
   if (!running) {
-    console.error("Error: Obsidian is not running. Please open Obsidian and try again.");
-    process.exit(1);
+    console.error(
+      "Warning: Obsidian.app not detected. Server will accept connections; tool calls will fail until Obsidian is opened."
+    );
   }
   const transport = new StdioServerTransport();
-  console.error(`obsidian-mcp server running on stdio (Obsidian ${version})`);
+  console.error("obsidian-mcp server running on stdio");
   await server.connect(transport);
 }