obsidian-mcp-server 2.0.6 → 3.0.0

package/CHANGELOG.md

@@ -1,118 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [2.0.6] - 2025-06-20
-
-### Changed
-
-- **Tool Renaming**: Renamed `obsidian_read_file`, `obsidian_delete_file`, and `obsidian_list_files` to `obsidian_read_note`, `obsidian_delete_note`, and `obsidian_list_notes` respectively. This change improves semantic clarity and aligns the tool names more closely with Obsidian's terminology, reducing ambiguity for AI agents.
-- **Dependency Updates**: Updated all dependencies to their latest versions.
-- **Documentation Improvements**: Updated `.clinerules` to reflect the new tool names and ensure all documentation is current.
-
-## [2.0.5] - 2025-06-20
-
-### Changed
-
-- **Tool Renaming**: Renamed the `obsidian_update_file` tool to `obsidian_update_note` to avoid conflicts and better reflect its function. During agentic use, LLMs confused this tool with filesystem operations, leading to errors. The new name clarifies that it operates on Obsidian notes specifically.
-- **HTTP Transport Refactor**: Restructured the HTTP transport layer for improved clarity and robustness. Authentication logic is now more modular, and a centralized error handler has been implemented.
-- **Dependency Updates**: Updated all dependencies to their latest versions.
-- **Documentation Improvements**: Enhanced the documentation around installation & MCP Client configuration. Suggested by [@bgheneti](https://github.com/bgheneti) in [PR #14](https://github.com/cyanheads/obsidian-mcp-server/pull/14). Thanks!
-
-## [2.0.4] - 2025-06-13
-
-### Added
-
-- **Recursive File Listing**: The `obsidian_list_files` tool now supports recursive listing of directories with a `recursionDepth` parameter.
-
-### Changed
-
-- **Documentation**:
-  - Consolidated tool specifications into `obsidian_mcp_tools_spec.md`.
-  - Updated `.clinerules` with a detailed logger implementation example for the agent.
-  - Updated the repository's directory tree documentation.
-
-## [2.0.3] - 2025-06-12
-
-### Fixed
-
-- **NPM Package Display**: Explicitly included `README.md`, `LICENSE`, and `CHANGELOG.md` in the `files` array in `package.json` to ensure they are displayed correctly on the npm package page.
-
-## [2.0.2] - 2025-06-12
-
-### Fixed
-
-- **NPM Package Version**: Bad npm package. Bumping to v2.0.2 for publishing.
-
-## [2.0.1] - 2025-06-12
-
-### Added
-
-- **Enhanced Documentation**:
-  - Added a warning to the `VaultCacheService` documentation about its potential for high memory usage on large vaults.
-  - Added a code comment in `obsidianManageFrontmatterTool` to clarify the regex-based key deletion strategy.
-
-### Changed
-
-- **Improved SSL Handling**: The `OBSIDIAN_VERIFY_SSL` environment variable is now correctly parsed as a boolean, ensuring more reliable SSL verification behavior.
-- **API Service Refactoring**: Simplified the `httpsAgent` handling within the `ObsidianRestApiService` to improve code clarity and remove redundant agent creation on each request.
-
-### Fixed
-
-- **Path Import Correction**: Corrected a path import in the `obsidianGlobalSearchTool` to use `node:path/posix` for better cross-platform compatibility.
-
-## [2.0.0] - 2025-06-12
-
-Version 2.0.0 is a complete overhaul of the Obsidian MCP Server, migrating it to my [`cyanheads/mcp-ts-template`](https://github.com/cyanheads/mcp-ts-template). This release introduces a more robust architecture, a streamlined toolset, enhanced security, and significant performance improvements. It is a breaking change from the 1.x series.
-
-### Added
-
-- **New Core Architecture**: The server is now built on the [`cyanheads/mcp-ts-template`](https://github.com/cyanheads/mcp-ts-template), providing a standardized, modular, and maintainable structure.
-- **Hono HTTP Transport**: The HTTP transport has been migrated from Express to Hono, offering a more lightweight and performant server.
-- **Vault Cache Service**: A new in-memory `VaultCacheService` has been introduced. It caches vault content to improve performance for search operations and provides a resilient fallback if the Obsidian API is temporarily unavailable. It also refreshes periodically.
-- **Advanced Authentication**:
-  - Added support for **OAuth 2.1** bearer token validation alongside the existing secret key-based JWTs.
-  - Introduced `authContext` using `AsyncLocalStorage` for secure, request-scoped access to authentication details.
-- **New Tools**:
-  - `obsidian_delete_file`: A new tool to permanently delete files from the vault.
-  - `obsidian_search_replace`: A powerful new tool to perform search and replace operations with regex support.
-- **Enhanced Utilities**:
-  - **Request Context**: A robust request context system (`requestContextService`) for improved logging and tracing.
-  - **Error Handling**: A centralized `ErrorHandler` for consistent and detailed error reporting.
-  - **Async Utilities**: A `retryWithDelay` utility is now used across the application to make API calls more resilient.
-- **New Development Scripts**: Added `docs:generate` (for TypeDoc) and `inspect:stdio`/`inspect:http` (for MCP Inspector) to `package.json`.
-
-### Changed
-
-- **Project Structure**: The entire project has been reorganized to align with the [`cyanheads/mcp-ts-template`](https://github.com/cyanheads/mcp-ts-template), improving separation of concerns (e.g., `services`, `mcp-server`, `types-global`).
-- **Tool Consolidation and Enhancement**: The toolset has been redesigned for clarity and power:
-  - `obsidian_list_files` replaces `obsidian_list_files_in_vault` and `obsidian_list_files_in_dir`, offering more flexible filtering.
-  - `obsidian_read_file` replaces `obsidian_get_file_contents` and now supports returning content as structured JSON.
-  - `obsidian_update_file` replaces `obsidian_append_content` and `obsidian_update_content` with explicit modes (`append`, `prepend`, `overwrite`).
-  - `obsidian_global_search` replaces `obsidian_find_in_file` with added support for path/date filtering and pagination.
-  - `obsidian_manage_frontmatter` replaces `obsidian_get_properties` and `obsidian_update_properties` with atomic get/set/delete operations.
-  - `obsidian_manage_tags` replaces `obsidian_get_tags` and now manages both frontmatter and inline tags.
-- **Configuration Overhaul**: Environment variables have been renamed for consistency and clarity.
-  - `OBSIDIAN_BASE_URL` now consolidates protocol, host, and port.
-  - New variables like `MCP_TRANSPORT_TYPE`, `MCP_LOG_LEVEL`, and `MCP_AUTH_SECRET_KEY` have been introduced.
-- **Dependency Updates**: All dependencies, including the MCP SDK, have been updated to their latest stable versions.
-- **Obsidian API Service**: The `ObsidianRestApiService` has been completely refactored into a modular class, providing a typed, resilient, and centralized client for all interactions with the Obsidian Local REST API.
-
-### Removed
-
-- **Removed Tools**: The following tools from version 1.x have been removed and their functionality integrated into the new, more comprehensive tools:
-  - `obsidian_list_files_in_vault`
-  - `obsidian_list_files_in_dir`
-  - `obsidian_get_file_contents`
-  - `obsidian_append_content`
-  - `obsidian_update_content`
-  - `obsidian_find_in_file`
-  - `obsidian_complex_search` (path-based searching is now a filter in `obsidian_global_search`)
-  - `obsidian_get_tags`
-  - `obsidian_get_properties`
-  - `obsidian_update_properties`
-- **Removed Resources**: The `obsidian://tags` resource has been removed. Tag information is now available through the `obsidian_manage_tags` tool. I may add the resource back in the future if there is demand for it. Please open an issue if you would like to see it return.
-- **Old Configuration**: All old, non-prefixed environment variables (e.g., `VERIFY_SSL`, `REQUEST_TIMEOUT`) have been removed in favor of the new, standardized configuration schema.

package/dist/config/index.d.ts

@@ -1,41 +0,0 @@
-/**
- * Main application configuration object.
- */
-export declare const config: {
-    pkg: {
-        name: string;
-        version: string;
-    };
-    mcpServerName: string;
-    mcpServerVersion: string;
-    logLevel: string;
-    logsPath: string;
-    environment: string;
-    mcpTransportType: "stdio" | "http";
-    mcpHttpPort: number;
-    mcpHttpHost: string;
-    mcpAllowedOrigins: string[] | undefined;
-    mcpAuthMode: "jwt" | "oauth" | undefined;
-    mcpAuthSecretKey: string | undefined;
-    oauthIssuerUrl: string | undefined;
-    oauthAudience: string | undefined;
-    oauthJwksUri: string | undefined;
-    obsidianApiKey: string;
-    obsidianBaseUrl: string;
-    obsidianVerifySsl: boolean;
-    obsidianCacheRefreshIntervalMin: number;
-    obsidianEnableCache: boolean;
-    obsidianApiSearchTimeoutMs: number;
-};
-/**
- * The configured logging level for the application.
- * Exported separately for convenience (e.g., logger initialization).
- * @type {string}
- */
-export declare const logLevel: string;
-/**
- * The configured runtime environment for the application.
- * Exported separately for convenience.
- * @type {string}
- */
-export declare const environment: string;

package/dist/config/index.js

@@ -1,191 +0,0 @@
-import dotenv from "dotenv";
-import { existsSync, mkdirSync, readFileSync, statSync } from "fs";
-import path, { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import { z } from "zod";
-dotenv.config();
-// --- Determine Project Root ---
-/**
- * Finds the project root directory by searching upwards for package.json.
- * @param startDir The directory to start searching from.
- * @returns The absolute path to the project root, or throws an error if not found.
- */
-const findProjectRoot = (startDir) => {
-    let currentDir = startDir;
-    while (true) {
-        const packageJsonPath = join(currentDir, "package.json");
-        if (existsSync(packageJsonPath)) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            // Reached the root of the filesystem without finding package.json
-            throw new Error(`Could not find project root (package.json) starting from ${startDir}`);
-        }
-        currentDir = parentDir;
-    }
-};
-let projectRoot;
-try {
-    // For ESM, __dirname is not available directly.
-    const currentModuleDir = dirname(fileURLToPath(import.meta.url));
-    projectRoot = findProjectRoot(currentModuleDir);
-}
-catch (error) {
-    console.error(`FATAL: Error determining project root: ${error.message}`);
-    projectRoot = process.cwd();
-    console.warn(`Warning: Using process.cwd() (${projectRoot}) as fallback project root.`);
-}
-// --- End Determine Project Root ---
-const pkgPath = join(projectRoot, "package.json");
-let pkg = { name: "obsidian-mcp-server", version: "0.0.0" };
-try {
-    pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-}
-catch (error) {
-    if (process.stderr.isTTY) {
-        console.error("Warning: Could not read package.json for default config values. Using hardcoded defaults.", error);
-    }
-}
-/**
- * Zod schema for validating environment variables.
- * @private
- */
-const EnvSchema = z.object({
-    MCP_SERVER_NAME: z.string().optional(),
-    MCP_SERVER_VERSION: z.string().optional(),
-    MCP_LOG_LEVEL: z.string().default("info"),
-    LOGS_DIR: z.string().default(path.join(projectRoot, "logs")),
-    NODE_ENV: z.string().default("development"),
-    MCP_TRANSPORT_TYPE: z.enum(["stdio", "http"]).default("stdio"),
-    MCP_HTTP_PORT: z.coerce.number().int().positive().default(3010),
-    MCP_HTTP_HOST: z.string().default("127.0.0.1"),
-    MCP_ALLOWED_ORIGINS: z.string().optional(),
-    MCP_AUTH_MODE: z.enum(["jwt", "oauth"]).optional(),
-    MCP_AUTH_SECRET_KEY: z
-        .string()
-        .min(32, "MCP_AUTH_SECRET_KEY must be at least 32 characters long for security")
-        .optional(),
-    OAUTH_ISSUER_URL: z.string().url().optional(),
-    OAUTH_AUDIENCE: z.string().optional(),
-    OAUTH_JWKS_URI: z.string().url().optional(),
-    // --- Obsidian Specific Config ---
-    OBSIDIAN_API_KEY: z.string().min(1, "OBSIDIAN_API_KEY cannot be empty"),
-    OBSIDIAN_BASE_URL: z.string().url().default("http://127.0.0.1:27123"),
-    OBSIDIAN_VERIFY_SSL: z
-        .string()
-        .transform((val) => val.toLowerCase() === "true")
-        .default("false"),
-    OBSIDIAN_CACHE_REFRESH_INTERVAL_MIN: z.coerce
-        .number()
-        .int()
-        .positive()
-        .default(10),
-    OBSIDIAN_ENABLE_CACHE: z
-        .string()
-        .transform((val) => val.toLowerCase() === "true")
-        .default("true"),
-    OBSIDIAN_API_SEARCH_TIMEOUT_MS: z.coerce
-        .number()
-        .int()
-        .positive()
-        .default(30000),
-});
-const parsedEnv = EnvSchema.safeParse(process.env);
-if (!parsedEnv.success) {
-    const errorDetails = parsedEnv.error.flatten().fieldErrors;
-    if (process.stderr.isTTY) {
-        console.error("❌ Invalid environment variables:", errorDetails);
-    }
-    throw new Error(`Invalid environment configuration. Please check your .env file or environment variables. Details: ${JSON.stringify(errorDetails)}`);
-}
-const env = parsedEnv.data;
-// --- Directory Ensurance Function ---
-const ensureDirectory = (dirPath, rootDir, dirName) => {
-    const resolvedDirPath = path.isAbsolute(dirPath)
-        ? dirPath
-        : path.resolve(rootDir, dirPath);
-    if (!resolvedDirPath.startsWith(rootDir + path.sep) &&
-        resolvedDirPath !== rootDir) {
-        if (process.stderr.isTTY) {
-            console.error(`Error: ${dirName} path "${dirPath}" resolves to "${resolvedDirPath}", which is outside the project boundary "${rootDir}".`);
-        }
-        return null;
-    }
-    if (!existsSync(resolvedDirPath)) {
-        try {
-            mkdirSync(resolvedDirPath, { recursive: true });
-        }
-        catch (err) {
-            if (process.stderr.isTTY) {
-                console.error(`Error creating ${dirName} directory at ${resolvedDirPath}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            return null;
-        }
-    }
-    else {
-        try {
-            if (!statSync(resolvedDirPath).isDirectory()) {
-                if (process.stderr.isTTY) {
-                    console.error(`Error: ${dirName} path ${resolvedDirPath} exists but is not a directory.`);
-                }
-                return null;
-            }
-        }
-        catch (statError) {
-            if (process.stderr.isTTY) {
-                console.error(`Error accessing ${dirName} path ${resolvedDirPath}: ${statError.message}`);
-            }
-            return null;
-        }
-    }
-    return resolvedDirPath;
-};
-// --- End Directory Ensurance Function ---
-const validatedLogsPath = ensureDirectory(env.LOGS_DIR, projectRoot, "logs");
-if (!validatedLogsPath) {
-    if (process.stderr.isTTY) {
-        console.error("FATAL: Logs directory configuration is invalid or could not be created. Please check permissions and path. Exiting.");
-    }
-    process.exit(1);
-}
-/**
- * Main application configuration object.
- */
-export const config = {
-    pkg,
-    mcpServerName: env.MCP_SERVER_NAME || pkg.name,
-    mcpServerVersion: env.MCP_SERVER_VERSION || pkg.version,
-    logLevel: env.MCP_LOG_LEVEL,
-    logsPath: validatedLogsPath,
-    environment: env.NODE_ENV,
-    mcpTransportType: env.MCP_TRANSPORT_TYPE,
-    mcpHttpPort: env.MCP_HTTP_PORT,
-    mcpHttpHost: env.MCP_HTTP_HOST,
-    mcpAllowedOrigins: env.MCP_ALLOWED_ORIGINS?.split(",")
-        .map((origin) => origin.trim())
-        .filter(Boolean),
-    mcpAuthMode: env.MCP_AUTH_MODE,
-    mcpAuthSecretKey: env.MCP_AUTH_SECRET_KEY,
-    oauthIssuerUrl: env.OAUTH_ISSUER_URL,
-    oauthAudience: env.OAUTH_AUDIENCE,
-    oauthJwksUri: env.OAUTH_JWKS_URI,
-    obsidianApiKey: env.OBSIDIAN_API_KEY,
-    obsidianBaseUrl: env.OBSIDIAN_BASE_URL,
-    obsidianVerifySsl: env.OBSIDIAN_VERIFY_SSL,
-    obsidianCacheRefreshIntervalMin: env.OBSIDIAN_CACHE_REFRESH_INTERVAL_MIN,
-    obsidianEnableCache: env.OBSIDIAN_ENABLE_CACHE,
-    obsidianApiSearchTimeoutMs: env.OBSIDIAN_API_SEARCH_TIMEOUT_MS,
-};
-/**
- * The configured logging level for the application.
- * Exported separately for convenience (e.g., logger initialization).
- * @type {string}
- */
-export const logLevel = config.logLevel;
-/**
- * The configured runtime environment for the application.
- * Exported separately for convenience.
- * @type {string}
- */
-export const environment = config.environment;

package/dist/mcp-server/server.d.ts

@@ -1,33 +0,0 @@
-/**
- * @fileoverview Main entry point for the MCP (Model Context Protocol) server.
- * This file orchestrates the server's lifecycle:
- * 1. Initializes the core `McpServer` instance (from `@modelcontextprotocol/sdk`) with its identity and capabilities.
- * 2. Registers available resources and tools, making them discoverable and usable by clients.
- * 3. Selects and starts the appropriate communication transport (stdio or Streamable HTTP)
- *    based on configuration.
- * 4. Handles top-level error management during startup.
- *
- * MCP Specification References:
- * - Lifecycle: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/lifecycle.mdx
- * - Overview (Capabilities): https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/index.mdx
- * - Transports: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx
- * @module src/mcp-server/server
- */
-import { ServerType } from "@hono/node-server";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { ObsidianRestApiService } from "../services/obsidianRestAPI/index.js";
-import { VaultCacheService } from "../services/obsidianRestAPI/vaultCache/index.js";
-/**
- * Main application entry point. Initializes services and starts the MCP server.
- * Orchestrates server startup, transport selection, and top-level error handling.
- *
- * MCP Spec Relevance:
- * - Manages server startup, leading to a server ready for MCP messages.
- * - Handles critical startup failures, ensuring appropriate process exit.
- *
- * @param {ObsidianRestApiService} obsidianService - The shared Obsidian REST API service instance, instantiated by the caller (e.g., index.ts).
- * @param {VaultCacheService | undefined} vaultCacheService - The shared Vault Cache service instance, instantiated by the caller (e.g., index.ts).
- * @returns {Promise<void | McpServer>} For 'stdio', resolves with `McpServer`. For 'http', runs indefinitely.
- *   Rejects on critical failure, leading to process exit.
- */
-export declare function initializeAndStartServer(obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined): Promise<void | McpServer | ServerType>;

package/dist/mcp-server/server.js

@@ -1,211 +0,0 @@
-/**
- * @fileoverview Main entry point for the MCP (Model Context Protocol) server.
- * This file orchestrates the server's lifecycle:
- * 1. Initializes the core `McpServer` instance (from `@modelcontextprotocol/sdk`) with its identity and capabilities.
- * 2. Registers available resources and tools, making them discoverable and usable by clients.
- * 3. Selects and starts the appropriate communication transport (stdio or Streamable HTTP)
- *    based on configuration.
- * 4. Handles top-level error management during startup.
- *
- * MCP Specification References:
- * - Lifecycle: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/lifecycle.mdx
- * - Overview (Capabilities): https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/index.mdx
- * - Transports: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx
- * @module src/mcp-server/server
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-// Import validated configuration and environment details.
-import { config, environment } from "../config/index.js";
-// Import core utilities: ErrorHandler, logger, requestContextService.
-import { ErrorHandler, logger, requestContextService } from "../utils/index.js";
-// Import registration functions for specific resources and tools.
-import { registerObsidianDeleteNoteTool } from "./tools/obsidianDeleteNoteTool/index.js";
-import { registerObsidianGlobalSearchTool } from "./tools/obsidianGlobalSearchTool/index.js";
-import { registerObsidianListNotesTool } from "./tools/obsidianListNotesTool/index.js";
-import { registerObsidianReadNoteTool } from "./tools/obsidianReadNoteTool/index.js";
-import { registerObsidianSearchReplaceTool } from "./tools/obsidianSearchReplaceTool/index.js";
-import { registerObsidianUpdateNoteTool } from "./tools/obsidianUpdateNoteTool/index.js";
-import { registerObsidianManageFrontmatterTool } from "./tools/obsidianManageFrontmatterTool/index.js";
-import { registerObsidianManageTagsTool } from "./tools/obsidianManageTagsTool/index.js";
-// Import transport setup functions.
-import { startHttpTransport } from "./transports/httpTransport.js";
-import { connectStdioTransport } from "./transports/stdioTransport.js";
-/**
- * Creates and configures a new instance of the `McpServer`.
- *
- * This function is central to defining the server's identity and functionality
- * as presented to connecting clients during the MCP initialization phase.
- * It uses pre-instantiated shared services like Obsidian API and Vault Cache.
- *
- * MCP Spec Relevance:
- * - Server Identity (`serverInfo`): The `name` and `version` provided here are part
- *   of the `ServerInformation` object returned in the `InitializeResult` message.
- * - Capabilities Declaration: Declares supported features (logging, dynamic resources/tools).
- * - Resource/Tool Registration: Calls registration functions, passing necessary service instances.
- *
- * Design Note: This factory is called once for 'stdio' transport and per session for 'http' transport.
- *
- * @param {ObsidianRestApiService} obsidianService - The shared Obsidian REST API service instance.
- * @param {VaultCacheService | undefined} vaultCacheService - The shared Vault Cache service instance, which may be undefined if disabled.
- * @returns {Promise<McpServer>} A promise resolving with the configured `McpServer` instance.
- * @throws {Error} If any resource or tool registration fails.
- * @private
- */
-async function createMcpServerInstance(obsidianService, vaultCacheService) {
-    const context = requestContextService.createRequestContext({
-        operation: "createMcpServerInstance",
-    });
-    logger.info("Initializing MCP server instance with shared services", context);
-    requestContextService.configure({
-        appName: config.mcpServerName,
-        appVersion: config.mcpServerVersion,
-        environment,
-    });
-    logger.debug("Instantiating McpServer with capabilities", {
-        ...context,
-        serverInfo: {
-            name: config.mcpServerName,
-            version: config.mcpServerVersion,
-        },
-        capabilities: {
-            logging: {},
-            resources: { listChanged: true },
-            tools: { listChanged: true },
-        },
-    });
-    const server = new McpServer({ name: config.mcpServerName, version: config.mcpServerVersion }, {
-        capabilities: {
-            logging: {}, // Server can receive logging/setLevel and send notifications/message
-            resources: { listChanged: true }, // Server supports dynamic resource lists
-            tools: { listChanged: true }, // Server supports dynamic tool lists
-        },
-    });
-    try {
-        logger.debug("Registering resources and tools using shared services...", context);
-        // Register all tools, passing the vaultCacheService which may be undefined
-        await registerObsidianListNotesTool(server, obsidianService);
-        await registerObsidianReadNoteTool(server, obsidianService);
-        await registerObsidianDeleteNoteTool(server, obsidianService, vaultCacheService);
-        if (vaultCacheService) {
-            await registerObsidianGlobalSearchTool(server, obsidianService, vaultCacheService);
-        }
-        else {
-            logger.warning("Skipping registration of 'obsidian_global_search' because the Vault Cache Service is disabled.", context);
-        }
-        await registerObsidianSearchReplaceTool(server, obsidianService, vaultCacheService);
-        await registerObsidianUpdateNoteTool(server, obsidianService, vaultCacheService);
-        await registerObsidianManageFrontmatterTool(server, obsidianService, vaultCacheService);
-        await registerObsidianManageTagsTool(server, obsidianService, vaultCacheService);
-        logger.info("Resources and tools registered successfully", context);
-        if (vaultCacheService) {
-            logger.info("Triggering background vault cache build (if not already built/building)...", context);
-            // Intentionally not awaiting this promise to allow server startup to proceed.
-            // Errors are logged within the catch block.
-            vaultCacheService.buildVaultCache().catch((cacheBuildError) => {
-                logger.error("Error occurred during background vault cache build", {
-                    ...context, // Use the initial context for correlation
-                    subOperation: "BackgroundVaultCacheBuild", // Add sub-operation for clarity
-                    error: cacheBuildError instanceof Error
-                        ? cacheBuildError.message
-                        : String(cacheBuildError),
-                    stack: cacheBuildError instanceof Error
-                        ? cacheBuildError.stack
-                        : undefined,
-                });
-            });
-        }
-    }
-    catch (err) {
-        logger.error("Failed to register resources/tools", {
-            ...context,
-            error: err instanceof Error ? err.message : String(err),
-            stack: err instanceof Error ? err.stack : undefined,
-        });
-        throw err; // Re-throw to be caught by the caller (e.g., startTransport)
-    }
-    return server;
-}
-/**
- * Selects, sets up, and starts the appropriate MCP transport layer based on configuration.
- * This function acts as the bridge between the core server logic and the communication channel.
- * It now accepts shared service instances to pass them down the chain.
- *
- * MCP Spec Relevance:
- * - Transport Selection: Uses `config.mcpTransportType` ('stdio' or 'http').
- * - Transport Connection: Calls dedicated functions for chosen transport.
- * - Server Instance Lifecycle: Single instance for 'stdio', per-session for 'http'.
- *
- * @param {ObsidianRestApiService} obsidianService - The shared Obsidian REST API service instance.
- * @param {VaultCacheService | undefined} vaultCacheService - The shared Vault Cache service instance.
- * @returns {Promise<McpServer | void>} Resolves with the `McpServer` instance for 'stdio', or `void` for 'http'.
- * @throws {Error} If the configured transport type is unsupported or if transport setup fails.
- * @private
- */
-async function startTransport(obsidianService, vaultCacheService) {
-    const transportType = config.mcpTransportType;
-    const context = requestContextService.createRequestContext({
-        operation: "startTransport",
-        transport: transportType,
-    });
-    logger.info(`Starting transport: ${transportType}`, context);
-    if (transportType === "http") {
-        logger.debug("Delegating to startHttpTransport with a factory for McpServer instances...", context);
-        // For HTTP, startHttpTransport manages its own lifecycle and server instances per session.
-        // It needs a factory function to create new McpServer instances, passing along the shared services.
-        const mcpServerFactory = async () => createMcpServerInstance(obsidianService, vaultCacheService);
-        const httpServerInstance = await startHttpTransport(mcpServerFactory, context);
-        return httpServerInstance; // Return the http.Server instance.
-    }
-    if (transportType === "stdio") {
-        logger.debug("Creating single McpServer instance for stdio transport using shared services...", context);
-        const server = await createMcpServerInstance(obsidianService, vaultCacheService);
-        logger.debug("Delegating to connectStdioTransport...", context);
-        await connectStdioTransport(server, context);
-        return server; // Return the single server instance for stdio.
-    }
-    // Should not be reached if config validation is effective.
-    logger.fatal(`Unsupported transport type configured: ${transportType}`, context);
-    throw new Error(`Unsupported transport type: ${transportType}. Must be 'stdio' or 'http'.`);
-}
-/**
- * Main application entry point. Initializes services and starts the MCP server.
- * Orchestrates server startup, transport selection, and top-level error handling.
- *
- * MCP Spec Relevance:
- * - Manages server startup, leading to a server ready for MCP messages.
- * - Handles critical startup failures, ensuring appropriate process exit.
- *
- * @param {ObsidianRestApiService} obsidianService - The shared Obsidian REST API service instance, instantiated by the caller (e.g., index.ts).
- * @param {VaultCacheService | undefined} vaultCacheService - The shared Vault Cache service instance, instantiated by the caller (e.g., index.ts).
- * @returns {Promise<void | McpServer>} For 'stdio', resolves with `McpServer`. For 'http', runs indefinitely.
- *   Rejects on critical failure, leading to process exit.
- */
-export async function initializeAndStartServer(obsidianService, vaultCacheService) {
-    const context = requestContextService.createRequestContext({
-        operation: "initializeAndStartServer",
-    });
-    logger.info("MCP Server initialization sequence started (services provided).", context);
-    try {
-        // Services are now provided by the caller (e.g., index.ts)
-        logger.debug("Using provided shared services (ObsidianRestApiService, VaultCacheService).", context);
-        // Initiate the transport setup based on configuration, passing shared services.
-        const result = await startTransport(obsidianService, vaultCacheService);
-        logger.info("MCP Server initialization sequence completed successfully.", context);
-        return result;
-    }
-    catch (err) {
-        logger.fatal("Critical error during MCP server initialization.", {
-            ...context,
-            error: err instanceof Error ? err.message : String(err),
-            stack: err instanceof Error ? err.stack : undefined,
-        });
-        // Ensure the error is handled by our centralized handler, which might log more details or perform cleanup.
-        ErrorHandler.handleError(err, {
-            operation: "initializeAndStartServer", // More specific operation
-            context: context, // Pass the existing context
-            critical: true, // This is a critical failure
-        });
-        logger.info("Exiting process due to critical initialization error.", context);
-        process.exit(1); // Exit with a non-zero code to indicate failure.
-    }
-}

package/dist/mcp-server/tools/obsidianDeleteNoteTool/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * @fileoverview Barrel file for the 'obsidian_delete_note' MCP tool.
- *
- * This file serves as the public entry point for the obsidian_delete_note tool module.
- * It re-exports the primary registration function (`registerObsidianDeleteNoteTool`)
- * from the './registration.js' module. This pattern simplifies imports for consumers
- * of the tool, allowing them to import necessary components from a single location.
- *
- * Consumers (like the main server setup) should import the registration function
- * from this file to integrate the tool into the MCP server instance.
- */
-export { registerObsidianDeleteNoteTool } from "./registration.js";

package/dist/mcp-server/tools/obsidianDeleteNoteTool/index.js

@@ -1,12 +0,0 @@
-/**
- * @fileoverview Barrel file for the 'obsidian_delete_note' MCP tool.
- *
- * This file serves as the public entry point for the obsidian_delete_note tool module.
- * It re-exports the primary registration function (`registerObsidianDeleteNoteTool`)
- * from the './registration.js' module. This pattern simplifies imports for consumers
- * of the tool, allowing them to import necessary components from a single location.
- *
- * Consumers (like the main server setup) should import the registration function
- * from this file to integrate the tool into the MCP server instance.
- */
-export { registerObsidianDeleteNoteTool } from "./registration.js";