@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
97 lines • 13.7 kB
JavaScript
/**
* ResourceHandler - Manages MCP Resources capability
*
* Handles registration and serving of MCP resources including:
* - Capability Index (summary, full, stats variants)
*
* Uses dependency injection pattern consistent with refactored architecture.
* Resources are disabled by default and require explicit configuration.
*/
import { ListResourcesRequestSchema, ReadResourceRequestSchema, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
import { CapabilityIndexResource } from '../server/resources/CapabilityIndexResource.js';
import { logger } from '../utils/logger.js';
import { ErrorHandler } from '../utils/ErrorHandler.js';
import { FileOperationsService } from '../services/FileOperationsService.js';
import { FileLockManager } from '../security/fileLockManager.js';
/**
* Handler for MCP Resources protocol
*/
export class ResourceHandler {
configManager;
capabilityIndexResource;
isEnabled = false;
enabledVariants = [];
constructor(configManager) {
this.configManager = configManager;
}
/**
* Initialize and register resource handlers with the MCP server
*
* This method:
* 1. Checks configuration to see if resources are enabled
* 2. Initializes the CapabilityIndexResource
* 3. Registers ListResourcesRequest and ReadResourceRequest handlers
*
* @param server - MCP Server instance to register handlers with
*/
async initialize(server) {
try {
// Check if resources are enabled in configuration
const resourcesConfig = this.configManager.getSetting('elements.enhanced_index.resources');
if (!resourcesConfig?.advertise_resources) {
logger.info('[ResourceHandler] MCP Resources disabled (future-proof implementation, opt-in required)');
return;
}
// Resources are enabled
this.isEnabled = true;
// Initialize resource handler with FileOperationsService
const fileLockManager = new FileLockManager();
const fileOperations = new FileOperationsService(fileLockManager);
this.capabilityIndexResource = new CapabilityIndexResource(fileOperations);
// Determine which variants are enabled
if (resourcesConfig.variants?.summary)
this.enabledVariants.push('summary');
if (resourcesConfig.variants?.full)
this.enabledVariants.push('full');
if (resourcesConfig.variants?.stats)
this.enabledVariants.push('stats');
logger.info(`[ResourceHandler] MCP Resources enabled: capability-index (variants: ${this.enabledVariants.join(', ') || 'none'})`);
// Register ListResourcesRequest handler
server.setRequestHandler(ListResourcesRequestSchema, async () => {
if (!this.capabilityIndexResource) {
throw new McpError(ErrorCode.InternalError, 'Resource handler not initialized');
}
const result = await this.capabilityIndexResource.listResources();
return result; // Type assertion needed for MCP SDK compatibility
});
// Register ReadResourceRequest handler
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
if (!this.capabilityIndexResource) {
throw new McpError(ErrorCode.InternalError, 'Resource handler not initialized');
}
const result = await this.capabilityIndexResource.readResource(request.params.uri);
return result; // Type assertion needed for MCP SDK compatibility
});
logger.debug('[ResourceHandler] MCP resource handlers registered successfully');
}
catch (error) {
ErrorHandler.logError('ResourceHandler.initialize', error);
// Don't throw - resource setup failures shouldn't prevent server startup
logger.warn('[ResourceHandler] Failed to setup MCP resource handlers, continuing without resources');
this.isEnabled = false;
}
}
/**
* Check if resources are currently enabled
*/
getIsEnabled() {
return this.isEnabled;
}
/**
* Get list of enabled resource variants
*/
getEnabledVariants() {
return [...this.enabledVariants];
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ResourceHandler.js","sourceRoot":"","sources":["../../src/handlers/ResourceHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ResourceHandler - Manages MCP Resources capability\n *\n * Handles registration and serving of MCP resources including:\n * - Capability Index (summary, full, stats variants)\n *\n * Uses dependency injection pattern consistent with refactored architecture.\n * Resources are disabled by default and require explicit configuration.\n */\n\nimport { Server } from \"@modelcontextprotocol/sdk/server/index.js\";\nimport { ListResourcesRequestSchema, ReadResourceRequestSchema, ErrorCode, McpError } from \"@modelcontextprotocol/sdk/types.js\";\nimport { CapabilityIndexResource } from '../server/resources/CapabilityIndexResource.js';\nimport { ConfigManager } from '../config/ConfigManager.js';\nimport { logger } from '../utils/logger.js';\nimport { ErrorHandler } from '../utils/ErrorHandler.js';\nimport { FileOperationsService } from '../services/FileOperationsService.js';\nimport { FileLockManager } from '../security/fileLockManager.js';\n\n/**\n * Handler for MCP Resources protocol\n */\nexport class ResourceHandler {\n  private capabilityIndexResource?: CapabilityIndexResource;\n  private isEnabled: boolean = false;\n  private enabledVariants: string[] = [];\n\n  constructor(\n    private readonly configManager: ConfigManager\n  ) {}\n\n  /**\n   * Initialize and register resource handlers with the MCP server\n   *\n   * This method:\n   * 1. Checks configuration to see if resources are enabled\n   * 2. Initializes the CapabilityIndexResource\n   * 3. Registers ListResourcesRequest and ReadResourceRequest handlers\n   *\n   * @param server - MCP Server instance to register handlers with\n   */\n  async initialize(server: Server): Promise<void> {\n    try {\n      // Check if resources are enabled in configuration\n      const resourcesConfig = this.configManager.getSetting<any>('elements.enhanced_index.resources');\n\n      if (!resourcesConfig?.advertise_resources) {\n        logger.info('[ResourceHandler] MCP Resources disabled (future-proof implementation, opt-in required)');\n        return;\n      }\n\n      // Resources are enabled\n      this.isEnabled = true;\n\n      // Initialize resource handler with FileOperationsService\n      const fileLockManager = new FileLockManager();\n      const fileOperations = new FileOperationsService(fileLockManager);\n      this.capabilityIndexResource = new CapabilityIndexResource(fileOperations);\n\n      // Determine which variants are enabled\n      if (resourcesConfig.variants?.summary) this.enabledVariants.push('summary');\n      if (resourcesConfig.variants?.full) this.enabledVariants.push('full');\n      if (resourcesConfig.variants?.stats) this.enabledVariants.push('stats');\n\n      logger.info(`[ResourceHandler] MCP Resources enabled: capability-index (variants: ${this.enabledVariants.join(', ') || 'none'})`);\n\n      // Register ListResourcesRequest handler\n      server.setRequestHandler(ListResourcesRequestSchema, async () => {\n        if (!this.capabilityIndexResource) {\n          throw new McpError(ErrorCode.InternalError, 'Resource handler not initialized');\n        }\n        const result = await this.capabilityIndexResource.listResources();\n        return result as any; // Type assertion needed for MCP SDK compatibility\n      });\n\n      // Register ReadResourceRequest handler\n      server.setRequestHandler(ReadResourceRequestSchema, async (request) => {\n        if (!this.capabilityIndexResource) {\n          throw new McpError(ErrorCode.InternalError, 'Resource handler not initialized');\n        }\n        const result = await this.capabilityIndexResource.readResource(request.params.uri);\n        return result as any; // Type assertion needed for MCP SDK compatibility\n      });\n\n      logger.debug('[ResourceHandler] MCP resource handlers registered successfully');\n    } catch (error) {\n      ErrorHandler.logError('ResourceHandler.initialize', error);\n      // Don't throw - resource setup failures shouldn't prevent server startup\n      logger.warn('[ResourceHandler] Failed to setup MCP resource handlers, continuing without resources');\n      this.isEnabled = false;\n    }\n  }\n\n  /**\n   * Check if resources are currently enabled\n   */\n  getIsEnabled(): boolean {\n    return this.isEnabled;\n  }\n\n  /**\n   * Get list of enabled resource variants\n   */\n  getEnabledVariants(): string[] {\n    return [...this.enabledVariants];\n  }\n}\n"]}