@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.
208 lines (203 loc) • 24.7 kB
JavaScript
/**
* UnifiedEndpoint - Single unified MCP-AQL endpoint handler (Issue #196)
*
* This handler provides a single `mcp_aql` endpoint as an alternative to the
* 4 CRUD endpoints for users who want minimal token footprint (~300-400 tokens
* vs ~943 tokens for 4 endpoints).
*
* ARCHITECTURE:
* - Single entry point for all MCP-AQL operations
* - Routes internally to appropriate MCPAQLHandler methods
* - Uses Gatekeeper (PermissionGuard) for all permission checks
* - Maintains full security with minimal client-side footprint
*
* USE CASES:
* - Multi-server deployments where token budget is constrained
* - Clients that prefer simpler tool interfaces
* - Integration scenarios where 4 endpoints create complexity
*
* SECURITY:
* - All operations pass through PermissionGuard.validate()
* - Operation routing is determined server-side, not client-side
* - Full audit logging for all operations
*/
import { getRoute } from './OperationRouter.js';
import { isOperationInput, parseOperationInput, describeInvalidInput } from './types.js';
import { logger } from '../../utils/logger.js';
import { SecurityMonitor } from '../../security/securityMonitor.js';
/**
* UnifiedEndpoint - Single entry point for all MCP-AQL operations
*
* This class wraps MCPAQLHandler to provide a unified endpoint that
* automatically routes operations to the correct CRUD handler based
* on the operation name.
*
* SECURITY NOTE:
* Unlike the 4-endpoint mode where the client chooses which endpoint to call,
* in single-endpoint mode the server determines the appropriate handler
* based on the operation name. This means:
* 1. The client cannot bypass security by calling the wrong endpoint
* 2. All routing is enforced server-side via PermissionGuard
* 3. The operation-to-endpoint mapping is authoritative
*/
export class UnifiedEndpoint {
mcpAqlHandler;
constructor(mcpAqlHandler) {
this.mcpAqlHandler = mcpAqlHandler;
}
/**
* Handle any MCP-AQL operation through the unified endpoint.
*
* This method:
* 1. Validates input structure
* 2. Determines the correct CRUD endpoint for the operation
* 3. Routes to the appropriate handler method
* 4. Returns standardized OperationResult or BatchResult
*
* @param input - Operation input with operation name and params, or BatchRequest
* @returns OperationResult or BatchResult with success/failure status
*/
async handle(input) {
// Issue #301: Capture start time for response timing metadata
const startTime = performance.now();
// Extract operation name for logging (safe access before validation)
const operationName = isOperationInput(input) ? input.operation : 'unknown';
try {
// Step 1: Validate and normalize input structure (supports silent JSON fallback)
const parsedInput = parseOperationInput(input);
if (!parsedInput) {
return this.failure('Invalid input: expected OperationInput with operation name and optional params. ' +
describeInvalidInput(input), startTime);
}
const { operation } = parsedInput;
// Step 2: Determine the correct CRUD endpoint for this operation
const route = getRoute(operation);
if (!route) {
SecurityMonitor.logSecurityEvent({
type: 'UPDATE_SECURITY_VIOLATION',
severity: 'MEDIUM',
source: 'UnifiedEndpoint.handle',
details: `Unknown operation: "${operation}"`,
additionalData: { operation }
});
return this.failure(`Unknown operation: "${operation}". See tool description for available operations.`, startTime);
}
// Step 3: Route to the appropriate handler method
// The handler will perform its own PermissionGuard validation
// Pass parsedInput to ensure normalized format is used
const result = await this.routeToHandler(route.endpoint, parsedInput);
// Log successful routing
SecurityMonitor.logSecurityEvent({
type: 'ELEMENT_CREATED',
severity: 'LOW',
source: 'UnifiedEndpoint.handle',
details: `Operation '${operation}' routed to ${route.endpoint} handler`,
additionalData: { operation, endpoint: route.endpoint }
});
return result;
}
catch (error) {
const message = error instanceof Error ? error.message : String(error);
SecurityMonitor.logSecurityEvent({
type: 'UPDATE_SECURITY_VIOLATION',
severity: 'MEDIUM',
source: 'UnifiedEndpoint.handle',
details: `Operation '${operationName}' failed: ${message}`,
additionalData: { operation: operationName, error: message }
});
logger.error('UnifiedEndpoint operation failed', {
operation: operationName,
error: message,
stack: error instanceof Error ? error.stack : undefined,
});
return this.failure(message, startTime);
}
}
/**
* Route input to the appropriate CRUD handler based on endpoint type.
*
* @param endpoint - The CRUD endpoint determined from operation routing
* @param input - The validated operation input
* @returns OperationResult or BatchResult from the handler
*/
async routeToHandler(endpoint, input) {
switch (endpoint) {
case 'CREATE':
return this.mcpAqlHandler.handleCreate(input);
case 'READ':
return this.mcpAqlHandler.handleRead(input);
case 'UPDATE':
return this.mcpAqlHandler.handleUpdate(input);
case 'DELETE':
return this.mcpAqlHandler.handleDelete(input);
case 'EXECUTE':
return this.mcpAqlHandler.handleExecute(input);
default: {
// Exhaustive check - TypeScript will error if a case is missing
const _exhaustive = endpoint;
return _exhaustive;
}
}
}
/**
* Build response metadata with correlation ID and timing.
* Issue #301: Request correlation support.
*/
buildMeta(startTime) {
return {
requestId: this.mcpAqlHandler.getCorrelationId() ?? 'unknown',
durationMs: parseFloat((performance.now() - startTime).toFixed(2)),
timestamp: new Date().toISOString(),
};
}
/**
* Create a failed operation result
*/
failure(error, startTime) {
return {
success: false,
error,
_meta: this.buildMeta(startTime),
};
}
}
/**
* Get all available operations with their endpoint mappings.
* This is useful for documentation and help text.
*
* @returns Map of operation names to their CRUDE endpoints
*/
export function getOperationHelp() {
return `
## MCP-AQL Unified Endpoint Operations (CRUDE)
### CREATE Operations (additive, non-destructive)
- create_element: Create a new element
- import_element: Import an element from exported data
- addEntry: Add an entry to a memory element
- activate_element: Activate an element for use in session
### READ Operations (safe, read-only)
- list_elements: List elements with filtering and pagination
- get_element: Retrieve a single element by name
- get_element_details: Get detailed information about an element
- search_elements: Full-text search across elements
- query_elements: Query elements with advanced filters
- get_active_elements: Get currently active elements
- validate_element: Validate an element's structure
- render: Render a template with variables
- export_element: Export an element to portable format
- deactivate_element: Deactivate an active element
### UPDATE Operations (modifying)
- edit_element: Modify an existing element's fields
### DELETE Operations (destructive)
- delete_element: Permanently delete an element
- clear: Clear entries from a memory element
### EXECUTE Operations (runtime lifecycle, potentially destructive)
- execute_agent: Start execution of an agent
- get_execution_state: Query current execution state
- record_execution_step: Record execution progress
- complete_execution: Signal successful completion
- continue_execution: Resume from saved state
- abort_execution: Abort a running execution
`.trim();
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UnifiedEndpoint.js","sourceRoot":"","sources":["../../../src/handlers/mcp-aql/UnifiedEndpoint.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * UnifiedEndpoint - Single unified MCP-AQL endpoint handler (Issue #196)\n *\n * This handler provides a single `mcp_aql` endpoint as an alternative to the\n * 4 CRUD endpoints for users who want minimal token footprint (~300-400 tokens\n * vs ~943 tokens for 4 endpoints).\n *\n * ARCHITECTURE:\n * - Single entry point for all MCP-AQL operations\n * - Routes internally to appropriate MCPAQLHandler methods\n * - Uses Gatekeeper (PermissionGuard) for all permission checks\n * - Maintains full security with minimal client-side footprint\n *\n * USE CASES:\n * - Multi-server deployments where token budget is constrained\n * - Clients that prefer simpler tool interfaces\n * - Integration scenarios where 4 endpoints create complexity\n *\n * SECURITY:\n * - All operations pass through PermissionGuard.validate()\n * - Operation routing is determined server-side, not client-side\n * - Full audit logging for all operations\n */\n\nimport { MCPAQLHandler } from './MCPAQLHandler.js';\nimport { getRoute, CRUDEndpoint } from './OperationRouter.js';\nimport { OperationResult, BatchResult, ResponseMeta, isOperationInput, parseOperationInput, describeInvalidInput } from './types.js';\nimport { logger } from '../../utils/logger.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\n\n/**\n * UnifiedEndpoint - Single entry point for all MCP-AQL operations\n *\n * This class wraps MCPAQLHandler to provide a unified endpoint that\n * automatically routes operations to the correct CRUD handler based\n * on the operation name.\n *\n * SECURITY NOTE:\n * Unlike the 4-endpoint mode where the client chooses which endpoint to call,\n * in single-endpoint mode the server determines the appropriate handler\n * based on the operation name. This means:\n * 1. The client cannot bypass security by calling the wrong endpoint\n * 2. All routing is enforced server-side via PermissionGuard\n * 3. The operation-to-endpoint mapping is authoritative\n */\nexport class UnifiedEndpoint {\n  constructor(private readonly mcpAqlHandler: MCPAQLHandler) {}\n\n  /**\n   * Handle any MCP-AQL operation through the unified endpoint.\n   *\n   * This method:\n   * 1. Validates input structure\n   * 2. Determines the correct CRUD endpoint for the operation\n   * 3. Routes to the appropriate handler method\n   * 4. Returns standardized OperationResult or BatchResult\n   *\n   * @param input - Operation input with operation name and params, or BatchRequest\n   * @returns OperationResult or BatchResult with success/failure status\n   */\n  async handle(input: unknown): Promise<OperationResult | BatchResult> {\n    // Issue #301: Capture start time for response timing metadata\n    const startTime = performance.now();\n\n    // Extract operation name for logging (safe access before validation)\n    const operationName = isOperationInput(input) ? input.operation : 'unknown';\n\n    try {\n      // Step 1: Validate and normalize input structure (supports silent JSON fallback)\n      const parsedInput = parseOperationInput(input);\n      if (!parsedInput) {\n        return this.failure(\n          'Invalid input: expected OperationInput with operation name and optional params. ' +\n          describeInvalidInput(input),\n          startTime\n        );\n      }\n\n      const { operation } = parsedInput;\n\n      // Step 2: Determine the correct CRUD endpoint for this operation\n      const route = getRoute(operation);\n      if (!route) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'UPDATE_SECURITY_VIOLATION',\n          severity: 'MEDIUM',\n          source: 'UnifiedEndpoint.handle',\n          details: `Unknown operation: \"${operation}\"`,\n          additionalData: { operation }\n        });\n        return this.failure(\n          `Unknown operation: \"${operation}\". See tool description for available operations.`,\n          startTime\n        );\n      }\n\n      // Step 3: Route to the appropriate handler method\n      // The handler will perform its own PermissionGuard validation\n      // Pass parsedInput to ensure normalized format is used\n      const result = await this.routeToHandler(route.endpoint, parsedInput);\n\n      // Log successful routing\n      SecurityMonitor.logSecurityEvent({\n        type: 'ELEMENT_CREATED',\n        severity: 'LOW',\n        source: 'UnifiedEndpoint.handle',\n        details: `Operation '${operation}' routed to ${route.endpoint} handler`,\n        additionalData: { operation, endpoint: route.endpoint }\n      });\n\n      return result;\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n\n      SecurityMonitor.logSecurityEvent({\n        type: 'UPDATE_SECURITY_VIOLATION',\n        severity: 'MEDIUM',\n        source: 'UnifiedEndpoint.handle',\n        details: `Operation '${operationName}' failed: ${message}`,\n        additionalData: { operation: operationName, error: message }\n      });\n\n      logger.error('UnifiedEndpoint operation failed', {\n        operation: operationName,\n        error: message,\n        stack: error instanceof Error ? error.stack : undefined,\n      });\n\n      return this.failure(message, startTime);\n    }\n  }\n\n  /**\n   * Route input to the appropriate CRUD handler based on endpoint type.\n   *\n   * @param endpoint - The CRUD endpoint determined from operation routing\n   * @param input - The validated operation input\n   * @returns OperationResult or BatchResult from the handler\n   */\n  private async routeToHandler(\n    endpoint: CRUDEndpoint,\n    input: unknown\n  ): Promise<OperationResult | BatchResult> {\n    switch (endpoint) {\n      case 'CREATE':\n        return this.mcpAqlHandler.handleCreate(input);\n      case 'READ':\n        return this.mcpAqlHandler.handleRead(input);\n      case 'UPDATE':\n        return this.mcpAqlHandler.handleUpdate(input);\n      case 'DELETE':\n        return this.mcpAqlHandler.handleDelete(input);\n      case 'EXECUTE':\n        return this.mcpAqlHandler.handleExecute(input);\n      default: {\n        // Exhaustive check - TypeScript will error if a case is missing\n        const _exhaustive: never = endpoint;\n        return _exhaustive;\n      }\n    }\n  }\n\n  /**\n   * Build response metadata with correlation ID and timing.\n   * Issue #301: Request correlation support.\n   */\n  private buildMeta(startTime: number): ResponseMeta {\n    return {\n      requestId: this.mcpAqlHandler.getCorrelationId() ?? 'unknown',\n      durationMs: parseFloat((performance.now() - startTime).toFixed(2)),\n      timestamp: new Date().toISOString(),\n    };\n  }\n\n  /**\n   * Create a failed operation result\n   */\n  private failure(error: string, startTime: number): OperationResult {\n    return {\n      success: false,\n      error,\n      _meta: this.buildMeta(startTime),\n    };\n  }\n}\n\n/**\n * Get all available operations with their endpoint mappings.\n * This is useful for documentation and help text.\n *\n * @returns Map of operation names to their CRUDE endpoints\n */\nexport function getOperationHelp(): string {\n  return `\n## MCP-AQL Unified Endpoint Operations (CRUDE)\n\n### CREATE Operations (additive, non-destructive)\n- create_element: Create a new element\n- import_element: Import an element from exported data\n- addEntry: Add an entry to a memory element\n- activate_element: Activate an element for use in session\n\n### READ Operations (safe, read-only)\n- list_elements: List elements with filtering and pagination\n- get_element: Retrieve a single element by name\n- get_element_details: Get detailed information about an element\n- search_elements: Full-text search across elements\n- query_elements: Query elements with advanced filters\n- get_active_elements: Get currently active elements\n- validate_element: Validate an element's structure\n- render: Render a template with variables\n- export_element: Export an element to portable format\n- deactivate_element: Deactivate an active element\n\n### UPDATE Operations (modifying)\n- edit_element: Modify an existing element's fields\n\n### DELETE Operations (destructive)\n- delete_element: Permanently delete an element\n- clear: Clear entries from a memory element\n\n### EXECUTE Operations (runtime lifecycle, potentially destructive)\n- execute_agent: Start execution of an agent\n- get_execution_state: Query current execution state\n- record_execution_step: Record execution progress\n- complete_execution: Signal successful completion\n- continue_execution: Resume from saved state\n- abort_execution: Abort a running execution\n`.trim();\n}\n"]}