@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.
217 lines • 30.1 kB
JavaScript
/**
* Server setup and initialization
*/
import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
// import { getUserTools } from './tools/UserTools.js'; // DEPRECATED - replaced by dollhouse_config
// import { getConfigTools } from './tools/ConfigTools.js'; // DEPRECATED - replaced by dollhouse_config
import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
import { SecurityMonitor } from '../security/securityMonitor.js';
import { logger } from '../utils/logger.js';
import { LRUCache } from '../cache/LRUCache.js';
import { getValidatedToolCacheTTL } from '../config/performance-constants.js';
import { generatePrescriptiveDigest } from './PrescriptiveDigest.js';
// ConfigWizardCheck import removed - auto-trigger disabled for v1.8.0
export class ServerSetup {
static TOOL_CACHE_KEY = 'tool_discovery_list';
/** Issue #706: Max ms to wait for deferred setup before proceeding anyway. */
static DEFERRED_SETUP_TIMEOUT_MS = 10_000;
toolCache;
contextTracker;
elementCrudHandler = null;
/** Issue #706 Phase 4: Promise that resolves when deferred setup completes. */
deferredSetupPromise = null;
constructor(contextTracker) {
this.contextTracker = contextTracker;
this.toolCache = new LRUCache({
name: 'tool-discovery',
maxSize: 1,
maxMemoryMB: 5,
ttlMs: getValidatedToolCacheTTL(),
});
}
/**
* Issue #706 Phase 4: Set the deferred setup promise for request buffering.
* First request after connect holds briefly until deferred setup completes
* (or the timeout fires). Subsequent requests proceed immediately.
*/
setDeferredSetupPromise(promise) {
this.deferredSetupPromise = promise;
// Auto-clear when resolved so subsequent requests skip the check
promise.then(() => { this.deferredSetupPromise = null; })
.catch(() => { this.deferredSetupPromise = null; });
}
/**
* Issue #706 Phase 4: Wait for deferred setup with a hard timeout.
* No-op if already resolved or never set.
*/
async awaitDeferredSetup() {
if (!this.deferredSetupPromise)
return;
const timeout = new Promise(resolve => setTimeout(resolve, ServerSetup.DEFERRED_SETUP_TIMEOUT_MS));
await Promise.race([this.deferredSetupPromise, timeout]);
this.deferredSetupPromise = null;
}
/**
* Initialize the server with all tools and handlers
*/
setupServer(server, toolRegistry, elementCrudHandler) {
this.elementCrudHandler = elementCrudHandler ?? null;
// Setup request handlers
this.setupListToolsHandler(server, toolRegistry);
this.setupCallToolHandler(server, toolRegistry);
}
/**
* Setup the ListToolsRequest handler with caching
*/
setupListToolsHandler(server, toolRegistry) {
server.setRequestHandler(ListToolsRequestSchema, async () => {
const startTime = Date.now();
// Try to get cached tools first
let tools = this.toolCache.get(ServerSetup.TOOL_CACHE_KEY);
if (!tools) {
// Cache miss - fetch tools from registry
tools = toolRegistry.getAllTools();
// Cache the results for future requests
this.toolCache.set(ServerSetup.TOOL_CACHE_KEY, tools);
const duration = Date.now() - startTime;
logger.info('ToolDiscoveryCache: Cache miss - fetched and cached tools', {
toolCount: tools.length,
duration: `${duration}ms`,
source: 'registry'
});
}
else {
const duration = Date.now() - startTime;
logger.debug('ToolDiscoveryCache: Cache hit - returned cached tools', {
toolCount: tools.length,
duration: `${duration}ms`,
source: 'cache'
});
}
return { tools };
});
}
/**
* Setup the CallToolRequest handler
*/
setupCallToolHandler(server, toolRegistry) {
server.setRequestHandler(CallToolRequestSchema, async (request) => {
// Issue #706 Phase 4: Hold first request(s) until deferred setup completes
await this.awaitDeferredSetup();
const context = this.contextTracker.createContext('llm-request', {
toolName: request.params.name,
});
return this.contextTracker.runAsync(context, async () => {
const { name, arguments: args } = request.params;
try {
const handler = toolRegistry.getHandler(name);
if (!handler) {
throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
}
// Normalize Unicode in all string arguments to prevent security bypasses
const normalizedArgs = this.normalizeArgumentsUnicode(args, name);
const response = await handler(normalizedArgs);
// Issue #492: Prescriptive digest for active element context recovery.
// After context compaction, the LLM loses active element instructions.
// This digest tells it how to recover them.
if (this.elementCrudHandler && name !== 'get_active_elements') {
try {
const activeElements = await this.elementCrudHandler.getActiveElementsForPolicy();
if (activeElements.length > 0) {
const digest = generatePrescriptiveDigest(activeElements);
if (response?.content?.[0]?.type === 'text') {
response.content[0].text += '\n\n' + digest;
}
}
}
catch {
// Best-effort — never fail a tool response for the digest
}
}
return response;
}
catch (error) {
if (error instanceof McpError) {
throw error;
}
throw new McpError(ErrorCode.InternalError, `Error executing tool ${name}: ${error}`);
}
});
});
}
/**
* Recursively normalize Unicode in all string values within arguments
*/
normalizeArgumentsUnicode(args, toolName) {
if (args === null || args === undefined) {
return args;
}
if (typeof args === 'string') {
const result = UnicodeValidator.normalize(args);
if (result.detectedIssues && result.detectedIssues.length > 0) {
logger.warn(`Unicode security issues detected in tool ${toolName}:`, {
issues: result.detectedIssues,
severity: result.severity
});
}
return result.normalizedContent;
}
if (Array.isArray(args)) {
return args.map(item => this.normalizeArgumentsUnicode(item, toolName));
}
if (typeof args === 'object') {
const normalized = {};
for (const [key, value] of Object.entries(args)) {
// Normalize both keys and values to prevent Unicode attacks in property names
const normalizedKey = typeof key === 'string' ?
UnicodeValidator.normalize(key).normalizedContent : key;
normalized[normalizedKey] = this.normalizeArgumentsUnicode(value, toolName);
}
return normalized;
}
// For non-string primitive types, return as-is
return args;
}
/**
* Get the tool discovery cache
*/
getToolCache() {
return this.toolCache;
}
/**
* Invalidate the tool discovery cache (useful for external tool changes)
*/
invalidateToolCache() {
this.toolCache.delete(ServerSetup.TOOL_CACHE_KEY);
logger.info('ToolDiscoveryCache: Cache manually invalidated');
// Log security event for audit trail
SecurityMonitor.logSecurityEvent({
type: 'TOOL_CACHE_INVALIDATED',
severity: 'LOW',
source: 'ServerSetup.invalidateToolCache',
details: 'Tool discovery cache manually invalidated'
});
}
/**
* Log current cache performance metrics
*/
logCachePerformance() {
const stats = this.toolCache.getStats();
logger.info('ToolDiscoveryCache: Performance metrics', {
hitRate: `${(stats.hitRate * 100).toFixed(1)}%`,
hits: stats.hitCount,
misses: stats.missCount,
cacheSize: stats.size,
efficiency: stats.hitCount > 0 ? 'GOOD' : 'NEEDS_WARMUP'
});
}
/**
* Get cache statistics for monitoring
*/
getCacheStatistics() {
return {
toolCache: this.toolCache.getStats()
};
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ServerSetup.js","sourceRoot":"","sources":["../../src/server/ServerSetup.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Server setup and initialization\n */\n\nimport { Server } from \"@modelcontextprotocol/sdk/server/index.js\";\nimport { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from \"@modelcontextprotocol/sdk/types.js\";\nimport { ToolRegistry } from '../handlers/ToolRegistry.js';\n// import { getUserTools } from './tools/UserTools.js'; // DEPRECATED - replaced by dollhouse_config\n// import { getConfigTools } from './tools/ConfigTools.js'; // DEPRECATED - replaced by dollhouse_config\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { logger } from '../utils/logger.js';\nimport { LRUCache } from '../cache/LRUCache.js';\nimport { getValidatedToolCacheTTL } from '../config/performance-constants.js';\nimport { generatePrescriptiveDigest } from './PrescriptiveDigest.js';\nimport type { Tool } from \"@modelcontextprotocol/sdk/types.js\";\nimport type { ContextTracker } from '../security/encryption/ContextTracker.js';\nimport type { ElementCRUDHandler } from '../handlers/ElementCRUDHandler.js';\n// ConfigWizardCheck import removed - auto-trigger disabled for v1.8.0\n\nexport class ServerSetup {\n  private static readonly TOOL_CACHE_KEY = 'tool_discovery_list';\n  /** Issue #706: Max ms to wait for deferred setup before proceeding anyway. */\n  private static readonly DEFERRED_SETUP_TIMEOUT_MS = 10_000;\n  private toolCache: LRUCache<Tool[]>;\n  private contextTracker: ContextTracker;\n  private elementCrudHandler: ElementCRUDHandler | null = null;\n  /** Issue #706 Phase 4: Promise that resolves when deferred setup completes. */\n  private deferredSetupPromise: Promise<void> | null = null;\n\n  constructor(contextTracker: ContextTracker) {\n    this.contextTracker = contextTracker;\n    this.toolCache = new LRUCache<Tool[]>({\n      name: 'tool-discovery',\n      maxSize: 1,\n      maxMemoryMB: 5,\n      ttlMs: getValidatedToolCacheTTL(),\n    });\n  }\n\n  /**\n   * Issue #706 Phase 4: Set the deferred setup promise for request buffering.\n   * First request after connect holds briefly until deferred setup completes\n   * (or the timeout fires). Subsequent requests proceed immediately.\n   */\n  setDeferredSetupPromise(promise: Promise<void>): void {\n    this.deferredSetupPromise = promise;\n    // Auto-clear when resolved so subsequent requests skip the check\n    promise.then(() => { this.deferredSetupPromise = null; })\n      .catch(() => { this.deferredSetupPromise = null; });\n  }\n\n  /**\n   * Issue #706 Phase 4: Wait for deferred setup with a hard timeout.\n   * No-op if already resolved or never set.\n   */\n  private async awaitDeferredSetup(): Promise<void> {\n    if (!this.deferredSetupPromise) return;\n    const timeout = new Promise<void>(resolve =>\n      setTimeout(resolve, ServerSetup.DEFERRED_SETUP_TIMEOUT_MS)\n    );\n    await Promise.race([this.deferredSetupPromise, timeout]);\n    this.deferredSetupPromise = null;\n  }\n\n  /**\n   * Initialize the server with all tools and handlers\n   */\n  setupServer(server: Server, toolRegistry: ToolRegistry, elementCrudHandler?: ElementCRUDHandler): void {\n    this.elementCrudHandler = elementCrudHandler ?? null;\n\n    // Setup request handlers\n    this.setupListToolsHandler(server, toolRegistry);\n    this.setupCallToolHandler(server, toolRegistry);\n  }\n  \n  /**\n   * Setup the ListToolsRequest handler with caching\n   */\n  private setupListToolsHandler(server: Server, toolRegistry: ToolRegistry): void {\n    server.setRequestHandler(ListToolsRequestSchema, async () => {\n      const startTime = Date.now();\n      \n      // Try to get cached tools first\n      let tools = this.toolCache.get(ServerSetup.TOOL_CACHE_KEY);\n\n      if (!tools) {\n        // Cache miss - fetch tools from registry\n        tools = toolRegistry.getAllTools();\n\n        // Cache the results for future requests\n        this.toolCache.set(ServerSetup.TOOL_CACHE_KEY, tools);\n\n        const duration = Date.now() - startTime;\n        logger.info('ToolDiscoveryCache: Cache miss - fetched and cached tools', {\n          toolCount: tools.length,\n          duration: `${duration}ms`,\n          source: 'registry'\n        });\n      } else {\n        const duration = Date.now() - startTime;\n        logger.debug('ToolDiscoveryCache: Cache hit - returned cached tools', {\n          toolCount: tools.length,\n          duration: `${duration}ms`,\n          source: 'cache'\n        });\n      }\n      \n      return { tools };\n    });\n  }\n  \n  /**\n   * Setup the CallToolRequest handler\n   */\n  private setupCallToolHandler(server: Server, toolRegistry: ToolRegistry): void {\n    server.setRequestHandler(CallToolRequestSchema, async (request) => {\n      // Issue #706 Phase 4: Hold first request(s) until deferred setup completes\n      await this.awaitDeferredSetup();\n\n      const context = this.contextTracker.createContext('llm-request', {\n        toolName: request.params.name,\n      });\n      return this.contextTracker.runAsync(context, async () => {\n        const { name, arguments: args } = request.params;\n\n        try {\n          const handler = toolRegistry.getHandler(name);\n\n          if (!handler) {\n            throw new McpError(\n              ErrorCode.MethodNotFound,\n              `Unknown tool: ${name}`\n            );\n          }\n\n          // Normalize Unicode in all string arguments to prevent security bypasses\n          const normalizedArgs = this.normalizeArgumentsUnicode(args, name);\n\n          const response = await handler(normalizedArgs);\n\n          // Issue #492: Prescriptive digest for active element context recovery.\n          // After context compaction, the LLM loses active element instructions.\n          // This digest tells it how to recover them.\n          if (this.elementCrudHandler && name !== 'get_active_elements') {\n            try {\n              const activeElements = await this.elementCrudHandler.getActiveElementsForPolicy();\n              if (activeElements.length > 0) {\n                const digest = generatePrescriptiveDigest(activeElements);\n                if (response?.content?.[0]?.type === 'text') {\n                  response.content[0].text += '\\n\\n' + digest;\n                }\n              }\n            } catch {\n              // Best-effort — never fail a tool response for the digest\n            }\n          }\n\n          return response;\n        } catch (error) {\n          if (error instanceof McpError) {\n            throw error;\n          }\n\n          throw new McpError(\n            ErrorCode.InternalError,\n            `Error executing tool ${name}: ${error}`\n          );\n        }\n      });\n    });\n  }\n  \n  /**\n   * Recursively normalize Unicode in all string values within arguments\n   */\n  private normalizeArgumentsUnicode(args: any, toolName: string): any {\n    if (args === null || args === undefined) {\n      return args;\n    }\n    \n    if (typeof args === 'string') {\n      const result = UnicodeValidator.normalize(args);\n      if (result.detectedIssues && result.detectedIssues.length > 0) {\n        logger.warn(`Unicode security issues detected in tool ${toolName}:`, {\n          issues: result.detectedIssues,\n          severity: result.severity\n        });\n      }\n      return result.normalizedContent;\n    }\n    \n    if (Array.isArray(args)) {\n      return args.map(item => this.normalizeArgumentsUnicode(item, toolName));\n    }\n    \n    if (typeof args === 'object') {\n      const normalized: any = {};\n      for (const [key, value] of Object.entries(args)) {\n        // Normalize both keys and values to prevent Unicode attacks in property names\n        const normalizedKey = typeof key === 'string' ? \n          UnicodeValidator.normalize(key).normalizedContent : key;\n        normalized[normalizedKey] = this.normalizeArgumentsUnicode(value, toolName);\n      }\n      return normalized;\n    }\n    \n    // For non-string primitive types, return as-is\n    return args;\n  }\n  \n  /**\n   * Get the tool discovery cache\n   */\n  getToolCache(): LRUCache<Tool[]> {\n    return this.toolCache;\n  }\n\n  /**\n   * Invalidate the tool discovery cache (useful for external tool changes)\n   */\n  invalidateToolCache(): void {\n    this.toolCache.delete(ServerSetup.TOOL_CACHE_KEY);\n    logger.info('ToolDiscoveryCache: Cache manually invalidated');\n\n    // Log security event for audit trail\n    SecurityMonitor.logSecurityEvent({\n      type: 'TOOL_CACHE_INVALIDATED',\n      severity: 'LOW',\n      source: 'ServerSetup.invalidateToolCache',\n      details: 'Tool discovery cache manually invalidated'\n    });\n  }\n\n  /**\n   * Log current cache performance metrics\n   */\n  logCachePerformance(): void {\n    const stats = this.toolCache.getStats();\n    logger.info('ToolDiscoveryCache: Performance metrics', {\n      hitRate: `${(stats.hitRate * 100).toFixed(1)}%`,\n      hits: stats.hitCount,\n      misses: stats.missCount,\n      cacheSize: stats.size,\n      efficiency: stats.hitCount > 0 ? 'GOOD' : 'NEEDS_WARMUP'\n    });\n  }\n\n  /**\n   * Get cache statistics for monitoring\n   */\n  getCacheStatistics() {\n    return {\n      toolCache: this.toolCache.getStats()\n    };\n  }\n}"]}