@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/cache/CollectionCache.js

@@ -12,8 +12,18 @@ export class CollectionCache {
     cacheDir;
     cacheFile;
     CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours for collection cache
-    constructor(baseDir = process.cwd()) {
-        this.cacheDir = path.join(baseDir, '.dollhousemcp', 'cache');
+    constructor(baseDir) {
+        // Use environment variable if set, otherwise fall back to parameter or default
+        const envCacheDir = process.env.DOLLHOUSE_CACHE_DIR;
+        if (envCacheDir) {
+            this.cacheDir = envCacheDir;
+            logger.debug(`CollectionCache: Using environment cache directory: ${this.cacheDir}`);
+        }
+        else {
+            const defaultBaseDir = baseDir || process.cwd();
+            this.cacheDir = path.join(defaultBaseDir, '.dollhousemcp', 'cache');
+            logger.debug(`CollectionCache: Using default cache directory: ${this.cacheDir}`);
+        }
         this.cacheFile = path.join(this.cacheDir, 'collection-cache.json');
     }
     /**
@@ -159,4 +169,4 @@ export class CollectionCache {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionCache.js","sourceRoot":"","sources":["../../src/cache/CollectionCache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAgBjE;;GAEG;AACH,MAAM,OAAO,eAAe;IAClB,QAAQ,CAAS;IACjB,SAAS,CAAS;IACT,YAAY,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,gCAAgC;IAErF,YAAY,UAAkB,OAAO,CAAC,GAAG,EAAE;QACzC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,uBAAuB,CAAC,CAAC;IACrE,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,cAAc;QAC1B,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACrD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,qCAAqC,KAAK,EAAE,CAAC,CAAC;YAC3D,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS;QACb,IAAI,CAAC;YACH,kDAAkD;YAClD,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBACnE,uEAAuE;gBACvE,eAAe,CAAC,gBAAgB,CAAC;oBAC/B,IAAI,EAAE,wBAAwB;oBAC9B,QAAQ,EAAE,MAAM;oBAChB,MAAM,EAAE,2BAA2B;oBACnC,OAAO,EAAE,iEAAiE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE;iBAC7G,CAAC,CAAC;gBACH,MAAM,CAAC,IAAI,CAAC,8CAA8C,CAAC,CAAC;gBAC5D,OAAO,IAAI,CAAC;YACd,CAAC;YAED,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YACvD,MAAM,KAAK,GAAyB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAErD,4BAA4B;YAC5B,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;gBACrD,MAAM,CAAC,KAAK,CAAC,oDAAoD,CAAC,CAAC;gBACnE,OAAO,IAAI,CAAC;YACd,CAAC;YAED,MAAM,CAAC,KAAK,CAAC,UAAU,KAAK,CAAC,KAAK,CAAC,MAAM,8BAA8B,CAAC,CAAC;YACzE,OAAO,KAAK,CAAC;QACf,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAK,KAAa,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACrC,MAAM,CAAC,KAAK,CAAC,oCAAoC,KAAK,EAAE,CAAC,CAAC;YAC5D,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,KAAuB,EAAE,IAAa;QACpD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YAE5B,MAAM,UAAU,GAAyB;gBACvC,KAAK;gBACL,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;gBACrB,IAAI;aACL,CAAC;YAEF,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YACjD,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;YAEjD,MAAM,CAAC,KAAK,CAAC,SAAS,KAAK,CAAC,MAAM,4BAA4B,CAAC,CAAC;YAEhE,6DAA6D;YAC7D,MAAM,CAAC,KAAK,CAAC,8DAA8D,CAAC,CAAC;YAE7E,uCAAuC;YACvC,MAAM,CAAC,KAAK,CAAC,uCAAuC,KAAK,CAAC,MAAM,QAAQ,CAAC,CAAC;QAC5E,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,oCAAoC,KAAK,EAAE,CAAC,CAAC;YAC1D,+DAA+D;QACjE,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW,CAAC,KAAa;QAC7B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QACrC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,eAAe,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;QACxD,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YAC/B,iDAAiD;YACjD,MAAM,cAAc,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3D,MAAM,cAAc,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAE3D,OAAO,cAAc,CAAC,QAAQ,CAAC,eAAe,CAAC;gBACxC,cAAc,CAAC,QAAQ,CAAC,eAAe,CAAC;gBACxC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC;QAC5F,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,IAAY;QACtC,OAAO,IAAI,CAAC,WAAW,EAAE;aACtB,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CAAE,wCAAwC;aAClE,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAO,uBAAuB;aAClD,IAAI,EAAE,CAAC;IACZ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc,CAAC,UAAkB;QACrC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QACrC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;IACtE,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY;QAChB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QACrC,OAAO,KAAK,KAAK,IAAI,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAChC,MAAM,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC3C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAK,KAAa,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACrC,MAAM,CAAC,KAAK,CAAC,qCAAqC,KAAK,EAAE,CAAC,CAAC;YAC7D,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,aAAa;QACjB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QACrC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QACvD,CAAC;QAED,OAAO;YACL,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM;YAC7B,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,SAAS;YACtC,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,SAAS,IAAI,IAAI,CAAC,YAAY;SAC3D,CAAC;IACJ,CAAC;CACF","sourcesContent":["/**\n * Persistent cache for collection data to support offline/anonymous browsing\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { logger } from '../utils/logger.js';\nimport { PathValidator } from '../security/pathValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\nexport interface CollectionItem {\n  name: string;\n  path: string;\n  sha: string;\n  content?: string;\n  last_modified?: string;\n}\n\nexport interface CollectionCacheEntry {\n  items: CollectionItem[];\n  timestamp: number;\n  etag?: string;\n}\n\n/**\n * Persistent cache for collection data that supports offline browsing\n */\nexport class CollectionCache {\n  private cacheDir: string;\n  private cacheFile: string;\n  private readonly CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours for collection cache\n  \n  constructor(baseDir: string = process.cwd()) {\n    this.cacheDir = path.join(baseDir, '.dollhousemcp', 'cache');\n    this.cacheFile = path.join(this.cacheDir, 'collection-cache.json');\n  }\n  \n  /**\n   * Initialize cache directory\n   */\n  private async ensureCacheDir(): Promise<void> {\n    try {\n      await fs.mkdir(this.cacheDir, { recursive: true });\n    } catch (error) {\n      logger.error(`Failed to create cache directory: ${error}`);\n      throw error;\n    }\n  }\n  \n  /**\n   * Load collection data from persistent cache\n   */\n  async loadCache(): Promise<CollectionCacheEntry | null> {\n    try {\n      // Validate cache file path (basic security check)\n      if (this.cacheFile.includes('..') || this.cacheFile.includes('\\0')) {\n        // SECURITY FIX: Add audit logging for path traversal attempt detection\n        SecurityMonitor.logSecurityEvent({\n          type: 'PATH_TRAVERSAL_ATTEMPT',\n          severity: 'HIGH',\n          source: 'CollectionCache.loadCache',\n          details: `Potential path traversal attempt detected in cache file path: ${this.cacheFile.substring(0, 100)}`\n        });\n        logger.warn('Invalid cache file path, skipping cache load');\n        return null;\n      }\n      \n      const data = await fs.readFile(this.cacheFile, 'utf8');\n      const cache: CollectionCacheEntry = JSON.parse(data);\n      \n      // Check if cache is expired\n      if (Date.now() - cache.timestamp > this.CACHE_TTL_MS) {\n        logger.debug('Collection cache expired, will refresh from GitHub');\n        return null;\n      }\n      \n      logger.debug(`Loaded ${cache.items.length} items from collection cache`);\n      return cache;\n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug(`Failed to load collection cache: ${error}`);\n      }\n      return null;\n    }\n  }\n  \n  /**\n   * Save collection data to persistent cache\n   */\n  async saveCache(items: CollectionItem[], etag?: string): Promise<void> {\n    try {\n      await this.ensureCacheDir();\n      \n      const cacheEntry: CollectionCacheEntry = {\n        items,\n        timestamp: Date.now(),\n        etag\n      };\n      \n      const data = JSON.stringify(cacheEntry, null, 2);\n      await fs.writeFile(this.cacheFile, data, 'utf8');\n      \n      logger.debug(`Saved ${items.length} items to collection cache`);\n      \n      // SECURITY FIX: Add audit logging for cache write operations\n      logger.debug('Security audit: Cache write operation completed successfully');\n      \n      // Log operation completed successfully\n      logger.debug(`Cache file operation completed with ${items.length} items`);\n    } catch (error) {\n      logger.error(`Failed to save collection cache: ${error}`);\n      // Don't throw - caching failures shouldn't break functionality\n    }\n  }\n  \n  /**\n   * Search cached collection items with fuzzy matching\n   */\n  async searchCache(query: string): Promise<CollectionItem[]> {\n    const cache = await this.loadCache();\n    if (!cache) {\n      return [];\n    }\n    \n    const normalizedQuery = this.normalizeSearchTerm(query);\n    return cache.items.filter(item => {\n      // Search in filename and path with normalization\n      const normalizedName = this.normalizeSearchTerm(item.name);\n      const normalizedPath = this.normalizeSearchTerm(item.path);\n      \n      return normalizedName.includes(normalizedQuery) || \n             normalizedPath.includes(normalizedQuery) ||\n             (item.content && this.normalizeSearchTerm(item.content).includes(normalizedQuery));\n    });\n  }\n  \n  /**\n   * Normalize search terms for better matching (handles spaces, dashes, etc.)\n   */\n  private normalizeSearchTerm(term: string): string {\n    return term.toLowerCase()\n      .replace(/[-_\\s]+/g, ' ')  // Convert dashes, underscores to spaces\n      .replace(/\\.md$/, '')       // Remove .md extension\n      .trim();\n  }\n  \n  /**\n   * Get cached collection items by type/path\n   */\n  async getItemsByPath(pathPrefix: string): Promise<CollectionItem[]> {\n    const cache = await this.loadCache();\n    if (!cache) {\n      return [];\n    }\n    \n    return cache.items.filter(item => item.path.startsWith(pathPrefix));\n  }\n  \n  /**\n   * Check if cache exists and is valid\n   */\n  async isCacheValid(): Promise<boolean> {\n    const cache = await this.loadCache();\n    return cache !== null;\n  }\n  \n  /**\n   * Clear the cache\n   */\n  async clearCache(): Promise<void> {\n    try {\n      await fs.unlink(this.cacheFile);\n      logger.debug('Collection cache cleared');\n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug(`Failed to clear collection cache: ${error}`);\n      }\n    }\n  }\n  \n  /**\n   * Get cache stats for debugging\n   */\n  async getCacheStats(): Promise<{ itemCount: number; cacheAge: number; isValid: boolean }> {\n    const cache = await this.loadCache();\n    if (!cache) {\n      return { itemCount: 0, cacheAge: 0, isValid: false };\n    }\n    \n    return {\n      itemCount: cache.items.length,\n      cacheAge: Date.now() - cache.timestamp,\n      isValid: Date.now() - cache.timestamp <= this.CACHE_TTL_MS\n    };\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionCache.js","sourceRoot":"","sources":["../../src/cache/CollectionCache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Persistent cache for collection data to support offline/anonymous browsing\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { logger } from '../utils/logger.js';\nimport { PathValidator } from '../security/pathValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\nexport interface CollectionItem {\n  name: string;\n  path: string;\n  sha: string;\n  content?: string;\n  last_modified?: string;\n}\n\nexport interface CollectionCacheEntry {\n  items: CollectionItem[];\n  timestamp: number;\n  etag?: string;\n}\n\n/**\n * Persistent cache for collection data that supports offline browsing\n */\nexport class CollectionCache {\n  private cacheDir: string;\n  private cacheFile: string;\n  private readonly CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours for collection cache\n  \n  constructor(baseDir?: string) {\n    // Use environment variable if set, otherwise fall back to parameter or default\n    const envCacheDir = process.env.DOLLHOUSE_CACHE_DIR;\n    if (envCacheDir) {\n      this.cacheDir = envCacheDir;\n      logger.debug(`CollectionCache: Using environment cache directory: ${this.cacheDir}`);\n    } else {\n      const defaultBaseDir = baseDir || process.cwd();\n      this.cacheDir = path.join(defaultBaseDir, '.dollhousemcp', 'cache');\n      logger.debug(`CollectionCache: Using default cache directory: ${this.cacheDir}`);\n    }\n    this.cacheFile = path.join(this.cacheDir, 'collection-cache.json');\n  }\n  \n  /**\n   * Initialize cache directory\n   */\n  private async ensureCacheDir(): Promise<void> {\n    try {\n      await fs.mkdir(this.cacheDir, { recursive: true });\n    } catch (error) {\n      logger.error(`Failed to create cache directory: ${error}`);\n      throw error;\n    }\n  }\n  \n  /**\n   * Load collection data from persistent cache\n   */\n  async loadCache(): Promise<CollectionCacheEntry | null> {\n    try {\n      // Validate cache file path (basic security check)\n      if (this.cacheFile.includes('..') || this.cacheFile.includes('\\0')) {\n        // SECURITY FIX: Add audit logging for path traversal attempt detection\n        SecurityMonitor.logSecurityEvent({\n          type: 'PATH_TRAVERSAL_ATTEMPT',\n          severity: 'HIGH',\n          source: 'CollectionCache.loadCache',\n          details: `Potential path traversal attempt detected in cache file path: ${this.cacheFile.substring(0, 100)}`\n        });\n        logger.warn('Invalid cache file path, skipping cache load');\n        return null;\n      }\n      \n      const data = await fs.readFile(this.cacheFile, 'utf8');\n      const cache: CollectionCacheEntry = JSON.parse(data);\n      \n      // Check if cache is expired\n      if (Date.now() - cache.timestamp > this.CACHE_TTL_MS) {\n        logger.debug('Collection cache expired, will refresh from GitHub');\n        return null;\n      }\n      \n      logger.debug(`Loaded ${cache.items.length} items from collection cache`);\n      return cache;\n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug(`Failed to load collection cache: ${error}`);\n      }\n      return null;\n    }\n  }\n  \n  /**\n   * Save collection data to persistent cache\n   */\n  async saveCache(items: CollectionItem[], etag?: string): Promise<void> {\n    try {\n      await this.ensureCacheDir();\n      \n      const cacheEntry: CollectionCacheEntry = {\n        items,\n        timestamp: Date.now(),\n        etag\n      };\n      \n      const data = JSON.stringify(cacheEntry, null, 2);\n      await fs.writeFile(this.cacheFile, data, 'utf8');\n      \n      logger.debug(`Saved ${items.length} items to collection cache`);\n      \n      // SECURITY FIX: Add audit logging for cache write operations\n      logger.debug('Security audit: Cache write operation completed successfully');\n      \n      // Log operation completed successfully\n      logger.debug(`Cache file operation completed with ${items.length} items`);\n    } catch (error) {\n      logger.error(`Failed to save collection cache: ${error}`);\n      // Don't throw - caching failures shouldn't break functionality\n    }\n  }\n  \n  /**\n   * Search cached collection items with fuzzy matching\n   */\n  async searchCache(query: string): Promise<CollectionItem[]> {\n    const cache = await this.loadCache();\n    if (!cache) {\n      return [];\n    }\n    \n    const normalizedQuery = this.normalizeSearchTerm(query);\n    return cache.items.filter(item => {\n      // Search in filename and path with normalization\n      const normalizedName = this.normalizeSearchTerm(item.name);\n      const normalizedPath = this.normalizeSearchTerm(item.path);\n      \n      return normalizedName.includes(normalizedQuery) || \n             normalizedPath.includes(normalizedQuery) ||\n             (item.content && this.normalizeSearchTerm(item.content).includes(normalizedQuery));\n    });\n  }\n  \n  /**\n   * Normalize search terms for better matching (handles spaces, dashes, etc.)\n   */\n  private normalizeSearchTerm(term: string): string {\n    return term.toLowerCase()\n      .replace(/[-_\\s]+/g, ' ')  // Convert dashes, underscores to spaces\n      .replace(/\\.md$/, '')       // Remove .md extension\n      .trim();\n  }\n  \n  /**\n   * Get cached collection items by type/path\n   */\n  async getItemsByPath(pathPrefix: string): Promise<CollectionItem[]> {\n    const cache = await this.loadCache();\n    if (!cache) {\n      return [];\n    }\n    \n    return cache.items.filter(item => item.path.startsWith(pathPrefix));\n  }\n  \n  /**\n   * Check if cache exists and is valid\n   */\n  async isCacheValid(): Promise<boolean> {\n    const cache = await this.loadCache();\n    return cache !== null;\n  }\n  \n  /**\n   * Clear the cache\n   */\n  async clearCache(): Promise<void> {\n    try {\n      await fs.unlink(this.cacheFile);\n      logger.debug('Collection cache cleared');\n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug(`Failed to clear collection cache: ${error}`);\n      }\n    }\n  }\n  \n  /**\n   * Get cache stats for debugging\n   */\n  async getCacheStats(): Promise<{ itemCount: number; cacheAge: number; isValid: boolean }> {\n    const cache = await this.loadCache();\n    if (!cache) {\n      return { itemCount: 0, cacheAge: 0, isValid: false };\n    }\n    \n    return {\n      itemCount: cache.items.length,\n      cacheAge: Date.now() - cache.timestamp,\n      isValid: Date.now() - cache.timestamp <= this.CACHE_TTL_MS\n    };\n  }\n}"]}

package/dist/cache/CollectionIndexCache.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Smart cache for collection index with conditional fetching and performance optimization
+ */
+import { CollectionIndex } from '../types/collection.js';
+import { GitHubClient } from '../collection/GitHubClient.js';
+export declare class CollectionIndexCache {
+    private cache;
+    private readonly TTL;
+    private readonly INDEX_URL;
+    private cacheDir;
+    private cacheFile;
+    private githubClient;
+    private performanceMonitor;
+    private memoryCache;
+    private fetchPromise;
+    constructor(githubClient: GitHubClient, baseDir?: string);
+    /**
+     * Get the collection index with performance optimization and lazy loading
+     */
+    getIndex(lazyLoad?: boolean): Promise<CollectionIndex>;
+    /**
+     * Check if current cache is valid (within TTL)
+     */
+    private isValid;
+    /**
+     * Fetch fresh index from GitHub with conditional requests
+     */
+    private fetchFresh;
+    /**
+     * Validate the structure of a collection index
+     */
+    private validateIndexStructure;
+    /**
+     * Save cache to persistent storage
+     */
+    private saveToDisk;
+    /**
+     * Load cache from persistent storage
+     */
+    private loadFromDisk;
+    /**
+     * Ensure cache directory exists
+     */
+    private ensureCacheDir;
+    /**
+     * Clear all cache data with performance monitoring
+     */
+    clearCache(): Promise<void>;
+    /**
+     * Get comprehensive cache statistics for debugging and monitoring
+     */
+    getCacheStats(): {
+        isValid: boolean;
+        age: number;
+        hasCache: boolean;
+        elements: number;
+        memoryCache: any;
+        performanceMetrics: any;
+    };
+    /**
+     * Fetch fresh index with comprehensive fallback strategy
+     */
+    private fetchFreshWithFallback;
+    /**
+     * Record performance metrics for cache operations
+     */
+    private recordPerformanceMetrics;
+    /**
+     * Calculate cache hit rate (placeholder for future implementation)
+     */
+    private calculateCacheHitRate;
+    /**
+     * Calculate average access time (placeholder for future implementation)
+     */
+    private calculateAverageAccessTime;
+}
+//# sourceMappingURL=CollectionIndexCache.d.ts.map

package/dist/cache/CollectionIndexCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionIndexCache.d.ts","sourceRoot":"","sources":["../../src/cache/CollectionIndexCache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,eAAe,EAAe,MAAM,wBAAwB,CAAC;AAEtE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAK7D,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiG;IAC3H,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,YAAY,CAAyC;gBAEjD,YAAY,EAAE,YAAY,EAAE,OAAO,GAAE,MAAsB;IAiBvE;;OAEG;IACG,QAAQ,CAAC,QAAQ,GAAE,OAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAiEnE;;OAEG;IACH,OAAO,CAAC,OAAO;IASf;;OAEG;YACW,UAAU;IAiExB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAc9B;;OAEG;YACW,UAAU;IAmBxB;;OAEG;YACW,YAAY;IA4B1B;;OAEG;YACW,cAAc;IAS5B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAwBjC;;OAEG;IACH,aAAa,IAAI;QACf,OAAO,EAAE,OAAO,CAAC;QACjB,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,OAAO,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,GAAG,CAAC;QACjB,kBAAkB,EAAE,GAAG,CAAC;KACzB;IA8BD;;OAEG;YACW,sBAAsB;IAuBpC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAqBhC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;OAEG;IACH,OAAO,CAAC,0BAA0B;CAInC"}

package/dist/cache/CollectionIndexCache.js

@@ -0,0 +1,349 @@
+/**
+ * Smart cache for collection index with conditional fetching and performance optimization
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+import { CacheFactory } from './LRUCache.js';
+import { PerformanceMonitor } from '../utils/PerformanceMonitor.js';
+export class CollectionIndexCache {
+    cache = null;
+    TTL = 15 * 60 * 1000; // 15 minutes in milliseconds
+    INDEX_URL = 'https://raw.githubusercontent.com/DollhouseMCP/collection/main/public/collection-index.json';
+    cacheDir;
+    cacheFile;
+    githubClient;
+    performanceMonitor;
+    memoryCache;
+    fetchPromise = null; // Prevent concurrent fetches
+    constructor(githubClient, baseDir = process.cwd()) {
+        this.githubClient = githubClient;
+        this.cacheDir = path.join(baseDir, '.dollhousemcp', 'cache');
+        this.cacheFile = path.join(this.cacheDir, 'collection-index-cache.json');
+        this.performanceMonitor = PerformanceMonitor.getInstance();
+        // Initialize memory cache for frequently accessed data
+        this.memoryCache = CacheFactory.createAPICache({
+            maxSize: 50,
+            maxMemoryMB: 10,
+            ttlMs: 5 * 60 * 1000, // 5 minutes
+            onEviction: (key, value) => {
+                logger.debug('Collection memory cache eviction', { key });
+            }
+        });
+    }
+    /**
+     * Get the collection index with performance optimization and lazy loading
+     */
+    async getIndex(lazyLoad = false) {
+        const startTime = Date.now();
+        const memoryBefore = process.memoryUsage().heapUsed;
+        try {
+            // Check memory cache first for fastest access
+            const memoryCached = this.memoryCache.get('collection-index');
+            if (memoryCached && this.isValid()) {
+                logger.debug('Using memory cached collection index');
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'memory-hit');
+                return memoryCached;
+            }
+            // Check if we have valid disk cached data
+            if (this.isValid()) {
+                logger.debug('Using valid disk cached collection index');
+                const result = this.cache.data;
+                this.memoryCache.set('collection-index', result);
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'disk-hit');
+                return result;
+            }
+            // Prevent concurrent fetches
+            if (this.fetchPromise) {
+                logger.debug('Waiting for ongoing collection index fetch');
+                return await this.fetchPromise;
+            }
+            // Lazy loading: Only fetch if not in lazy mode or absolutely necessary
+            if (lazyLoad && this.cache?.data) {
+                logger.debug('Using stale cache in lazy load mode');
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'lazy-stale');
+                return this.cache.data;
+            }
+            // Create fetch promise to prevent concurrent requests
+            this.fetchPromise = this.fetchFreshWithFallback();
+            try {
+                const result = await this.fetchPromise;
+                this.memoryCache.set('collection-index', result);
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'fresh-fetch');
+                return result;
+            }
+            finally {
+                this.fetchPromise = null;
+            }
+        }
+        catch (error) {
+            logger.error('Failed to get collection index:', error);
+            // Try loading from persistent cache as last resort
+            const persistentCache = await this.loadFromDisk();
+            if (persistentCache) {
+                logger.debug('Using persistent cache as last resort');
+                this.cache = persistentCache;
+                const result = persistentCache.data;
+                this.memoryCache.set('collection-index', result);
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'disk-fallback');
+                return result;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Check if current cache is valid (within TTL)
+     */
+    isValid() {
+        if (!this.cache) {
+            return false;
+        }
+        const age = Date.now() - this.cache.fetchedAt.getTime();
+        return age < this.TTL;
+    }
+    /**
+     * Fetch fresh index from GitHub with conditional requests
+     */
+    async fetchFresh() {
+        try {
+            // Build headers for conditional request
+            const headers = {
+                'Accept': 'application/json',
+                'User-Agent': 'DollhouseMCP/1.0'
+            };
+            // Add conditional headers if we have cache
+            if (this.cache?.etag) {
+                headers['If-None-Match'] = this.cache.etag;
+            }
+            if (this.cache?.lastModified) {
+                headers['If-Modified-Since'] = this.cache.lastModified;
+            }
+            // Use fetch directly for better control over conditional requests
+            const response = await fetch(this.INDEX_URL, { headers });
+            // 304 Not Modified - use cached data
+            if (response.status === 304) {
+                if (this.cache) {
+                    // Update timestamp to extend cache validity
+                    this.cache.fetchedAt = new Date();
+                    await this.saveToDisk(this.cache);
+                    logger.debug('Collection index not modified - refreshed cache timestamp');
+                    return this.cache.data;
+                }
+            }
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const indexData = await response.json();
+            // Validate the index structure
+            if (!this.validateIndexStructure(indexData)) {
+                throw new Error('Invalid collection index structure received');
+            }
+            // Create new cache entry
+            const newCache = {
+                data: indexData,
+                fetchedAt: new Date(),
+                etag: response.headers.get('etag') || undefined,
+                lastModified: response.headers.get('last-modified') || undefined
+            };
+            this.cache = newCache;
+            // Save to persistent cache in background
+            this.saveToDisk(newCache).catch(error => {
+                logger.debug('Failed to save index cache to disk:', error);
+            });
+            logger.debug(`Fresh collection index fetched with ${indexData.total_elements} elements`);
+            return indexData;
+        }
+        catch (error) {
+            logger.debug('Failed to fetch fresh collection index:', error);
+            return null;
+        }
+    }
+    /**
+     * Validate the structure of a collection index
+     */
+    validateIndexStructure(index) {
+        return (index &&
+            typeof index === 'object' &&
+            typeof index.version === 'string' &&
+            typeof index.generated === 'string' &&
+            typeof index.total_elements === 'number' &&
+            index.index &&
+            typeof index.index === 'object' &&
+            index.metadata &&
+            typeof index.metadata === 'object');
+    }
+    /**
+     * Save cache to persistent storage
+     */
+    async saveToDisk(cache) {
+        try {
+            await this.ensureCacheDir();
+            const cacheData = {
+                ...cache,
+                fetchedAt: cache.fetchedAt.toISOString() // Serialize date
+            };
+            const data = JSON.stringify(cacheData, null, 2);
+            await fs.writeFile(this.cacheFile, data, 'utf8');
+            logger.debug('Collection index cache saved to disk');
+        }
+        catch (error) {
+            logger.debug('Failed to save collection index cache:', error);
+            // Don't throw - cache persistence failures shouldn't break functionality
+        }
+    }
+    /**
+     * Load cache from persistent storage
+     */
+    async loadFromDisk() {
+        try {
+            // Basic security check for path traversal
+            if (this.cacheFile.includes('..') || this.cacheFile.includes('\0')) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'PATH_TRAVERSAL_ATTEMPT',
+                    severity: 'HIGH',
+                    source: 'CollectionIndexCache.loadFromDisk',
+                    details: `Potential path traversal attempt detected: ${this.cacheFile.substring(0, 100)}`
+                });
+                return null;
+            }
+            const data = await fs.readFile(this.cacheFile, 'utf8');
+            const cacheData = JSON.parse(data);
+            return {
+                ...cacheData,
+                fetchedAt: new Date(cacheData.fetchedAt) // Deserialize date
+            };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.debug('Failed to load collection index cache from disk:', error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Ensure cache directory exists
+     */
+    async ensureCacheDir() {
+        try {
+            await fs.mkdir(this.cacheDir, { recursive: true });
+        }
+        catch (error) {
+            logger.error('Failed to create cache directory:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear all cache data with performance monitoring
+     */
+    async clearCache() {
+        const startTime = Date.now();
+        this.cache = null;
+        this.memoryCache.clear();
+        // Cancel any ongoing fetch
+        this.fetchPromise = null;
+        try {
+            await fs.unlink(this.cacheFile);
+            logger.debug('Collection index cache cleared from disk');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.debug('Failed to clear collection index cache:', error);
+            }
+        }
+        logger.debug('Collection cache cleared', {
+            duration: Date.now() - startTime,
+            memoryFreed: this.memoryCache.getMemoryUsageMB()
+        });
+    }
+    /**
+     * Get comprehensive cache statistics for debugging and monitoring
+     */
+    getCacheStats() {
+        if (!this.cache) {
+            return {
+                isValid: false,
+                age: 0,
+                hasCache: false,
+                elements: 0,
+                memoryCache: this.memoryCache.getStats(),
+                performanceMetrics: null
+            };
+        }
+        const age = Date.now() - this.cache.fetchedAt.getTime();
+        return {
+            isValid: this.isValid(),
+            age,
+            hasCache: true,
+            elements: this.cache.data.total_elements,
+            memoryCache: this.memoryCache.getStats(),
+            performanceMetrics: {
+                cacheHitRate: this.calculateCacheHitRate(),
+                averageAccessTime: this.calculateAverageAccessTime()
+            }
+        };
+    }
+    // =====================================================
+    // PRIVATE HELPER METHODS FOR PERFORMANCE
+    // =====================================================
+    /**
+     * Fetch fresh index with comprehensive fallback strategy
+     */
+    async fetchFreshWithFallback() {
+        try {
+            // Try to fetch fresh index
+            const freshIndex = await this.fetchFresh();
+            if (freshIndex) {
+                logger.debug('Collection index fetched successfully');
+                return freshIndex;
+            }
+        }
+        catch (error) {
+            logger.warn('Fresh fetch failed, trying fallback', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        // Fall back to stale cache if available
+        if (this.cache?.data) {
+            logger.debug('Using stale cached collection index as fallback');
+            return this.cache.data;
+        }
+        throw new Error('No collection index available - fresh fetch failed and no cache exists');
+    }
+    /**
+     * Record performance metrics for cache operations
+     */
+    recordPerformanceMetrics(startTime, memoryBefore, operation) {
+        const duration = Date.now() - startTime;
+        const memoryAfter = process.memoryUsage().heapUsed;
+        logger.debug('Collection cache operation completed', {
+            operation,
+            duration,
+            memoryUsageMB: (memoryAfter - memoryBefore) / (1024 * 1024)
+        });
+        // Record cache performance metrics
+        this.performanceMonitor.recordCachePerformance('collectionIndex', {
+            hitRate: operation.includes('hit') ? 1 : 0,
+            avgHitTime: operation.includes('hit') ? duration : 0,
+            avgMissTime: operation.includes('hit') ? 0 : duration,
+            totalHits: operation.includes('hit') ? 1 : 0,
+            totalMisses: operation.includes('hit') ? 0 : 1,
+            evictions: 0
+        });
+    }
+    /**
+     * Calculate cache hit rate (placeholder for future implementation)
+     */
+    calculateCacheHitRate() {
+        // This would be implemented with actual metrics tracking
+        return this.memoryCache.getStats().hitRate;
+    }
+    /**
+     * Calculate average access time (placeholder for future implementation)
+     */
+    calculateAverageAccessTime() {
+        // This would be implemented with actual timing metrics
+        return 5; // Placeholder value
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionIndexCache.js","sourceRoot":"","sources":["../../src/cache/CollectionIndexCache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Smart cache for collection index with conditional fetching and performance optimization\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { CollectionIndex, CachedIndex } from '../types/collection.js';\nimport { logger } from '../utils/logger.js';\nimport { GitHubClient } from '../collection/GitHubClient.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { LRUCache, CacheFactory } from './LRUCache.js';\nimport { PerformanceMonitor } from '../utils/PerformanceMonitor.js';\n\nexport class CollectionIndexCache {\n  private cache: CachedIndex | null = null;\n  private readonly TTL = 15 * 60 * 1000; // 15 minutes in milliseconds\n  private readonly INDEX_URL = 'https://raw.githubusercontent.com/DollhouseMCP/collection/main/public/collection-index.json';\n  private cacheDir: string;\n  private cacheFile: string;\n  private githubClient: GitHubClient;\n  private performanceMonitor: PerformanceMonitor;\n  private memoryCache: LRUCache<any>;\n  private fetchPromise: Promise<CollectionIndex> | null = null; // Prevent concurrent fetches\n  \n  constructor(githubClient: GitHubClient, baseDir: string = process.cwd()) {\n    this.githubClient = githubClient;\n    this.cacheDir = path.join(baseDir, '.dollhousemcp', 'cache');\n    this.cacheFile = path.join(this.cacheDir, 'collection-index-cache.json');\n    this.performanceMonitor = PerformanceMonitor.getInstance();\n    \n    // Initialize memory cache for frequently accessed data\n    this.memoryCache = CacheFactory.createAPICache({\n      maxSize: 50,\n      maxMemoryMB: 10,\n      ttlMs: 5 * 60 * 1000, // 5 minutes\n      onEviction: (key, value) => {\n        logger.debug('Collection memory cache eviction', { key });\n      }\n    });\n  }\n  \n  /**\n   * Get the collection index with performance optimization and lazy loading\n   */\n  async getIndex(lazyLoad: boolean = false): Promise<CollectionIndex> {\n    const startTime = Date.now();\n    const memoryBefore = process.memoryUsage().heapUsed;\n    \n    try {\n      // Check memory cache first for fastest access\n      const memoryCached = this.memoryCache.get('collection-index');\n      if (memoryCached && this.isValid()) {\n        logger.debug('Using memory cached collection index');\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'memory-hit');\n        return memoryCached;\n      }\n      \n      // Check if we have valid disk cached data\n      if (this.isValid()) {\n        logger.debug('Using valid disk cached collection index');\n        const result = this.cache!.data;\n        this.memoryCache.set('collection-index', result);\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'disk-hit');\n        return result;\n      }\n      \n      // Prevent concurrent fetches\n      if (this.fetchPromise) {\n        logger.debug('Waiting for ongoing collection index fetch');\n        return await this.fetchPromise;\n      }\n      \n      // Lazy loading: Only fetch if not in lazy mode or absolutely necessary\n      if (lazyLoad && this.cache?.data) {\n        logger.debug('Using stale cache in lazy load mode');\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'lazy-stale');\n        return this.cache.data;\n      }\n      \n      // Create fetch promise to prevent concurrent requests\n      this.fetchPromise = this.fetchFreshWithFallback();\n      \n      try {\n        const result = await this.fetchPromise;\n        this.memoryCache.set('collection-index', result);\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'fresh-fetch');\n        return result;\n      } finally {\n        this.fetchPromise = null;\n      }\n      \n    } catch (error) {\n      logger.error('Failed to get collection index:', error);\n      \n      // Try loading from persistent cache as last resort\n      const persistentCache = await this.loadFromDisk();\n      if (persistentCache) {\n        logger.debug('Using persistent cache as last resort');\n        this.cache = persistentCache;\n        const result = persistentCache.data;\n        this.memoryCache.set('collection-index', result);\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'disk-fallback');\n        return result;\n      }\n      \n      throw error;\n    }\n  }\n  \n  /**\n   * Check if current cache is valid (within TTL)\n   */\n  private isValid(): boolean {\n    if (!this.cache) {\n      return false;\n    }\n    \n    const age = Date.now() - this.cache.fetchedAt.getTime();\n    return age < this.TTL;\n  }\n  \n  /**\n   * Fetch fresh index from GitHub with conditional requests\n   */\n  private async fetchFresh(): Promise<CollectionIndex | null> {\n    try {\n      // Build headers for conditional request\n      const headers: Record<string, string> = {\n        'Accept': 'application/json',\n        'User-Agent': 'DollhouseMCP/1.0'\n      };\n      \n      // Add conditional headers if we have cache\n      if (this.cache?.etag) {\n        headers['If-None-Match'] = this.cache.etag;\n      }\n      if (this.cache?.lastModified) {\n        headers['If-Modified-Since'] = this.cache.lastModified;\n      }\n      \n      // Use fetch directly for better control over conditional requests\n      const response = await fetch(this.INDEX_URL, { headers });\n      \n      // 304 Not Modified - use cached data\n      if (response.status === 304) {\n        if (this.cache) {\n          // Update timestamp to extend cache validity\n          this.cache.fetchedAt = new Date();\n          await this.saveToDisk(this.cache);\n          logger.debug('Collection index not modified - refreshed cache timestamp');\n          return this.cache.data;\n        }\n      }\n      \n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n      \n      const indexData = await response.json() as CollectionIndex;\n      \n      // Validate the index structure\n      if (!this.validateIndexStructure(indexData)) {\n        throw new Error('Invalid collection index structure received');\n      }\n      \n      // Create new cache entry\n      const newCache: CachedIndex = {\n        data: indexData,\n        fetchedAt: new Date(),\n        etag: response.headers.get('etag') || undefined,\n        lastModified: response.headers.get('last-modified') || undefined\n      };\n      \n      this.cache = newCache;\n      \n      // Save to persistent cache in background\n      this.saveToDisk(newCache).catch(error => {\n        logger.debug('Failed to save index cache to disk:', error);\n      });\n      \n      logger.debug(`Fresh collection index fetched with ${indexData.total_elements} elements`);\n      return indexData;\n      \n    } catch (error) {\n      logger.debug('Failed to fetch fresh collection index:', error);\n      return null;\n    }\n  }\n  \n  /**\n   * Validate the structure of a collection index\n   */\n  private validateIndexStructure(index: any): index is CollectionIndex {\n    return (\n      index &&\n      typeof index === 'object' &&\n      typeof index.version === 'string' &&\n      typeof index.generated === 'string' &&\n      typeof index.total_elements === 'number' &&\n      index.index &&\n      typeof index.index === 'object' &&\n      index.metadata &&\n      typeof index.metadata === 'object'\n    );\n  }\n  \n  /**\n   * Save cache to persistent storage\n   */\n  private async saveToDisk(cache: CachedIndex): Promise<void> {\n    try {\n      await this.ensureCacheDir();\n      \n      const cacheData = {\n        ...cache,\n        fetchedAt: cache.fetchedAt.toISOString() // Serialize date\n      };\n      \n      const data = JSON.stringify(cacheData, null, 2);\n      await fs.writeFile(this.cacheFile, data, 'utf8');\n      \n      logger.debug('Collection index cache saved to disk');\n    } catch (error) {\n      logger.debug('Failed to save collection index cache:', error);\n      // Don't throw - cache persistence failures shouldn't break functionality\n    }\n  }\n  \n  /**\n   * Load cache from persistent storage\n   */\n  private async loadFromDisk(): Promise<CachedIndex | null> {\n    try {\n      // Basic security check for path traversal\n      if (this.cacheFile.includes('..') || this.cacheFile.includes('\\0')) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'PATH_TRAVERSAL_ATTEMPT',\n          severity: 'HIGH',\n          source: 'CollectionIndexCache.loadFromDisk',\n          details: `Potential path traversal attempt detected: ${this.cacheFile.substring(0, 100)}`\n        });\n        return null;\n      }\n      \n      const data = await fs.readFile(this.cacheFile, 'utf8');\n      const cacheData = JSON.parse(data);\n      \n      return {\n        ...cacheData,\n        fetchedAt: new Date(cacheData.fetchedAt) // Deserialize date\n      };\n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug('Failed to load collection index cache from disk:', error);\n      }\n      return null;\n    }\n  }\n  \n  /**\n   * Ensure cache directory exists\n   */\n  private async ensureCacheDir(): Promise<void> {\n    try {\n      await fs.mkdir(this.cacheDir, { recursive: true });\n    } catch (error) {\n      logger.error('Failed to create cache directory:', error);\n      throw error;\n    }\n  }\n  \n  /**\n   * Clear all cache data with performance monitoring\n   */\n  async clearCache(): Promise<void> {\n    const startTime = Date.now();\n    \n    this.cache = null;\n    this.memoryCache.clear();\n    \n    // Cancel any ongoing fetch\n    this.fetchPromise = null;\n    \n    try {\n      await fs.unlink(this.cacheFile);\n      logger.debug('Collection index cache cleared from disk');\n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug('Failed to clear collection index cache:', error);\n      }\n    }\n    \n    logger.debug('Collection cache cleared', {\n      duration: Date.now() - startTime,\n      memoryFreed: this.memoryCache.getMemoryUsageMB()\n    });\n  }\n  \n  /**\n   * Get comprehensive cache statistics for debugging and monitoring\n   */\n  getCacheStats(): { \n    isValid: boolean; \n    age: number; \n    hasCache: boolean; \n    elements: number;\n    memoryCache: any;\n    performanceMetrics: any;\n  } {\n    if (!this.cache) {\n      return { \n        isValid: false, \n        age: 0, \n        hasCache: false, \n        elements: 0,\n        memoryCache: this.memoryCache.getStats(),\n        performanceMetrics: null\n      };\n    }\n    \n    const age = Date.now() - this.cache.fetchedAt.getTime();\n    return {\n      isValid: this.isValid(),\n      age,\n      hasCache: true,\n      elements: this.cache.data.total_elements,\n      memoryCache: this.memoryCache.getStats(),\n      performanceMetrics: {\n        cacheHitRate: this.calculateCacheHitRate(),\n        averageAccessTime: this.calculateAverageAccessTime()\n      }\n    };\n  }\n  \n  // =====================================================\n  // PRIVATE HELPER METHODS FOR PERFORMANCE\n  // =====================================================\n  \n  /**\n   * Fetch fresh index with comprehensive fallback strategy\n   */\n  private async fetchFreshWithFallback(): Promise<CollectionIndex> {\n    try {\n      // Try to fetch fresh index\n      const freshIndex = await this.fetchFresh();\n      if (freshIndex) {\n        logger.debug('Collection index fetched successfully');\n        return freshIndex;\n      }\n    } catch (error) {\n      logger.warn('Fresh fetch failed, trying fallback', {\n        error: error instanceof Error ? error.message : String(error)\n      });\n    }\n    \n    // Fall back to stale cache if available\n    if (this.cache?.data) {\n      logger.debug('Using stale cached collection index as fallback');\n      return this.cache.data;\n    }\n    \n    throw new Error('No collection index available - fresh fetch failed and no cache exists');\n  }\n  \n  /**\n   * Record performance metrics for cache operations\n   */\n  private recordPerformanceMetrics(startTime: number, memoryBefore: number, operation: string): void {\n    const duration = Date.now() - startTime;\n    const memoryAfter = process.memoryUsage().heapUsed;\n    \n    logger.debug('Collection cache operation completed', {\n      operation,\n      duration,\n      memoryUsageMB: (memoryAfter - memoryBefore) / (1024 * 1024)\n    });\n    \n    // Record cache performance metrics\n    this.performanceMonitor.recordCachePerformance('collectionIndex', {\n      hitRate: operation.includes('hit') ? 1 : 0,\n      avgHitTime: operation.includes('hit') ? duration : 0,\n      avgMissTime: operation.includes('hit') ? 0 : duration,\n      totalHits: operation.includes('hit') ? 1 : 0,\n      totalMisses: operation.includes('hit') ? 0 : 1,\n      evictions: 0\n    });\n  }\n  \n  /**\n   * Calculate cache hit rate (placeholder for future implementation)\n   */\n  private calculateCacheHitRate(): number {\n    // This would be implemented with actual metrics tracking\n    return this.memoryCache.getStats().hitRate;\n  }\n  \n  /**\n   * Calculate average access time (placeholder for future implementation)\n   */\n  private calculateAverageAccessTime(): number {\n    // This would be implemented with actual timing metrics\n    return 5; // Placeholder value\n  }\n}"]}