@dollhousemcp/mcp-server 2.0.35 → 2.0.37

package/dist/storage/MemoryMetadataExtractor.js

@@ -9,10 +9,14 @@
  */
 import { SecureYamlParser } from '../security/secureYamlParser.js';
 import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { MEMORY_CONSTANTS } from '../elements/memories/constants.js';
 import { logger } from '../utils/logger.js';
 export class MemoryMetadataExtractor {
-    /** Align with SecureYamlParser default raw YAML limit (64KB). */
-    static MAX_YAML_SIZE = 64 * 1024;
+    /**
+     * Align with the memory save/load limit (256KB). Issue #2329: this was 64KB,
+     * so memories that grew past it indexed as 'unnamed' with default metadata.
+     */
+    static MAX_YAML_SIZE = MEMORY_CONSTANTS.MAX_YAML_SIZE;
     /**
      * Extract index-relevant metadata from raw YAML memory content.
      *
@@ -174,4 +178,4 @@ export class MemoryMetadataExtractor {
         return UnicodeValidator.normalize(value).normalizedContent;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MemoryMetadataExtractor.js","sourceRoot":"","sources":["../../src/storage/MemoryMetadataExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Extracts metadata from pure YAML memory files for lightweight indexing.\n *\n * Memory files differ from other elements: they are pure YAML (not markdown\n * with frontmatter). Metadata lives under a top-level `metadata` key or\n * directly as top-level keys. This extractor reads raw YAML and returns\n * the subset of fields needed for ElementIndexEntry without constructing\n * a full Memory object.\n */\n\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport type { ElementIndexEntry } from './types.js';\nimport { logger } from '../utils/logger.js';\n\nexport class MemoryMetadataExtractor {\n  /** Align with SecureYamlParser default raw YAML limit (64KB). */\n  private static readonly MAX_YAML_SIZE = 64 * 1024;\n\n  /**\n   * Extract index-relevant metadata from raw YAML memory content.\n   *\n   * @param rawContent - Full YAML file content\n   * @param relativePath - Path relative to the memories element directory\n   * @returns Partial ElementIndexEntry with extracted fields\n   */\n  static extractMetadata(rawContent: string, relativePath: string): Partial<ElementIndexEntry> {\n    if (!rawContent || typeof rawContent !== 'string' || rawContent.trim().length === 0) {\n      return MemoryMetadataExtractor.defaultEntry(relativePath);\n    }\n\n    const primaryParse = MemoryMetadataExtractor.tryParseYamlObject(rawContent);\n    let yamlData = primaryParse.data;\n    if (!yamlData) {\n      // Multi-document streams (frontmatter + content) fail single-doc parsing.\n      // Extract just the frontmatter block and retry parsing safely.\n      const fmContent = MemoryMetadataExtractor.extractFrontmatter(rawContent);\n      if (!fmContent) {\n        if (primaryParse.errorMessage) {\n          logger.debug('MemoryMetadataExtractor: failed to parse YAML, returning default metadata', {\n            relativePath,\n            stage: 'primary',\n            error: primaryParse.errorMessage,\n          });\n        }\n        return MemoryMetadataExtractor.defaultEntry(relativePath);\n      }\n      const fallbackParse = MemoryMetadataExtractor.tryParseYamlObject(fmContent);\n      yamlData = fallbackParse.data;\n      if (!yamlData) {\n        logger.debug('MemoryMetadataExtractor: failed to parse YAML (primary + frontmatter fallback), returning default metadata', {\n          relativePath,\n          primaryError: primaryParse.errorMessage,\n          fallbackError: fallbackParse.errorMessage,\n        });\n        return MemoryMetadataExtractor.defaultEntry(relativePath);\n      }\n    }\n\n    // Memory files store metadata under a top-level `metadata` key or directly as top-level keys\n    const metadataSource = (\n      yamlData.metadata && typeof yamlData.metadata === 'object' && !Array.isArray(yamlData.metadata)\n        ? yamlData.metadata\n        : yamlData\n    ) as Record<string, unknown>;\n\n    const normalizedName = typeof metadataSource.name === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.name)\n      : '';\n    const name = normalizedName.length > 0\n      ? normalizedName\n      : 'unnamed';\n\n    const description = typeof metadataSource.description === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.description)\n      : '';\n\n    const normalizedVersion = typeof metadataSource.version === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.version)\n      : '';\n    const version = normalizedVersion.length > 0\n      ? normalizedVersion\n      : '1.0.0';\n\n    const author = typeof metadataSource.author === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.author)\n      : '';\n\n    const tags = Array.isArray(metadataSource.tags) && metadataSource.tags.every((t: unknown) => typeof t === 'string')\n      ? (metadataSource.tags as string[])\n        .map(tag => MemoryMetadataExtractor.normalizeText(tag))\n        .filter(tag => tag.length > 0)\n      : [];\n\n    const autoLoad = typeof metadataSource.autoLoad === 'boolean'\n      ? metadataSource.autoLoad\n      : undefined;\n\n    const priority = typeof metadataSource.priority === 'number'\n      ? metadataSource.priority\n      : undefined;\n\n    const normalizedMemoryType = typeof metadataSource.memoryType === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.memoryType)\n      : '';\n    const memoryType = normalizedMemoryType.length > 0\n      ? normalizedMemoryType\n      : MemoryMetadataExtractor.inferMemoryType(relativePath);\n\n    // totalEntries: prefer stats.totalEntries, fall back to entries array length\n    let totalEntries: number | undefined;\n    const stats = yamlData.stats as Record<string, unknown> | undefined;\n    if (stats && typeof stats === 'object' && typeof stats.totalEntries === 'number') {\n      totalEntries = stats.totalEntries;\n    } else if (Array.isArray(yamlData.entries)) {\n      totalEntries = yamlData.entries.length;\n    }\n\n    const entry: Partial<ElementIndexEntry> = {\n      filePath: relativePath,\n      name,\n      description,\n      version,\n      author,\n      tags,\n      memoryType,\n    };\n\n    if (autoLoad !== undefined) entry.autoLoad = autoLoad;\n    if (priority !== undefined) entry.priority = priority;\n    if (totalEntries !== undefined) entry.totalEntries = totalEntries;\n\n    return entry;\n  }\n\n  /**\n   * Infer the memory type from the file's relative path.\n   *\n   * @param relativePath - Path relative to the memories directory\n   * @returns 'system' | 'adapter' | 'user'\n   */\n  static inferMemoryType(relativePath: string): string {\n    // Normalize separators to forward slash for consistent matching\n    const normalized = relativePath.replace(/\\\\/g, '/');\n\n    if (normalized.startsWith('system/')) return 'system';\n    if (normalized.startsWith('adapters/')) return 'adapter';\n    return 'user';\n  }\n\n  /**\n   * Extract YAML content between --- frontmatter markers.\n   * Returns null if no valid frontmatter block found.\n   */\n  private static extractFrontmatter(rawContent: string): string | null {\n    const trimmed = rawContent.trim();\n    if (!trimmed.startsWith('---')) return null;\n\n    const endIndex = trimmed.indexOf('\\n---', 3);\n    if (endIndex === -1) return null;\n\n    return trimmed.substring(3, endIndex).trim();\n  }\n\n  /**\n   * Parse raw YAML using the centralized secure parser.\n   * Returns parse diagnostics so callers can fail closed while preserving error context.\n   */\n  private static tryParseYamlObject(content: string): { data?: Record<string, unknown>; errorMessage?: string } {\n    try {\n      return { data: SecureYamlParser.parseRawYaml(content, MemoryMetadataExtractor.MAX_YAML_SIZE) };\n    } catch (error) {\n      return {\n        errorMessage: error instanceof Error ? error.message : String(error),\n      };\n    }\n  }\n\n  /** Return a minimal default entry for empty/corrupt content. */\n  private static defaultEntry(relativePath: string): Partial<ElementIndexEntry> {\n    return {\n      filePath: relativePath,\n      name: 'unnamed',\n      description: '',\n      version: '1.0.0',\n      author: '',\n      tags: [],\n      memoryType: MemoryMetadataExtractor.inferMemoryType(relativePath),\n    };\n  }\n\n  private static normalizeText(value: string): string {\n    return UnicodeValidator.normalize(value).normalizedContent;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MemoryMetadataExtractor.js","sourceRoot":"","sources":["../../src/storage/MemoryMetadataExtractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAErE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,MAAM,OAAO,uBAAuB;IAClC;;;OAGG;IACK,MAAM,CAAU,aAAa,GAAG,gBAAgB,CAAC,aAAa,CAAC;IAEvE;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,UAAkB,EAAE,YAAoB;QAC7D,IAAI,CAAC,UAAU,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACpF,OAAO,uBAAuB,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;QAC5D,CAAC;QAED,MAAM,YAAY,GAAG,uBAAuB,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;QAC5E,IAAI,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC;QACjC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,0EAA0E;YAC1E,+DAA+D;YAC/D,MAAM,SAAS,GAAG,uBAAuB,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;YACzE,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,IAAI,YAAY,CAAC,YAAY,EAAE,CAAC;oBAC9B,MAAM,CAAC,KAAK,CAAC,2EAA2E,EAAE;wBACxF,YAAY;wBACZ,KAAK,EAAE,SAAS;wBAChB,KAAK,EAAE,YAAY,CAAC,YAAY;qBACjC,CAAC,CAAC;gBACL,CAAC;gBACD,OAAO,uBAAuB,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;YAC5D,CAAC;YACD,MAAM,aAAa,GAAG,uBAAuB,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;YAC5E,QAAQ,GAAG,aAAa,CAAC,IAAI,CAAC;YAC9B,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,CAAC,KAAK,CAAC,4GAA4G,EAAE;oBACzH,YAAY;oBACZ,YAAY,EAAE,YAAY,CAAC,YAAY;oBACvC,aAAa,EAAE,aAAa,CAAC,YAAY;iBAC1C,CAAC,CAAC;gBACH,OAAO,uBAAuB,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;YAC5D,CAAC;QACH,CAAC;QAED,6FAA6F;QAC7F,MAAM,cAAc,GAAG,CACrB,QAAQ,CAAC,QAAQ,IAAI,OAAO,QAAQ,CAAC,QAAQ,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC7F,CAAC,CAAC,QAAQ,CAAC,QAAQ;YACnB,CAAC,CAAC,QAAQ,CACc,CAAC;QAE7B,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,KAAK,QAAQ;YAC5D,CAAC,CAAC,uBAAuB,CAAC,aAAa,CAAC,cAAc,CAAC,IAAI,CAAC;YAC5D,CAAC,CAAC,EAAE,CAAC;QACP,MAAM,IAAI,GAAG,cAAc,CAAC,MAAM,GAAG,CAAC;YACpC,CAAC,CAAC,cAAc;YAChB,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,WAAW,GAAG,OAAO,cAAc,CAAC,WAAW,KAAK,QAAQ;YAChE,CAAC,CAAC,uBAAuB,CAAC,aAAa,CAAC,cAAc,CAAC,WAAW,CAAC;YACnE,CAAC,CAAC,EAAE,CAAC;QAEP,MAAM,iBAAiB,GAAG,OAAO,cAAc,CAAC,OAAO,KAAK,QAAQ;YAClE,CAAC,CAAC,uBAAuB,CAAC,aAAa,CAAC,cAAc,CAAC,OAAO,CAAC;YAC/D,CAAC,CAAC,EAAE,CAAC;QACP,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM,GAAG,CAAC;YAC1C,CAAC,CAAC,iBAAiB;YACnB,CAAC,CAAC,OAAO,CAAC;QAEZ,MAAM,MAAM,GAAG,OAAO,cAAc,CAAC,MAAM,KAAK,QAAQ;YACtD,CAAC,CAAC,uBAAuB,CAAC,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC;YAC9D,CAAC,CAAC,EAAE,CAAC;QAEP,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAU,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC;YACjH,CAAC,CAAE,cAAc,CAAC,IAAiB;iBAChC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,uBAAuB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;iBACtD,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;YAChC,CAAC,CAAC,EAAE,CAAC;QAEP,MAAM,QAAQ,GAAG,OAAO,cAAc,CAAC,QAAQ,KAAK,SAAS;YAC3D,CAAC,CAAC,cAAc,CAAC,QAAQ;YACzB,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,QAAQ,GAAG,OAAO,cAAc,CAAC,QAAQ,KAAK,QAAQ;YAC1D,CAAC,CAAC,cAAc,CAAC,QAAQ;YACzB,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,oBAAoB,GAAG,OAAO,cAAc,CAAC,UAAU,KAAK,QAAQ;YACxE,CAAC,CAAC,uBAAuB,CAAC,aAAa,CAAC,cAAc,CAAC,UAAU,CAAC;YAClE,CAAC,CAAC,EAAE,CAAC;QACP,MAAM,UAAU,GAAG,oBAAoB,CAAC,MAAM,GAAG,CAAC;YAChD,CAAC,CAAC,oBAAoB;YACtB,CAAC,CAAC,uBAAuB,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;QAE1D,6EAA6E;QAC7E,IAAI,YAAgC,CAAC;QACrC,MAAM,KAAK,GAAG,QAAQ,CAAC,KAA4C,CAAC;QACpE,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,CAAC,YAAY,KAAK,QAAQ,EAAE,CAAC;YACjF,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;QACpC,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3C,YAAY,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC;QACzC,CAAC;QAED,MAAM,KAAK,GAA+B;YACxC,QAAQ,EAAE,YAAY;YACtB,IAAI;YACJ,WAAW;YACX,OAAO;YACP,MAAM;YACN,IAAI;YACJ,UAAU;SACX,CAAC;QAEF,IAAI,QAAQ,KAAK,SAAS;YAAE,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACtD,IAAI,QAAQ,KAAK,SAAS;YAAE,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACtD,IAAI,YAAY,KAAK,SAAS;YAAE,KAAK,CAAC,YAAY,GAAG,YAAY,CAAC;QAElE,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,YAAoB;QACzC,gEAAgE;QAChE,MAAM,UAAU,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAEpD,IAAI,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC;YAAE,OAAO,QAAQ,CAAC;QACtD,IAAI,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC;YAAE,OAAO,SAAS,CAAC;QACzD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;OAGG;IACK,MAAM,CAAC,kBAAkB,CAAC,UAAkB;QAClD,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;QAClC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAE5C,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;QAC7C,IAAI,QAAQ,KAAK,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;QAEjC,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACK,MAAM,CAAC,kBAAkB,CAAC,OAAe;QAC/C,IAAI,CAAC;YACH,OAAO,EAAE,IAAI,EAAE,gBAAgB,CAAC,YAAY,CAAC,OAAO,EAAE,uBAAuB,CAAC,aAAa,CAAC,EAAE,CAAC;QACjG,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO;gBACL,YAAY,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;aACrE,CAAC;QACJ,CAAC;IACH,CAAC;IAED,gEAAgE;IACxD,MAAM,CAAC,YAAY,CAAC,YAAoB;QAC9C,OAAO;YACL,QAAQ,EAAE,YAAY;YACtB,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,EAAE;YACf,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,EAAE;YACV,IAAI,EAAE,EAAE;YACR,UAAU,EAAE,uBAAuB,CAAC,eAAe,CAAC,YAAY,CAAC;SAClE,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,aAAa,CAAC,KAAa;QACxC,OAAO,gBAAgB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,iBAAiB,CAAC;IAC7D,CAAC","sourcesContent":["/**\n * Extracts metadata from pure YAML memory files for lightweight indexing.\n *\n * Memory files differ from other elements: they are pure YAML (not markdown\n * with frontmatter). Metadata lives under a top-level `metadata` key or\n * directly as top-level keys. This extractor reads raw YAML and returns\n * the subset of fields needed for ElementIndexEntry without constructing\n * a full Memory object.\n */\n\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { MEMORY_CONSTANTS } from '../elements/memories/constants.js';\nimport type { ElementIndexEntry } from './types.js';\nimport { logger } from '../utils/logger.js';\n\nexport class MemoryMetadataExtractor {\n  /**\n   * Align with the memory save/load limit (256KB). Issue #2329: this was 64KB,\n   * so memories that grew past it indexed as 'unnamed' with default metadata.\n   */\n  private static readonly MAX_YAML_SIZE = MEMORY_CONSTANTS.MAX_YAML_SIZE;\n\n  /**\n   * Extract index-relevant metadata from raw YAML memory content.\n   *\n   * @param rawContent - Full YAML file content\n   * @param relativePath - Path relative to the memories element directory\n   * @returns Partial ElementIndexEntry with extracted fields\n   */\n  static extractMetadata(rawContent: string, relativePath: string): Partial<ElementIndexEntry> {\n    if (!rawContent || typeof rawContent !== 'string' || rawContent.trim().length === 0) {\n      return MemoryMetadataExtractor.defaultEntry(relativePath);\n    }\n\n    const primaryParse = MemoryMetadataExtractor.tryParseYamlObject(rawContent);\n    let yamlData = primaryParse.data;\n    if (!yamlData) {\n      // Multi-document streams (frontmatter + content) fail single-doc parsing.\n      // Extract just the frontmatter block and retry parsing safely.\n      const fmContent = MemoryMetadataExtractor.extractFrontmatter(rawContent);\n      if (!fmContent) {\n        if (primaryParse.errorMessage) {\n          logger.debug('MemoryMetadataExtractor: failed to parse YAML, returning default metadata', {\n            relativePath,\n            stage: 'primary',\n            error: primaryParse.errorMessage,\n          });\n        }\n        return MemoryMetadataExtractor.defaultEntry(relativePath);\n      }\n      const fallbackParse = MemoryMetadataExtractor.tryParseYamlObject(fmContent);\n      yamlData = fallbackParse.data;\n      if (!yamlData) {\n        logger.debug('MemoryMetadataExtractor: failed to parse YAML (primary + frontmatter fallback), returning default metadata', {\n          relativePath,\n          primaryError: primaryParse.errorMessage,\n          fallbackError: fallbackParse.errorMessage,\n        });\n        return MemoryMetadataExtractor.defaultEntry(relativePath);\n      }\n    }\n\n    // Memory files store metadata under a top-level `metadata` key or directly as top-level keys\n    const metadataSource = (\n      yamlData.metadata && typeof yamlData.metadata === 'object' && !Array.isArray(yamlData.metadata)\n        ? yamlData.metadata\n        : yamlData\n    ) as Record<string, unknown>;\n\n    const normalizedName = typeof metadataSource.name === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.name)\n      : '';\n    const name = normalizedName.length > 0\n      ? normalizedName\n      : 'unnamed';\n\n    const description = typeof metadataSource.description === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.description)\n      : '';\n\n    const normalizedVersion = typeof metadataSource.version === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.version)\n      : '';\n    const version = normalizedVersion.length > 0\n      ? normalizedVersion\n      : '1.0.0';\n\n    const author = typeof metadataSource.author === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.author)\n      : '';\n\n    const tags = Array.isArray(metadataSource.tags) && metadataSource.tags.every((t: unknown) => typeof t === 'string')\n      ? (metadataSource.tags as string[])\n        .map(tag => MemoryMetadataExtractor.normalizeText(tag))\n        .filter(tag => tag.length > 0)\n      : [];\n\n    const autoLoad = typeof metadataSource.autoLoad === 'boolean'\n      ? metadataSource.autoLoad\n      : undefined;\n\n    const priority = typeof metadataSource.priority === 'number'\n      ? metadataSource.priority\n      : undefined;\n\n    const normalizedMemoryType = typeof metadataSource.memoryType === 'string'\n      ? MemoryMetadataExtractor.normalizeText(metadataSource.memoryType)\n      : '';\n    const memoryType = normalizedMemoryType.length > 0\n      ? normalizedMemoryType\n      : MemoryMetadataExtractor.inferMemoryType(relativePath);\n\n    // totalEntries: prefer stats.totalEntries, fall back to entries array length\n    let totalEntries: number | undefined;\n    const stats = yamlData.stats as Record<string, unknown> | undefined;\n    if (stats && typeof stats === 'object' && typeof stats.totalEntries === 'number') {\n      totalEntries = stats.totalEntries;\n    } else if (Array.isArray(yamlData.entries)) {\n      totalEntries = yamlData.entries.length;\n    }\n\n    const entry: Partial<ElementIndexEntry> = {\n      filePath: relativePath,\n      name,\n      description,\n      version,\n      author,\n      tags,\n      memoryType,\n    };\n\n    if (autoLoad !== undefined) entry.autoLoad = autoLoad;\n    if (priority !== undefined) entry.priority = priority;\n    if (totalEntries !== undefined) entry.totalEntries = totalEntries;\n\n    return entry;\n  }\n\n  /**\n   * Infer the memory type from the file's relative path.\n   *\n   * @param relativePath - Path relative to the memories directory\n   * @returns 'system' | 'adapter' | 'user'\n   */\n  static inferMemoryType(relativePath: string): string {\n    // Normalize separators to forward slash for consistent matching\n    const normalized = relativePath.replace(/\\\\/g, '/');\n\n    if (normalized.startsWith('system/')) return 'system';\n    if (normalized.startsWith('adapters/')) return 'adapter';\n    return 'user';\n  }\n\n  /**\n   * Extract YAML content between --- frontmatter markers.\n   * Returns null if no valid frontmatter block found.\n   */\n  private static extractFrontmatter(rawContent: string): string | null {\n    const trimmed = rawContent.trim();\n    if (!trimmed.startsWith('---')) return null;\n\n    const endIndex = trimmed.indexOf('\\n---', 3);\n    if (endIndex === -1) return null;\n\n    return trimmed.substring(3, endIndex).trim();\n  }\n\n  /**\n   * Parse raw YAML using the centralized secure parser.\n   * Returns parse diagnostics so callers can fail closed while preserving error context.\n   */\n  private static tryParseYamlObject(content: string): { data?: Record<string, unknown>; errorMessage?: string } {\n    try {\n      return { data: SecureYamlParser.parseRawYaml(content, MemoryMetadataExtractor.MAX_YAML_SIZE) };\n    } catch (error) {\n      return {\n        errorMessage: error instanceof Error ? error.message : String(error),\n      };\n    }\n  }\n\n  /** Return a minimal default entry for empty/corrupt content. */\n  private static defaultEntry(relativePath: string): Partial<ElementIndexEntry> {\n    return {\n      filePath: relativePath,\n      name: 'unnamed',\n      description: '',\n      version: '1.0.0',\n      author: '',\n      tags: [],\n      memoryType: MemoryMetadataExtractor.inferMemoryType(relativePath),\n    };\n  }\n\n  private static normalizeText(value: string): string {\n    return UnicodeValidator.normalize(value).normalizedContent;\n  }\n}\n"]}

package/dist/utils/pathSecurity.d.ts

@@ -1,7 +1,9 @@
 /**
  * Resolve a target path and verify that it remains inside the intended base
  * directory. This is separator-aware, so sibling paths such as `/tmp/base2`
- * are not treated as children of `/tmp/base`.
+ * are not treated as children of `/tmp/base`. Existing symlinked base paths
+ * and symlinked descendants under the base are rejected because writes would
+ * follow them outside the lexical containment boundary.
  */
 export declare function resolvePathWithinBase(baseDir: string, ...segments: string[]): string;
 //# sourceMappingURL=pathSecurity.d.ts.map

package/dist/utils/pathSecurity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pathSecurity.d.ts","sourceRoot":"","sources":["../../src/utils/pathSecurity.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CA0BpF"}
+{"version":3,"file":"pathSecurity.d.ts","sourceRoot":"","sources":["../../src/utils/pathSecurity.ts"],"names":[],"mappings":"AAqCA;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CA4BpF"}

package/dist/utils/pathSecurity.js

@@ -1,8 +1,42 @@
+import * as fs from 'node:fs';
 import * as path from 'node:path';
+function assertNotSymlink(pathToCheck, message) {
+    try {
+        const stats = fs.lstatSync(pathToCheck);
+        if (stats.isSymbolicLink()) {
+            throw new Error(message);
+        }
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error !== null && 'code' in error
+            ? error.code
+            : undefined;
+        if (code === 'ENOENT' || code === 'ENOTDIR') {
+            return;
+        }
+        throw error;
+    }
+}
+function assertNoSymlinkedDescendants(resolvedBase, resolvedTarget) {
+    const relativePath = path.relative(resolvedBase, resolvedTarget);
+    if (!relativePath) {
+        return;
+    }
+    let currentPath = resolvedBase;
+    for (const segment of relativePath.split(path.sep)) {
+        if (!segment) {
+            continue;
+        }
+        currentPath = path.join(currentPath, segment);
+        assertNotSymlink(currentPath, 'Path segment resolves through a symbolic link');
+    }
+}
 /**
  * Resolve a target path and verify that it remains inside the intended base
  * directory. This is separator-aware, so sibling paths such as `/tmp/base2`
- * are not treated as children of `/tmp/base`.
+ * are not treated as children of `/tmp/base`. Existing symlinked base paths
+ * and symlinked descendants under the base are rejected because writes would
+ * follow them outside the lexical containment boundary.
  */
 export function resolvePathWithinBase(baseDir, ...segments) {
     if (!baseDir || typeof baseDir !== 'string') {
@@ -23,8 +57,10 @@ export function resolvePathWithinBase(baseDir, ...segments) {
         || relativePath.startsWith('..' + path.sep)
         || path.isAbsolute(relativePath);
     if (!isTraversal) {
+        assertNotSymlink(resolvedBase, 'Base directory resolves through a symbolic link');
+        assertNoSymlinkedDescendants(resolvedBase, resolvedTarget);
         return resolvedTarget;
     }
     throw new Error('Resolved path escapes the base directory');
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/web/routes/setupRoutes.d.ts

@@ -33,6 +33,13 @@ export declare function createSetupRoutes(opts?: {
     _installPermissionHook?: (client: string) => Promise<InstallPermissionHookResult>;
     /** Override permission hook status reconciler. For testing only. */
     _reconcilePermissionHookStatus?: (client: string) => Promise<PermissionHookStatus>;
+    /**
+     * Override the NVM launcher mitigation applied after a successful install.
+     * For testing only. Without this seam the install handler runs the real
+     * applyNvmLauncherIfNeeded against the real homedir(); on a machine WITH NVM
+     * that patches the developer's real client configs (issue #2338).
+     */
+    _applyNvmLauncher?: (client: string) => Promise<NvmLauncherResult>;
     /** Enable automatic hook asset repair during detect. Defaults off in tests. */
     _autoRepairPermissionHooksOnDetect?: boolean;
     /** Skip the sliding-window rate limiter. For testing only. */
@@ -59,18 +66,27 @@ export type NvmLauncherResult = 'applied' | 'not-applicable' | 'failed';
  */
 export declare function applyNvmLauncherIfNeeded(client: string, home?: string): Promise<NvmLauncherResult>;
 /**
- * Startup repair: re-creates the wrapper and re-patches all known JSON-format
- * client configs on every server start. Handles two cases:
- *   1. Wrapper was deleted — recreates it so configs pointing to it keep working.
- *   2. Pre-existing install (user installed before this fix shipped) — patches
- *      configs that still use bare `npx`.
+ * Startup repair + self-heal: reconciles every known JSON-format client config
+ * on each server start. Behaviour depends on whether NVM is installed, matching
+ * the acceptance matrix in https://github.com/DollhouseMCP/mcp-server/issues/2338:
+ *
+ *   • NVM present  → (re)create the wrapper and point each config at it. Covers a
+ *     deleted wrapper, a pre-fix install still on bare `npx`, and a config left
+ *     pointing at a dead temp-dir wrapper (regenerates the real one). Healthy
+ *     configs re-serialise byte-identically, so this is a no-op for them.
+ *   • NVM absent   → never create a wrapper, but SELF-HEAL any config whose
+ *     command points at a `dollhousemcp-nvm.sh` that no longer exists (e.g. the
+ *     #2338 test leak, or a user who removed ~/.dollhouse/bin) back to bare `npx`,
+ *     preserving args so the client can launch DollhouseMCP again.
  *
  * Fire-and-forget from startWebServer. All errors are swallowed and logged.
  *
  * @param home               - Override home directory (injectable for tests)
  * @param configPathResolver - Override config path lookup (injectable for tests).
- *                             Return null to skip a client entirely.
- *                             Defaults to the production getConfigPath.
+ *                             Return null to skip a client entirely. Defaults to a
+ *                             home-derived resolver so `home` stays authoritative
+ *                             — the default must NOT reach the real homedir() when
+ *                             a fake home is supplied (#2338).
  */
 export declare function repairNvmLauncherOnStartup(home?: string, configPathResolver?: (client: string) => string | null): Promise<void>;
 /**

package/dist/web/routes/setupRoutes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setupRoutes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/setupRoutes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"setupRoutes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/setupRoutes.ts"],"names":[],"mappings":"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"}