@dollhousemcp/mcp-server 1.5.1 → 1.6.0

package/dist/cache/CollectionCache.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Persistent cache for collection data to support offline/anonymous browsing
+ */
+export interface CollectionItem {
+    name: string;
+    path: string;
+    sha: string;
+    content?: string;
+    last_modified?: string;
+}
+export interface CollectionCacheEntry {
+    items: CollectionItem[];
+    timestamp: number;
+    etag?: string;
+}
+/**
+ * Persistent cache for collection data that supports offline browsing
+ */
+export declare class CollectionCache {
+    private cacheDir;
+    private cacheFile;
+    private readonly CACHE_TTL_MS;
+    constructor(baseDir?: string);
+    /**
+     * Initialize cache directory
+     */
+    private ensureCacheDir;
+    /**
+     * Load collection data from persistent cache
+     */
+    loadCache(): Promise<CollectionCacheEntry | null>;
+    /**
+     * Save collection data to persistent cache
+     */
+    saveCache(items: CollectionItem[], etag?: string): Promise<void>;
+    /**
+     * Search cached collection items with fuzzy matching
+     */
+    searchCache(query: string): Promise<CollectionItem[]>;
+    /**
+     * Normalize search terms for better matching (handles spaces, dashes, etc.)
+     */
+    private normalizeSearchTerm;
+    /**
+     * Get cached collection items by type/path
+     */
+    getItemsByPath(pathPrefix: string): Promise<CollectionItem[]>;
+    /**
+     * Check if cache exists and is valid
+     */
+    isCacheValid(): Promise<boolean>;
+    /**
+     * Clear the cache
+     */
+    clearCache(): Promise<void>;
+    /**
+     * Get cache stats for debugging
+     */
+    getCacheStats(): Promise<{
+        itemCount: number;
+        cacheAge: number;
+        isValid: boolean;
+    }>;
+}
+//# sourceMappingURL=CollectionCache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionCache.d.ts","sourceRoot":"","sources":["../../src/cache/CollectionCache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuB;gBAExC,OAAO,CAAC,EAAE,MAAM;IAc5B;;OAEG;YACW,cAAc;IAS5B;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAkCvD;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BtE;;OAEG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAkB3D;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;OAEG;IACG,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IASnE;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAKtC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAWjC;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAY1F"}

package/dist/cache/CollectionCache.js

@@ -0,0 +1,172 @@
+/**
+ * Persistent cache for collection data to support offline/anonymous browsing
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+/**
+ * Persistent cache for collection data that supports offline browsing
+ */
+export class CollectionCache {
+    cacheDir;
+    cacheFile;
+    CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours for collection 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');
+    }
+    /**
+     * Initialize cache directory
+     */
+    async ensureCacheDir() {
+        try {
+            await fs.mkdir(this.cacheDir, { recursive: true });
+        }
+        catch (error) {
+            logger.error(`Failed to create cache directory: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Load collection data from persistent cache
+     */
+    async loadCache() {
+        try {
+            // Validate cache file path (basic security check)
+            if (this.cacheFile.includes('..') || this.cacheFile.includes('\0')) {
+                // SECURITY FIX: Add audit logging for path traversal attempt detection
+                SecurityMonitor.logSecurityEvent({
+                    type: 'PATH_TRAVERSAL_ATTEMPT',
+                    severity: 'HIGH',
+                    source: 'CollectionCache.loadCache',
+                    details: `Potential path traversal attempt detected in cache file path: ${this.cacheFile.substring(0, 100)}`
+                });
+                logger.warn('Invalid cache file path, skipping cache load');
+                return null;
+            }
+            const data = await fs.readFile(this.cacheFile, 'utf8');
+            const cache = JSON.parse(data);
+            // Check if cache is expired
+            if (Date.now() - cache.timestamp > this.CACHE_TTL_MS) {
+                logger.debug('Collection cache expired, will refresh from GitHub');
+                return null;
+            }
+            logger.debug(`Loaded ${cache.items.length} items from collection cache`);
+            return cache;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.debug(`Failed to load collection cache: ${error}`);
+            }
+            return null;
+        }
+    }
+    /**
+     * Save collection data to persistent cache
+     */
+    async saveCache(items, etag) {
+        try {
+            await this.ensureCacheDir();
+            const cacheEntry = {
+                items,
+                timestamp: Date.now(),
+                etag
+            };
+            const data = JSON.stringify(cacheEntry, null, 2);
+            await fs.writeFile(this.cacheFile, data, 'utf8');
+            logger.debug(`Saved ${items.length} items to collection cache`);
+            // SECURITY FIX: Add audit logging for cache write operations
+            logger.debug('Security audit: Cache write operation completed successfully');
+            // Log operation completed successfully
+            logger.debug(`Cache file operation completed with ${items.length} items`);
+        }
+        catch (error) {
+            logger.error(`Failed to save collection cache: ${error}`);
+            // Don't throw - caching failures shouldn't break functionality
+        }
+    }
+    /**
+     * Search cached collection items with fuzzy matching
+     */
+    async searchCache(query) {
+        const cache = await this.loadCache();
+        if (!cache) {
+            return [];
+        }
+        const normalizedQuery = this.normalizeSearchTerm(query);
+        return cache.items.filter(item => {
+            // Search in filename and path with normalization
+            const normalizedName = this.normalizeSearchTerm(item.name);
+            const normalizedPath = this.normalizeSearchTerm(item.path);
+            return normalizedName.includes(normalizedQuery) ||
+                normalizedPath.includes(normalizedQuery) ||
+                (item.content && this.normalizeSearchTerm(item.content).includes(normalizedQuery));
+        });
+    }
+    /**
+     * Normalize search terms for better matching (handles spaces, dashes, etc.)
+     */
+    normalizeSearchTerm(term) {
+        return term.toLowerCase()
+            .replace(/[-_\s]+/g, ' ') // Convert dashes, underscores to spaces
+            .replace(/\.md$/, '') // Remove .md extension
+            .trim();
+    }
+    /**
+     * Get cached collection items by type/path
+     */
+    async getItemsByPath(pathPrefix) {
+        const cache = await this.loadCache();
+        if (!cache) {
+            return [];
+        }
+        return cache.items.filter(item => item.path.startsWith(pathPrefix));
+    }
+    /**
+     * Check if cache exists and is valid
+     */
+    async isCacheValid() {
+        const cache = await this.loadCache();
+        return cache !== null;
+    }
+    /**
+     * Clear the cache
+     */
+    async clearCache() {
+        try {
+            await fs.unlink(this.cacheFile);
+            logger.debug('Collection cache cleared');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.debug(`Failed to clear collection cache: ${error}`);
+            }
+        }
+    }
+    /**
+     * Get cache stats for debugging
+     */
+    async getCacheStats() {
+        const cache = await this.loadCache();
+        if (!cache) {
+            return { itemCount: 0, cacheAge: 0, isValid: false };
+        }
+        return {
+            itemCount: cache.items.length,
+            cacheAge: Date.now() - cache.timestamp,
+            isValid: Date.now() - cache.timestamp <= this.CACHE_TTL_MS
+        };
+    }
+}
+//# 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"}