@dollhousemcp/mcp-server 1.7.3 → 1.7.4

package/dist/utils/TemplateRenderer.js

@@ -0,0 +1,154 @@
+/**
+ * TemplateRenderer - Utility class for rendering templates with comprehensive validation
+ *
+ * IMPROVEMENTS IMPLEMENTED (per Debug Detective recommendations):
+ * 1. instanceof Template verification for type safety
+ * 2. Performance logging to track render times
+ * 3. Validation of render() return value
+ * 4. Clear separation of concerns from index.ts
+ *
+ * This addresses Issues #913 and #914 from the v1.7.3 hotfix
+ */
+import { Template } from '../elements/templates/Template.js';
+import { logger } from '../utils/logger.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+export class TemplateRenderer {
+    templateManager;
+    constructor(templateManager) {
+        this.templateManager = templateManager;
+    }
+    /**
+     * Render a template with comprehensive validation and performance tracking
+     *
+     * VALIDATION CHAIN:
+     * 1. Unicode normalization of template name
+     * 2. Template exists in manager
+     * 3. Template is proper Template instance
+     * 4. Template has render() method
+     * 5. render() returns a string
+     *
+     * SECURITY:
+     * - Unicode normalization prevents homograph attacks
+     * - Variables are normalized by Template.render() internally
+     *
+     * PERFORMANCE TRACKING:
+     * - Lookup time (finding template)
+     * - Render time (actual rendering)
+     * - Total time (complete operation)
+     */
+    async render(name, variables = {}) {
+        const startTime = performance.now();
+        try {
+            // SECURITY: Normalize template name to prevent Unicode attacks
+            const normalizedName = UnicodeValidator.normalize(name).normalizedContent;
+            // STEP 1: Find template with performance tracking
+            const lookupStart = performance.now();
+            const template = await this.templateManager.find(t => t.metadata.name === normalizedName);
+            const lookupTime = performance.now() - lookupStart;
+            logger.debug(`Template lookup for '${normalizedName}' completed in ${lookupTime.toFixed(2)}ms`);
+            // VALIDATION 1: Template exists
+            if (!template) {
+                const totalTime = performance.now() - startTime;
+                logger.warn(`Template '${normalizedName}' not found after ${lookupTime.toFixed(2)}ms lookup`);
+                return {
+                    success: false,
+                    error: `Template '${normalizedName}' not found`,
+                    performance: { lookupTime, renderTime: 0, totalTime }
+                };
+            }
+            // VALIDATION 2: Verify template is proper Template instance with render method
+            if (!(template instanceof Template) || typeof template.render !== 'function') {
+                const totalTime = performance.now() - startTime;
+                const isInstance = template instanceof Template;
+                const hasRender = typeof template?.render === 'function';
+                logger.error(`Template '${normalizedName}' validation failed. ` +
+                    `Is Template instance: ${isInstance}, Has render method: ${hasRender}`);
+                return {
+                    success: false,
+                    error: `Template '${normalizedName}' is not a valid Template instance`,
+                    performance: { lookupTime, renderTime: 0, totalTime }
+                };
+            }
+            // STEP 2: Render template with performance tracking
+            // Note: Template.render() internally handles Unicode normalization for variables
+            logger.debug(`Starting render for template '${normalizedName}': ` +
+                `variables=${JSON.stringify(Object.keys(variables))}, template.id=${template.id}`);
+            const renderStart = performance.now();
+            const rendered = await template.render(variables);
+            const renderTime = performance.now() - renderStart;
+            // VALIDATION 3: Verify render() returned a string
+            if (typeof rendered !== 'string') {
+                const totalTime = performance.now() - startTime;
+                logger.error(`Template '${normalizedName}' render() returned non-string: ${typeof rendered}`);
+                return {
+                    success: false,
+                    error: `Template render failed: invalid return type (${typeof rendered})`,
+                    performance: { lookupTime, renderTime, totalTime }
+                };
+            }
+            // SUCCESS: Log performance metrics
+            const totalTime = performance.now() - startTime;
+            logger.info(`Template '${normalizedName}' rendered successfully: ` +
+                `lookup=${lookupTime.toFixed(2)}ms, ` +
+                `render=${renderTime.toFixed(2)}ms, ` +
+                `total=${totalTime.toFixed(2)}ms, ` +
+                `output_length=${rendered.length}`);
+            return {
+                success: true,
+                content: rendered,
+                performance: { lookupTime, renderTime, totalTime }
+            };
+        }
+        catch (error) {
+            const totalTime = performance.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            // Use original name in error message for clarity
+            logger.error(`Failed to render template '${name}' after ${totalTime.toFixed(2)}ms:`, error);
+            return {
+                success: false,
+                error: `Failed to render template: ${errorMessage}`,
+                performance: { lookupTime: 0, renderTime: 0, totalTime }
+            };
+        }
+    }
+    /**
+     * Batch render multiple templates (useful for testing)
+     * SECURITY: Each template name is normalized individually
+     */
+    async renderBatch(templates) {
+        const results = new Map();
+        for (const { name, variables } of templates) {
+            // Each render call handles its own Unicode normalization
+            results.set(name, await this.render(name, variables));
+        }
+        return results;
+    }
+    /**
+     * Validate that a template can be rendered without actually rendering it
+     * SECURITY: Template name is normalized to prevent Unicode attacks
+     */
+    async validate(name) {
+        try {
+            // SECURITY: Normalize template name
+            const normalizedName = UnicodeValidator.normalize(name).normalizedContent;
+            const template = await this.templateManager.find(t => t.metadata.name === normalizedName);
+            if (!template) {
+                return { valid: false, reason: 'Template not found' };
+            }
+            if (!(template instanceof Template)) {
+                return { valid: false, reason: 'Not a valid Template instance' };
+            }
+            if (typeof template.render !== 'function') {
+                return { valid: false, reason: 'Missing render method' };
+            }
+            return { valid: true };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                reason: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TemplateRenderer.js","sourceRoot":"","sources":["../../src/utils/TemplateRenderer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TemplateRenderer - Utility class for rendering templates with comprehensive validation\n * \n * IMPROVEMENTS IMPLEMENTED (per Debug Detective recommendations):\n * 1. instanceof Template verification for type safety\n * 2. Performance logging to track render times\n * 3. Validation of render() return value\n * 4. Clear separation of concerns from index.ts\n * \n * This addresses Issues #913 and #914 from the v1.7.3 hotfix\n */\n\nimport { Template } from '../elements/templates/Template.js';\nimport { TemplateManager } from '../elements/templates/TemplateManager.js';\nimport { logger } from '../utils/logger.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\n\nexport interface RenderResult {\n  success: boolean;\n  content?: string;\n  error?: string;\n  performance?: {\n    lookupTime: number;\n    renderTime: number;\n    totalTime: number;\n  };\n}\n\nexport class TemplateRenderer {\n  constructor(private templateManager: TemplateManager) {}\n\n  /**\n   * Render a template with comprehensive validation and performance tracking\n   * \n   * VALIDATION CHAIN:\n   * 1. Unicode normalization of template name\n   * 2. Template exists in manager\n   * 3. Template is proper Template instance\n   * 4. Template has render() method\n   * 5. render() returns a string\n   * \n   * SECURITY:\n   * - Unicode normalization prevents homograph attacks\n   * - Variables are normalized by Template.render() internally\n   * \n   * PERFORMANCE TRACKING:\n   * - Lookup time (finding template)\n   * - Render time (actual rendering)\n   * - Total time (complete operation)\n   */\n  async render(name: string, variables: Record<string, any> = {}): Promise<RenderResult> {\n    const startTime = performance.now();\n    \n    try {\n      // SECURITY: Normalize template name to prevent Unicode attacks\n      const normalizedName = UnicodeValidator.normalize(name).normalizedContent;\n      \n      // STEP 1: Find template with performance tracking\n      const lookupStart = performance.now();\n      const template = await this.templateManager.find(t => t.metadata.name === normalizedName);\n      const lookupTime = performance.now() - lookupStart;\n      \n      logger.debug(`Template lookup for '${normalizedName}' completed in ${lookupTime.toFixed(2)}ms`);\n      \n      // VALIDATION 1: Template exists\n      if (!template) {\n        const totalTime = performance.now() - startTime;\n        logger.warn(`Template '${normalizedName}' not found after ${lookupTime.toFixed(2)}ms lookup`);\n        \n        return {\n          success: false,\n          error: `Template '${normalizedName}' not found`,\n          performance: { lookupTime, renderTime: 0, totalTime }\n        };\n      }\n      \n      // VALIDATION 2: Verify template is proper Template instance with render method\n      if (!(template instanceof Template) || typeof template.render !== 'function') {\n        const totalTime = performance.now() - startTime;\n        const isInstance = template instanceof Template;\n        const hasRender = typeof (template as any)?.render === 'function';\n        \n        logger.error(\n          `Template '${normalizedName}' validation failed. ` +\n          `Is Template instance: ${isInstance}, Has render method: ${hasRender}`\n        );\n        \n        return {\n          success: false,\n          error: `Template '${normalizedName}' is not a valid Template instance`,\n          performance: { lookupTime, renderTime: 0, totalTime }\n        };\n      }\n      \n      // STEP 2: Render template with performance tracking\n      // Note: Template.render() internally handles Unicode normalization for variables\n      logger.debug(\n        `Starting render for template '${normalizedName}': ` +\n        `variables=${JSON.stringify(Object.keys(variables))}, template.id=${template.id}`\n      );\n      \n      const renderStart = performance.now();\n      const rendered = await template.render(variables);\n      const renderTime = performance.now() - renderStart;\n      \n      // VALIDATION 3: Verify render() returned a string\n      if (typeof rendered !== 'string') {\n        const totalTime = performance.now() - startTime;\n        logger.error(`Template '${normalizedName}' render() returned non-string: ${typeof rendered}`);\n        \n        return {\n          success: false,\n          error: `Template render failed: invalid return type (${typeof rendered})`,\n          performance: { lookupTime, renderTime, totalTime }\n        };\n      }\n      \n      // SUCCESS: Log performance metrics\n      const totalTime = performance.now() - startTime;\n      logger.info(\n        `Template '${normalizedName}' rendered successfully: ` +\n        `lookup=${lookupTime.toFixed(2)}ms, ` +\n        `render=${renderTime.toFixed(2)}ms, ` +\n        `total=${totalTime.toFixed(2)}ms, ` +\n        `output_length=${rendered.length}`\n      );\n      \n      return {\n        success: true,\n        content: rendered,\n        performance: { lookupTime, renderTime, totalTime }\n      };\n      \n    } catch (error) {\n      const totalTime = performance.now() - startTime;\n      const errorMessage = error instanceof Error ? error.message : 'Unknown error';\n      \n      // Use original name in error message for clarity\n      logger.error(`Failed to render template '${name}' after ${totalTime.toFixed(2)}ms:`, error);\n      \n      return {\n        success: false,\n        error: `Failed to render template: ${errorMessage}`,\n        performance: { lookupTime: 0, renderTime: 0, totalTime }\n      };\n    }\n  }\n\n  /**\n   * Batch render multiple templates (useful for testing)\n   * SECURITY: Each template name is normalized individually\n   */\n  async renderBatch(\n    templates: Array<{ name: string; variables: Record<string, any> }>\n  ): Promise<Map<string, RenderResult>> {\n    const results = new Map<string, RenderResult>();\n    \n    for (const { name, variables } of templates) {\n      // Each render call handles its own Unicode normalization\n      results.set(name, await this.render(name, variables));\n    }\n    \n    return results;\n  }\n\n  /**\n   * Validate that a template can be rendered without actually rendering it\n   * SECURITY: Template name is normalized to prevent Unicode attacks\n   */\n  async validate(name: string): Promise<{ valid: boolean; reason?: string }> {\n    try {\n      // SECURITY: Normalize template name\n      const normalizedName = UnicodeValidator.normalize(name).normalizedContent;\n      \n      const template = await this.templateManager.find(t => t.metadata.name === normalizedName);\n      \n      if (!template) {\n        return { valid: false, reason: 'Template not found' };\n      }\n      \n      if (!(template instanceof Template)) {\n        return { valid: false, reason: 'Not a valid Template instance' };\n      }\n      \n      if (typeof template.render !== 'function') {\n        return { valid: false, reason: 'Missing render method' };\n      }\n      \n      return { valid: true };\n      \n    } catch (error) {\n      return { \n        valid: false, \n        reason: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`\n      };\n    }\n  }\n}"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dollhousemcp/mcp-server",
-  "version": "1.7.3",
+  "version": "1.7.4",
   "description": "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.",
   "type": "module",
   "main": "dist/index.js",