@dollhousemcp/mcp-server 1.5.1 → 1.6.0

package/dist/utils/installation.js

@@ -6,13 +6,10 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { logger } from './logger.js';
-import { UpdateConfigManager } from '../config/updateConfig.js';
 export class InstallationDetector {
     static cachedType = null;
     // Maximum directory levels to search upward for .git directory
-    static get MAX_SEARCH_DEPTH() {
-        return UpdateConfigManager.getInstance().getMaxSearchDepth();
-    }
+    static MAX_SEARCH_DEPTH = 10;
     /**
      * Detect the installation type (npm global, git clone, or unknown)
      */
@@ -36,8 +33,10 @@ export class InstallationDetector {
             }
             // Check if we're in a node_modules directory (npm installation)
             // Use path separator to ensure we match the exact package name
-            const npmPattern = path.sep + path.join('node_modules', '@dollhousemcp', 'mcp-server') + path.sep;
-            if (currentDir.includes(npmPattern)) {
+            // Normalize the path to handle both Windows and Unix separators
+            const normalizedCurrentDir = path.normalize(currentDir);
+            const npmPattern = path.normalize(path.join('node_modules', '@dollhousemcp', 'mcp-server'));
+            if (normalizedCurrentDir.includes(npmPattern)) {
                 logger.debug('[InstallationDetector] Detected npm installation');
                 this.cachedType = 'npm';
                 return 'npm';
@@ -86,7 +85,9 @@ export class InstallationDetector {
             const currentFilePath = fileURLToPath(currentFileUrl);
             let currentDir = path.dirname(currentFilePath);
             // Find the root of the npm package
-            while (currentDir.includes('node_modules/@dollhousemcp/mcp-server')) {
+            // Normalize paths to handle Windows and Unix separators
+            const npmPackagePattern = path.normalize('node_modules/@dollhousemcp/mcp-server');
+            while (path.normalize(currentDir).includes(npmPackagePattern)) {
                 const packageJsonPath = path.join(currentDir, 'package.json');
                 if (fs.existsSync(packageJsonPath)) {
                     return currentDir;
@@ -157,4 +158,4 @@ export class InstallationDetector {
         this.cachedType = null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"installation.js","sourceRoot":"","sources":["../../src/utils/installation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Installation detection utilities\n * Determines whether the application is running from npm or git installation\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\nimport { logger } from './logger.js';\nimport { UpdateConfigManager } from '../config/updateConfig.js';\n\nexport type InstallationType = 'npm' | 'git' | 'unknown';\n\nexport class InstallationDetector {\n  private static cachedType: InstallationType | null = null;\n  \n  // Maximum directory levels to search upward for .git directory\n  private static get MAX_SEARCH_DEPTH(): number {\n    return UpdateConfigManager.getInstance().getMaxSearchDepth();\n  }\n  \n  /**\n   * Detect the installation type (npm global, git clone, or unknown)\n   */\n  static getInstallationType(): InstallationType {\n    // Return cached result if available\n    if (this.cachedType !== null) {\n      return this.cachedType;\n    }\n    \n    try {\n      // Get the directory where this file is located\n      const currentFileUrl = import.meta.url;\n      const currentFilePath = fileURLToPath(currentFileUrl);\n      let currentDir = path.dirname(currentFilePath);\n      \n      // Resolve symlinks to get the real path\n      try {\n        currentDir = fs.realpathSync(currentDir);\n      } catch (error) {\n        // If realpath fails, continue with original path\n        logger.debug('[InstallationDetector] Could not resolve real path, using original');\n      }\n      \n      // Check if we're in a node_modules directory (npm installation)\n      // Use path separator to ensure we match the exact package name\n      const npmPattern = path.sep + path.join('node_modules', '@dollhousemcp', 'mcp-server') + path.sep;\n      if (currentDir.includes(npmPattern)) {\n        logger.debug('[InstallationDetector] Detected npm installation');\n        this.cachedType = 'npm';\n        return 'npm';\n      }\n      \n      // Check for .git directory (git installation)\n      // Search up from current directory\n      let searchDir = currentDir;\n      for (let i = 0; i < this.MAX_SEARCH_DEPTH; i++) {\n        const gitDir = path.join(searchDir, '.git');\n        try {\n          if (fs.existsSync(gitDir) && fs.statSync(gitDir).isDirectory()) {\n            logger.debug('[InstallationDetector] Detected git installation');\n            this.cachedType = 'git';\n            return 'git';\n          }\n        } catch (error) {\n          // Ignore errors and continue searching\n        }\n        \n        const parentDir = path.dirname(searchDir);\n        if (parentDir === searchDir) {\n          // Reached root directory\n          break;\n        }\n        searchDir = parentDir;\n      }\n      \n      logger.warn('[InstallationDetector] Could not determine installation type');\n      this.cachedType = 'unknown';\n      return 'unknown';\n    } catch (error) {\n      logger.error('[InstallationDetector] Error detecting installation type:', error);\n      this.cachedType = 'unknown';\n      return 'unknown';\n    }\n  }\n  \n  /**\n   * Get the npm global installation path if running from npm\n   */\n  static getNpmGlobalPath(): string | null {\n    if (this.getInstallationType() !== 'npm') {\n      return null;\n    }\n    \n    try {\n      const currentFileUrl = import.meta.url;\n      const currentFilePath = fileURLToPath(currentFileUrl);\n      let currentDir = path.dirname(currentFilePath);\n      \n      // Find the root of the npm package\n      while (currentDir.includes('node_modules/@dollhousemcp/mcp-server')) {\n        const packageJsonPath = path.join(currentDir, 'package.json');\n        if (fs.existsSync(packageJsonPath)) {\n          return currentDir;\n        }\n        const parentDir = path.dirname(currentDir);\n        if (parentDir === currentDir) break;\n        currentDir = parentDir;\n      }\n    } catch (error) {\n      logger.error('[InstallationDetector] Error finding npm global path:', error);\n    }\n    \n    return null;\n  }\n  \n  /**\n   * Get the git repository root path if running from git\n   */\n  static getGitRepositoryPath(): string | null {\n    if (this.getInstallationType() !== 'git') {\n      return null;\n    }\n    \n    try {\n      const currentFileUrl = import.meta.url;\n      const currentFilePath = fileURLToPath(currentFileUrl);\n      let currentDir = path.dirname(currentFilePath);\n      \n      // Search up for .git directory\n      for (let i = 0; i < 10; i++) {\n        const gitDir = path.join(currentDir, '.git');\n        if (fs.existsSync(gitDir) && fs.statSync(gitDir).isDirectory()) {\n          return currentDir;\n        }\n        \n        const parentDir = path.dirname(currentDir);\n        if (parentDir === currentDir) break;\n        currentDir = parentDir;\n      }\n    } catch (error) {\n      logger.error('[InstallationDetector] Error finding git repository path:', error);\n    }\n    \n    return null;\n  }\n  \n  /**\n   * Get a human-readable description of the installation\n   */\n  static getInstallationDescription(): string {\n    const type = this.getInstallationType();\n    \n    switch (type) {\n      case 'npm':\n        const npmPath = this.getNpmGlobalPath();\n        return npmPath \n          ? `npm global installation at ${npmPath}`\n          : 'npm global installation';\n          \n      case 'git':\n        const gitPath = this.getGitRepositoryPath();\n        return gitPath\n          ? `git installation at ${gitPath}`\n          : 'git installation';\n          \n      default:\n        return 'unknown installation type';\n    }\n  }\n  \n  /**\n   * Clear the cached installation type (mainly for testing)\n   */\n  static clearCache(): void {\n    this.cachedType = null;\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"installation.js","sourceRoot":"","sources":["../../src/utils/installation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Installation detection utilities\n * Determines whether the application is running from npm or git installation\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\nimport { logger } from './logger.js';\n\nexport type InstallationType = 'npm' | 'git' | 'unknown';\n\nexport class InstallationDetector {\n  private static cachedType: InstallationType | null = null;\n  \n  // Maximum directory levels to search upward for .git directory\n  private static readonly MAX_SEARCH_DEPTH = 10;\n  \n  /**\n   * Detect the installation type (npm global, git clone, or unknown)\n   */\n  static getInstallationType(): InstallationType {\n    // Return cached result if available\n    if (this.cachedType !== null) {\n      return this.cachedType;\n    }\n    \n    try {\n      // Get the directory where this file is located\n      const currentFileUrl = import.meta.url;\n      const currentFilePath = fileURLToPath(currentFileUrl);\n      let currentDir = path.dirname(currentFilePath);\n      \n      // Resolve symlinks to get the real path\n      try {\n        currentDir = fs.realpathSync(currentDir);\n      } catch (error) {\n        // If realpath fails, continue with original path\n        logger.debug('[InstallationDetector] Could not resolve real path, using original');\n      }\n      \n      // Check if we're in a node_modules directory (npm installation)\n      // Use path separator to ensure we match the exact package name\n      // Normalize the path to handle both Windows and Unix separators\n      const normalizedCurrentDir = path.normalize(currentDir);\n      const npmPattern = path.normalize(path.join('node_modules', '@dollhousemcp', 'mcp-server'));\n      if (normalizedCurrentDir.includes(npmPattern)) {\n        logger.debug('[InstallationDetector] Detected npm installation');\n        this.cachedType = 'npm';\n        return 'npm';\n      }\n      \n      // Check for .git directory (git installation)\n      // Search up from current directory\n      let searchDir = currentDir;\n      for (let i = 0; i < this.MAX_SEARCH_DEPTH; i++) {\n        const gitDir = path.join(searchDir, '.git');\n        try {\n          if (fs.existsSync(gitDir) && fs.statSync(gitDir).isDirectory()) {\n            logger.debug('[InstallationDetector] Detected git installation');\n            this.cachedType = 'git';\n            return 'git';\n          }\n        } catch (error) {\n          // Ignore errors and continue searching\n        }\n        \n        const parentDir = path.dirname(searchDir);\n        if (parentDir === searchDir) {\n          // Reached root directory\n          break;\n        }\n        searchDir = parentDir;\n      }\n      \n      logger.warn('[InstallationDetector] Could not determine installation type');\n      this.cachedType = 'unknown';\n      return 'unknown';\n    } catch (error) {\n      logger.error('[InstallationDetector] Error detecting installation type:', error);\n      this.cachedType = 'unknown';\n      return 'unknown';\n    }\n  }\n  \n  /**\n   * Get the npm global installation path if running from npm\n   */\n  static getNpmGlobalPath(): string | null {\n    if (this.getInstallationType() !== 'npm') {\n      return null;\n    }\n    \n    try {\n      const currentFileUrl = import.meta.url;\n      const currentFilePath = fileURLToPath(currentFileUrl);\n      let currentDir = path.dirname(currentFilePath);\n      \n      // Find the root of the npm package\n      // Normalize paths to handle Windows and Unix separators\n      const npmPackagePattern = path.normalize('node_modules/@dollhousemcp/mcp-server');\n      while (path.normalize(currentDir).includes(npmPackagePattern)) {\n        const packageJsonPath = path.join(currentDir, 'package.json');\n        if (fs.existsSync(packageJsonPath)) {\n          return currentDir;\n        }\n        const parentDir = path.dirname(currentDir);\n        if (parentDir === currentDir) break;\n        currentDir = parentDir;\n      }\n    } catch (error) {\n      logger.error('[InstallationDetector] Error finding npm global path:', error);\n    }\n    \n    return null;\n  }\n  \n  /**\n   * Get the git repository root path if running from git\n   */\n  static getGitRepositoryPath(): string | null {\n    if (this.getInstallationType() !== 'git') {\n      return null;\n    }\n    \n    try {\n      const currentFileUrl = import.meta.url;\n      const currentFilePath = fileURLToPath(currentFileUrl);\n      let currentDir = path.dirname(currentFilePath);\n      \n      // Search up for .git directory\n      for (let i = 0; i < 10; i++) {\n        const gitDir = path.join(currentDir, '.git');\n        if (fs.existsSync(gitDir) && fs.statSync(gitDir).isDirectory()) {\n          return currentDir;\n        }\n        \n        const parentDir = path.dirname(currentDir);\n        if (parentDir === currentDir) break;\n        currentDir = parentDir;\n      }\n    } catch (error) {\n      logger.error('[InstallationDetector] Error finding git repository path:', error);\n    }\n    \n    return null;\n  }\n  \n  /**\n   * Get a human-readable description of the installation\n   */\n  static getInstallationDescription(): string {\n    const type = this.getInstallationType();\n    \n    switch (type) {\n      case 'npm':\n        const npmPath = this.getNpmGlobalPath();\n        return npmPath \n          ? `npm global installation at ${npmPath}`\n          : 'npm global installation';\n          \n      case 'git':\n        const gitPath = this.getGitRepositoryPath();\n        return gitPath\n          ? `git installation at ${gitPath}`\n          : 'git installation';\n          \n      default:\n        return 'unknown installation type';\n    }\n  }\n  \n  /**\n   * Clear the cached installation type (mainly for testing)\n   */\n  static clearCache(): void {\n    this.cachedType = null;\n  }\n}"]}

package/dist/utils/searchUtils.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared utilities for search functionality
+ */
+/**
+ * Normalize search terms for better matching
+ * Handles spaces, dashes, underscores, and file extensions
+ *
+ * @param term - The search term to normalize
+ * @param maxLength - Maximum allowed length for the search term (default: 1000)
+ * @returns Normalized search term
+ * @throws Error if term exceeds maxLength
+ */
+export declare function normalizeSearchTerm(term: string, maxLength?: number): string;
+/**
+ * Preserve original structure for partial matching
+ * Less aggressive normalization that keeps original separators for partial searches
+ *
+ * @param term - The search term to normalize
+ * @param maxLength - Maximum allowed length for the search term (default: 1000)
+ * @returns Normalized search term with preserved structure
+ * @throws Error if term exceeds maxLength
+ */
+export declare function normalizeForPartialMatch(term: string, maxLength?: number): string;
+/**
+ * Check if a search term matches a target string with multiple strategies
+ * Uses both normalized matching and partial matching for better results
+ *
+ * @param searchTerm - The term being searched for
+ * @param targetString - The string to search in
+ * @returns true if there's a match
+ */
+export declare function isSearchMatch(searchTerm: string, targetString: string): boolean;
+/**
+ * Validate search query length and content
+ *
+ * @param query - The search query to validate
+ * @param maxLength - Maximum allowed length (default: 1000)
+ * @returns true if valid
+ * @throws Error with descriptive message if invalid
+ */
+export declare function validateSearchQuery(query: string, maxLength?: number): boolean;
+/**
+ * Debug function to show how search terms are normalized
+ * Helps troubleshoot search matching issues
+ *
+ * @param originalTerm - The original search term
+ * @returns Object with different normalization results
+ */
+export declare function debugNormalization(originalTerm: string): {
+    original: string;
+    normalized: string;
+    partialMatch: string;
+};
+//# sourceMappingURL=searchUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchUtils.d.ts","sourceRoot":"","sources":["../../src/utils/searchUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAa,GAAG,MAAM,CAclF;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAa,GAAG,MAAM,CAavF;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAqB/E;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,GAAE,MAAa,GAAG,OAAO,CA0BpF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM;;;;EAMtD"}

package/dist/utils/searchUtils.js

@@ -0,0 +1,118 @@
+/**
+ * Shared utilities for search functionality
+ */
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+/**
+ * Normalize search terms for better matching
+ * Handles spaces, dashes, underscores, and file extensions
+ *
+ * @param term - The search term to normalize
+ * @param maxLength - Maximum allowed length for the search term (default: 1000)
+ * @returns Normalized search term
+ * @throws Error if term exceeds maxLength
+ */
+export function normalizeSearchTerm(term, maxLength = 1000) {
+    // SECURITY FIX: Normalize Unicode to prevent homograph attacks
+    const normalized = UnicodeValidator.normalize(term);
+    const cleanTerm = normalized.normalizedContent;
+    // Security: Limit input length to prevent DoS attacks
+    if (cleanTerm.length > maxLength) {
+        throw new Error(`Search term exceeds maximum length of ${maxLength} characters`);
+    }
+    return cleanTerm.toLowerCase()
+        .replace(/[-_\s]+/g, ' ') // Convert dashes, underscores to spaces
+        .replace(/\.md$/, '') // Remove .md extension
+        .trim();
+}
+/**
+ * Preserve original structure for partial matching
+ * Less aggressive normalization that keeps original separators for partial searches
+ *
+ * @param term - The search term to normalize
+ * @param maxLength - Maximum allowed length for the search term (default: 1000)
+ * @returns Normalized search term with preserved structure
+ * @throws Error if term exceeds maxLength
+ */
+export function normalizeForPartialMatch(term, maxLength = 1000) {
+    // SECURITY FIX: Normalize Unicode to prevent homograph attacks
+    const normalized = UnicodeValidator.normalize(term);
+    const cleanTerm = normalized.normalizedContent;
+    // Security: Limit input length to prevent DoS attacks
+    if (cleanTerm.length > maxLength) {
+        throw new Error(`Search term exceeds maximum length of ${maxLength} characters`);
+    }
+    return cleanTerm.toLowerCase()
+        .replace(/\.md$/, '') // Remove .md extension only
+        .trim();
+}
+/**
+ * Check if a search term matches a target string with multiple strategies
+ * Uses both normalized matching and partial matching for better results
+ *
+ * @param searchTerm - The term being searched for
+ * @param targetString - The string to search in
+ * @returns true if there's a match
+ */
+export function isSearchMatch(searchTerm, targetString) {
+    // Strategy 1: Exact normalized matching
+    const normalizedSearch = normalizeSearchTerm(searchTerm);
+    const normalizedTarget = normalizeSearchTerm(targetString);
+    if (normalizedTarget.includes(normalizedSearch)) {
+        return true;
+    }
+    // Strategy 2: Partial matching with preserved structure
+    const partialSearch = normalizeForPartialMatch(searchTerm);
+    const partialTarget = normalizeForPartialMatch(targetString);
+    if (partialTarget.includes(partialSearch)) {
+        return true;
+    }
+    // Strategy 3: Word-boundary matching
+    const searchWords = normalizedSearch.split(/\s+/);
+    const targetWords = normalizedTarget.split(/\s+/);
+    return searchWords.some(searchWord => targetWords.some(targetWord => targetWord.includes(searchWord)));
+}
+/**
+ * Validate search query length and content
+ *
+ * @param query - The search query to validate
+ * @param maxLength - Maximum allowed length (default: 1000)
+ * @returns true if valid
+ * @throws Error with descriptive message if invalid
+ */
+export function validateSearchQuery(query, maxLength = 1000) {
+    if (!query || query.trim().length === 0) {
+        throw new Error('Search query cannot be empty');
+    }
+    // SECURITY FIX: Normalize Unicode before validation
+    const normalized = UnicodeValidator.normalize(query);
+    const cleanQuery = normalized.normalizedContent;
+    if (cleanQuery.length > maxLength) {
+        throw new Error(`Search query exceeds maximum length of ${maxLength} characters`);
+    }
+    // Check for potential injection patterns (basic validation)
+    const dangerousPatterns = [
+        /[\x00-\x1F\x7F]/, // Control characters
+        /[<>]/, // Potential HTML/XML injection
+    ];
+    for (const pattern of dangerousPatterns) {
+        if (pattern.test(cleanQuery)) {
+            throw new Error('Search query contains invalid characters');
+        }
+    }
+    return true;
+}
+/**
+ * Debug function to show how search terms are normalized
+ * Helps troubleshoot search matching issues
+ *
+ * @param originalTerm - The original search term
+ * @returns Object with different normalization results
+ */
+export function debugNormalization(originalTerm) {
+    return {
+        original: originalTerm,
+        normalized: normalizeSearchTerm(originalTerm),
+        partialMatch: normalizeForPartialMatch(originalTerm)
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"searchUtils.js","sourceRoot":"","sources":["../../src/utils/searchUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAE9E;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAY,EAAE,YAAoB,IAAI;IACxE,+DAA+D;IAC/D,MAAM,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACpD,MAAM,SAAS,GAAG,UAAU,CAAC,iBAAiB,CAAC;IAE/C,sDAAsD;IACtD,IAAI,SAAS,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,yCAAyC,SAAS,aAAa,CAAC,CAAC;IACnF,CAAC;IAED,OAAO,SAAS,CAAC,WAAW,EAAE;SAC3B,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CAAE,wCAAwC;SAClE,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAO,uBAAuB;SAClD,IAAI,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAAY,EAAE,YAAoB,IAAI;IAC7E,+DAA+D;IAC/D,MAAM,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACpD,MAAM,SAAS,GAAG,UAAU,CAAC,iBAAiB,CAAC;IAE/C,sDAAsD;IACtD,IAAI,SAAS,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,yCAAyC,SAAS,aAAa,CAAC,CAAC;IACnF,CAAC;IAED,OAAO,SAAS,CAAC,WAAW,EAAE;SAC3B,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAO,4BAA4B;SACvD,IAAI,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,UAAkB,EAAE,YAAoB;IACpE,wCAAwC;IACxC,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC;IACzD,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAC3D,IAAI,gBAAgB,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAChD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,wDAAwD;IACxD,MAAM,aAAa,GAAG,wBAAwB,CAAC,UAAU,CAAC,CAAC;IAC3D,MAAM,aAAa,GAAG,wBAAwB,CAAC,YAAY,CAAC,CAAC;IAC7D,IAAI,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,qCAAqC;IACrC,MAAM,WAAW,GAAG,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAClD,MAAM,WAAW,GAAG,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAClD,OAAO,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CACnC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAChE,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAa,EAAE,YAAoB,IAAI;IACzE,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;IAClD,CAAC;IAED,oDAAoD;IACpD,MAAM,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACrD,MAAM,UAAU,GAAG,UAAU,CAAC,iBAAiB,CAAC;IAEhD,IAAI,UAAU,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,0CAA0C,SAAS,aAAa,CAAC,CAAC;IACpF,CAAC;IAED,4DAA4D;IAC5D,MAAM,iBAAiB,GAAG;QACxB,iBAAiB,EAAG,qBAAqB;QACzC,MAAM,EAAc,+BAA+B;KACpD,CAAC;IAEF,KAAK,MAAM,OAAO,IAAI,iBAAiB,EAAE,CAAC;QACxC,IAAI,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,YAAoB;IACrD,OAAO;QACL,QAAQ,EAAE,YAAY;QACtB,UAAU,EAAE,mBAAmB,CAAC,YAAY,CAAC;QAC7C,YAAY,EAAE,wBAAwB,CAAC,YAAY,CAAC;KACrD,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Shared utilities for search functionality\n */\n\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\n\n/**\n * Normalize search terms for better matching\n * Handles spaces, dashes, underscores, and file extensions\n * \n * @param term - The search term to normalize\n * @param maxLength - Maximum allowed length for the search term (default: 1000)\n * @returns Normalized search term\n * @throws Error if term exceeds maxLength\n */\nexport function normalizeSearchTerm(term: string, maxLength: number = 1000): string {\n  // SECURITY FIX: Normalize Unicode to prevent homograph attacks\n  const normalized = UnicodeValidator.normalize(term);\n  const cleanTerm = normalized.normalizedContent;\n  \n  // Security: Limit input length to prevent DoS attacks\n  if (cleanTerm.length > maxLength) {\n    throw new Error(`Search term exceeds maximum length of ${maxLength} characters`);\n  }\n  \n  return cleanTerm.toLowerCase()\n    .replace(/[-_\\s]+/g, ' ')  // Convert dashes, underscores to spaces\n    .replace(/\\.md$/, '')       // Remove .md extension\n    .trim();\n}\n\n/**\n * Preserve original structure for partial matching\n * Less aggressive normalization that keeps original separators for partial searches\n * \n * @param term - The search term to normalize\n * @param maxLength - Maximum allowed length for the search term (default: 1000)\n * @returns Normalized search term with preserved structure\n * @throws Error if term exceeds maxLength\n */\nexport function normalizeForPartialMatch(term: string, maxLength: number = 1000): string {\n  // SECURITY FIX: Normalize Unicode to prevent homograph attacks\n  const normalized = UnicodeValidator.normalize(term);\n  const cleanTerm = normalized.normalizedContent;\n  \n  // Security: Limit input length to prevent DoS attacks\n  if (cleanTerm.length > maxLength) {\n    throw new Error(`Search term exceeds maximum length of ${maxLength} characters`);\n  }\n  \n  return cleanTerm.toLowerCase()\n    .replace(/\\.md$/, '')       // Remove .md extension only\n    .trim();\n}\n\n/**\n * Check if a search term matches a target string with multiple strategies\n * Uses both normalized matching and partial matching for better results\n * \n * @param searchTerm - The term being searched for\n * @param targetString - The string to search in\n * @returns true if there's a match\n */\nexport function isSearchMatch(searchTerm: string, targetString: string): boolean {\n  // Strategy 1: Exact normalized matching\n  const normalizedSearch = normalizeSearchTerm(searchTerm);\n  const normalizedTarget = normalizeSearchTerm(targetString);\n  if (normalizedTarget.includes(normalizedSearch)) {\n    return true;\n  }\n  \n  // Strategy 2: Partial matching with preserved structure\n  const partialSearch = normalizeForPartialMatch(searchTerm);\n  const partialTarget = normalizeForPartialMatch(targetString);\n  if (partialTarget.includes(partialSearch)) {\n    return true;\n  }\n  \n  // Strategy 3: Word-boundary matching\n  const searchWords = normalizedSearch.split(/\\s+/);\n  const targetWords = normalizedTarget.split(/\\s+/);\n  return searchWords.some(searchWord => \n    targetWords.some(targetWord => targetWord.includes(searchWord))\n  );\n}\n\n/**\n * Validate search query length and content\n * \n * @param query - The search query to validate\n * @param maxLength - Maximum allowed length (default: 1000)\n * @returns true if valid\n * @throws Error with descriptive message if invalid\n */\nexport function validateSearchQuery(query: string, maxLength: number = 1000): boolean {\n  if (!query || query.trim().length === 0) {\n    throw new Error('Search query cannot be empty');\n  }\n  \n  // SECURITY FIX: Normalize Unicode before validation\n  const normalized = UnicodeValidator.normalize(query);\n  const cleanQuery = normalized.normalizedContent;\n  \n  if (cleanQuery.length > maxLength) {\n    throw new Error(`Search query exceeds maximum length of ${maxLength} characters`);\n  }\n  \n  // Check for potential injection patterns (basic validation)\n  const dangerousPatterns = [\n    /[\\x00-\\x1F\\x7F]/,  // Control characters\n    /[<>]/,             // Potential HTML/XML injection\n  ];\n  \n  for (const pattern of dangerousPatterns) {\n    if (pattern.test(cleanQuery)) {\n      throw new Error('Search query contains invalid characters');\n    }\n  }\n  \n  return true;\n}\n\n/**\n * Debug function to show how search terms are normalized\n * Helps troubleshoot search matching issues\n * \n * @param originalTerm - The original search term\n * @returns Object with different normalization results\n */\nexport function debugNormalization(originalTerm: string) {\n  return {\n    original: originalTerm,\n    normalized: normalizeSearchTerm(originalTerm),\n    partialMatch: normalizeForPartialMatch(originalTerm)\n  };\n}"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dollhousemcp/mcp-server",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.",
   "type": "module",
   "main": "dist/index.js",
@@ -13,14 +13,12 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "tsx watch src/index.ts",
+    "inspector": "npx @modelcontextprotocol/inspector node dist/index.js",
+    "inspector:dev": "npx @modelcontextprotocol/inspector tsx src/index.ts",
     "clean": "rm -rf dist",
     "rebuild": "npm run clean && npm run build",
     "setup": "npm install && npm run build",
     "prepublishOnly": "BUILD_TYPE=npm npm run build",
-    "update:check": "echo 'Use check_for_updates MCP tool for interactive update checking'",
-    "update:pull": "git pull origin main && npm install && npm run build",
-    "update:backup": "cp -r . .backup-$(date +%s)",
-    "update:restore": "echo 'Use rollback_update MCP tool for interactive rollback'",
     "test": "cross-env \"NODE_OPTIONS=--experimental-vm-modules --no-warnings\" jest --config test/jest.config.cjs",
     "test:watch": "cross-env \"NODE_OPTIONS=--experimental-vm-modules --no-warnings\" jest --config test/jest.config.cjs --watch",
     "test:coverage": "cross-env \"NODE_OPTIONS=--experimental-vm-modules --no-warnings\" jest --config test/jest.config.cjs --coverage",
@@ -42,7 +40,17 @@
     "security:audit": "tsx scripts/run-security-audit.ts",
     "security:audit:json": "tsx scripts/run-security-audit.ts --json",
     "security:audit:verbose": "tsx scripts/run-security-audit.ts --verbose",
-    "pre-commit": "npm run security:rapid && npm audit --audit-level=high"
+    "pre-commit": "npm run security:rapid && npm audit --audit-level=high",
+    "test:e2e": "cross-env \"NODE_OPTIONS=--experimental-vm-modules --no-warnings\" jest --config test/jest.e2e.config.cjs",
+    "test:e2e:watch": "cross-env \"NODE_OPTIONS=--experimental-vm-modules --no-warnings\" jest --config test/jest.e2e.config.cjs --watch",
+    "test:e2e:verbose": "cross-env \"NODE_OPTIONS=--experimental-vm-modules --no-warnings\" jest --config test/jest.e2e.config.cjs --verbose",
+    "test:roundtrip": "npm run test:e2e",
+    "test:roundtrip:manual": "./scripts/test-roundtrip-workflow.sh",
+    "test:roundtrip:cleanup": "./scripts/test-roundtrip-workflow.sh cleanup",
+    "qa:direct": "node scripts/qa-direct-test.js",
+    "qa:inspector": "node scripts/qa-inspector-cli-test.js",
+    "qa:all": "npm run qa:direct && npm run qa:inspector",
+    "qa:simple": "node scripts/qa-simple-test.js"
   },
   "keywords": [
     "mcp",
@@ -99,7 +107,7 @@
     "url": "https://github.com/sponsors/mickdarling"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.16.0",
+    "@modelcontextprotocol/sdk": "^1.17.3",
     "@types/dompurify": "^3.0.5",
     "@types/uuid": "^10.0.0",
     "dompurify": "^3.2.6",
@@ -107,11 +115,13 @@
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
     "jsdom": "^26.1.0",
+    "node-fetch": "^3.3.2",
     "uuid": "^11.1.0",
     "zod": "^4.0.5"
   },
   "devDependencies": {
     "@jest/globals": "^30.0.4",
+    "@modelcontextprotocol/inspector": "^0.16.5",
     "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/jsdom": "^21.1.7",

package/dist/config/updateConfig.d.ts

@@ -1,84 +0,0 @@
-/**
- * Configuration for update system
- * Supports environment variables and XDG directories
- */
-export interface UpdateConfig {
-    paths: {
-        backupDir: string;
-        npmBackupDir: string;
-        tempDir: string;
-    };
-    limits: {
-        maxSearchDepth: number;
-        maxBackupCount: number;
-        maxBackupSizeMB: number;
-    };
-    timeouts: {
-        gitCloneMs: number;
-        npmInstallMs: number;
-        npmUpdateMs: number;
-        buildMs: number;
-    };
-}
-export declare class UpdateConfigManager {
-    private static instance;
-    private config;
-    private constructor();
-    /**
-     * Get singleton instance
-     */
-    static getInstance(): UpdateConfigManager;
-    /**
-     * Get configuration
-     */
-    getConfig(): UpdateConfig;
-    /**
-     * Load configuration from environment and defaults
-     */
-    private loadConfiguration;
-    /**
-     * Get base directory respecting XDG standards on Linux
-     */
-    private getBaseDirectory;
-    /**
-     * Parse integer environment variable with default
-     */
-    private parseIntEnv;
-    /**
-     * Get backup directory path
-     */
-    getBackupDir(): string;
-    /**
-     * Get npm backup directory path
-     */
-    getNpmBackupDir(): string;
-    /**
-     * Get temporary directory path
-     */
-    getTempDir(): string;
-    /**
-     * Get max search depth for installation detection
-     */
-    getMaxSearchDepth(): number;
-    /**
-     * Get max number of backups to keep
-     */
-    getMaxBackupCount(): number;
-    /**
-     * Get timeout for git clone operations
-     */
-    getGitCloneTimeout(): number;
-    /**
-     * Get timeout for npm install operations
-     */
-    getNpmInstallTimeout(): number;
-    /**
-     * Get timeout for npm update operations
-     */
-    getNpmUpdateTimeout(): number;
-    /**
-     * Get timeout for build operations
-     */
-    getBuildTimeout(): number;
-}
-//# sourceMappingURL=updateConfig.d.ts.map

package/dist/config/updateConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"updateConfig.d.ts","sourceRoot":"","sources":["../../src/config/updateConfig.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE;QACL,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,MAAM,EAAE;QACN,cAAc,EAAE,MAAM,CAAC;QACvB,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,QAAQ,EAAE;QACR,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAoC;IAC3D,OAAO,CAAC,MAAM,CAAe;IAE7B,OAAO;IAIP;;OAEG;IACH,MAAM,CAAC,WAAW,IAAI,mBAAmB;IAOzC;;OAEG;IACH,SAAS,IAAI,YAAY;IAIzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAoCzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAkBxB;;OAEG;IACH,OAAO,CAAC,WAAW;IAenB;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,eAAe,IAAI,MAAM;IAIzB;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAI5B;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAI9B;;OAEG;IACH,mBAAmB,IAAI,MAAM;IAI7B;;OAEG;IACH,eAAe,IAAI,MAAM;CAG1B"}

package/dist/config/updateConfig.js

@@ -1,148 +0,0 @@
-import * as path from 'path';
-import * as os from 'os';
-import { logger } from '../utils/logger.js';
-export class UpdateConfigManager {
-    static instance = null;
-    config;
-    constructor() {
-        this.config = this.loadConfiguration();
-    }
-    /**
-     * Get singleton instance
-     */
-    static getInstance() {
-        if (!UpdateConfigManager.instance) {
-            UpdateConfigManager.instance = new UpdateConfigManager();
-        }
-        return UpdateConfigManager.instance;
-    }
-    /**
-     * Get configuration
-     */
-    getConfig() {
-        return this.config;
-    }
-    /**
-     * Load configuration from environment and defaults
-     */
-    loadConfiguration() {
-        // Determine base directory (respects XDG on Linux)
-        const baseDir = this.getBaseDirectory();
-        // Load from environment or use defaults
-        const config = {
-            paths: {
-                backupDir: process.env.DOLLHOUSE_BACKUP_DIR ||
-                    path.join(baseDir, 'backups'),
-                npmBackupDir: process.env.DOLLHOUSE_NPM_BACKUP_DIR ||
-                    path.join(baseDir, 'backups', 'npm'),
-                tempDir: process.env.DOLLHOUSE_TEMP_DIR ||
-                    path.join(os.tmpdir(), 'dollhouse-update')
-            },
-            limits: {
-                maxSearchDepth: this.parseIntEnv('DOLLHOUSE_MAX_SEARCH_DEPTH', 10),
-                maxBackupCount: this.parseIntEnv('DOLLHOUSE_MAX_BACKUP_COUNT', 5),
-                maxBackupSizeMB: this.parseIntEnv('DOLLHOUSE_MAX_BACKUP_SIZE_MB', 500)
-            },
-            timeouts: {
-                gitCloneMs: this.parseIntEnv('DOLLHOUSE_GIT_CLONE_TIMEOUT_MS', 300000), // 5 minutes
-                npmInstallMs: this.parseIntEnv('DOLLHOUSE_NPM_INSTALL_TIMEOUT_MS', 300000), // 5 minutes
-                npmUpdateMs: this.parseIntEnv('DOLLHOUSE_NPM_UPDATE_TIMEOUT_MS', 300000), // 5 minutes
-                buildMs: this.parseIntEnv('DOLLHOUSE_BUILD_TIMEOUT_MS', 120000) // 2 minutes
-            }
-        };
-        logger.info('[UpdateConfig] Configuration loaded:', {
-            baseDir,
-            backupDir: config.paths.backupDir,
-            maxSearchDepth: config.limits.maxSearchDepth
-        });
-        return config;
-    }
-    /**
-     * Get base directory respecting XDG standards on Linux
-     */
-    getBaseDirectory() {
-        // Check for explicit override
-        if (process.env.DOLLHOUSE_BASE_DIR) {
-            return process.env.DOLLHOUSE_BASE_DIR;
-        }
-        // On Linux, respect XDG standards
-        if (process.platform === 'linux') {
-            const xdgDataHome = process.env.XDG_DATA_HOME;
-            if (xdgDataHome) {
-                return path.join(xdgDataHome, 'dollhouse');
-            }
-        }
-        // Default to home directory
-        return path.join(os.homedir(), '.dollhouse');
-    }
-    /**
-     * Parse integer environment variable with default
-     */
-    parseIntEnv(key, defaultValue) {
-        const value = process.env[key];
-        if (!value) {
-            return defaultValue;
-        }
-        const parsed = parseInt(value, 10);
-        if (isNaN(parsed)) {
-            logger.warn(`[UpdateConfig] Invalid integer value for ${key}: ${value}, using default: ${defaultValue}`);
-            return defaultValue;
-        }
-        return parsed;
-    }
-    /**
-     * Get backup directory path
-     */
-    getBackupDir() {
-        return this.config.paths.backupDir;
-    }
-    /**
-     * Get npm backup directory path
-     */
-    getNpmBackupDir() {
-        return this.config.paths.npmBackupDir;
-    }
-    /**
-     * Get temporary directory path
-     */
-    getTempDir() {
-        return this.config.paths.tempDir;
-    }
-    /**
-     * Get max search depth for installation detection
-     */
-    getMaxSearchDepth() {
-        return this.config.limits.maxSearchDepth;
-    }
-    /**
-     * Get max number of backups to keep
-     */
-    getMaxBackupCount() {
-        return this.config.limits.maxBackupCount;
-    }
-    /**
-     * Get timeout for git clone operations
-     */
-    getGitCloneTimeout() {
-        return this.config.timeouts.gitCloneMs;
-    }
-    /**
-     * Get timeout for npm install operations
-     */
-    getNpmInstallTimeout() {
-        return this.config.timeouts.npmInstallMs;
-    }
-    /**
-     * Get timeout for npm update operations
-     */
-    getNpmUpdateTimeout() {
-        return this.config.timeouts.npmUpdateMs;
-    }
-    /**
-     * Get timeout for build operations
-     */
-    getBuildTimeout() {
-        return this.config.timeouts.buildMs;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"updateConfig.js","sourceRoot":"","sources":["../../src/config/updateConfig.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as os from 'os';\nimport { logger } from '../utils/logger.js';\n\n/**\n * Configuration for update system\n * Supports environment variables and XDG directories\n */\nexport interface UpdateConfig {\n  paths: {\n    backupDir: string;\n    npmBackupDir: string;\n    tempDir: string;\n  };\n  limits: {\n    maxSearchDepth: number;\n    maxBackupCount: number;\n    maxBackupSizeMB: number;\n  };\n  timeouts: {\n    gitCloneMs: number;\n    npmInstallMs: number;\n    npmUpdateMs: number;\n    buildMs: number;\n  };\n}\n\nexport class UpdateConfigManager {\n  private static instance: UpdateConfigManager | null = null;\n  private config: UpdateConfig;\n  \n  private constructor() {\n    this.config = this.loadConfiguration();\n  }\n  \n  /**\n   * Get singleton instance\n   */\n  static getInstance(): UpdateConfigManager {\n    if (!UpdateConfigManager.instance) {\n      UpdateConfigManager.instance = new UpdateConfigManager();\n    }\n    return UpdateConfigManager.instance;\n  }\n  \n  /**\n   * Get configuration\n   */\n  getConfig(): UpdateConfig {\n    return this.config;\n  }\n  \n  /**\n   * Load configuration from environment and defaults\n   */\n  private loadConfiguration(): UpdateConfig {\n    // Determine base directory (respects XDG on Linux)\n    const baseDir = this.getBaseDirectory();\n    \n    // Load from environment or use defaults\n    const config: UpdateConfig = {\n      paths: {\n        backupDir: process.env.DOLLHOUSE_BACKUP_DIR || \n                   path.join(baseDir, 'backups'),\n        npmBackupDir: process.env.DOLLHOUSE_NPM_BACKUP_DIR || \n                      path.join(baseDir, 'backups', 'npm'),\n        tempDir: process.env.DOLLHOUSE_TEMP_DIR || \n                 path.join(os.tmpdir(), 'dollhouse-update')\n      },\n      limits: {\n        maxSearchDepth: this.parseIntEnv('DOLLHOUSE_MAX_SEARCH_DEPTH', 10),\n        maxBackupCount: this.parseIntEnv('DOLLHOUSE_MAX_BACKUP_COUNT', 5),\n        maxBackupSizeMB: this.parseIntEnv('DOLLHOUSE_MAX_BACKUP_SIZE_MB', 500)\n      },\n      timeouts: {\n        gitCloneMs: this.parseIntEnv('DOLLHOUSE_GIT_CLONE_TIMEOUT_MS', 300000), // 5 minutes\n        npmInstallMs: this.parseIntEnv('DOLLHOUSE_NPM_INSTALL_TIMEOUT_MS', 300000), // 5 minutes\n        npmUpdateMs: this.parseIntEnv('DOLLHOUSE_NPM_UPDATE_TIMEOUT_MS', 300000), // 5 minutes\n        buildMs: this.parseIntEnv('DOLLHOUSE_BUILD_TIMEOUT_MS', 120000) // 2 minutes\n      }\n    };\n    \n    logger.info('[UpdateConfig] Configuration loaded:', {\n      baseDir,\n      backupDir: config.paths.backupDir,\n      maxSearchDepth: config.limits.maxSearchDepth\n    });\n    \n    return config;\n  }\n  \n  /**\n   * Get base directory respecting XDG standards on Linux\n   */\n  private getBaseDirectory(): string {\n    // Check for explicit override\n    if (process.env.DOLLHOUSE_BASE_DIR) {\n      return process.env.DOLLHOUSE_BASE_DIR;\n    }\n    \n    // On Linux, respect XDG standards\n    if (process.platform === 'linux') {\n      const xdgDataHome = process.env.XDG_DATA_HOME;\n      if (xdgDataHome) {\n        return path.join(xdgDataHome, 'dollhouse');\n      }\n    }\n    \n    // Default to home directory\n    return path.join(os.homedir(), '.dollhouse');\n  }\n  \n  /**\n   * Parse integer environment variable with default\n   */\n  private parseIntEnv(key: string, defaultValue: number): number {\n    const value = process.env[key];\n    if (!value) {\n      return defaultValue;\n    }\n    \n    const parsed = parseInt(value, 10);\n    if (isNaN(parsed)) {\n      logger.warn(`[UpdateConfig] Invalid integer value for ${key}: ${value}, using default: ${defaultValue}`);\n      return defaultValue;\n    }\n    \n    return parsed;\n  }\n  \n  /**\n   * Get backup directory path\n   */\n  getBackupDir(): string {\n    return this.config.paths.backupDir;\n  }\n  \n  /**\n   * Get npm backup directory path\n   */\n  getNpmBackupDir(): string {\n    return this.config.paths.npmBackupDir;\n  }\n  \n  /**\n   * Get temporary directory path\n   */\n  getTempDir(): string {\n    return this.config.paths.tempDir;\n  }\n  \n  /**\n   * Get max search depth for installation detection\n   */\n  getMaxSearchDepth(): number {\n    return this.config.limits.maxSearchDepth;\n  }\n  \n  /**\n   * Get max number of backups to keep\n   */\n  getMaxBackupCount(): number {\n    return this.config.limits.maxBackupCount;\n  }\n  \n  /**\n   * Get timeout for git clone operations\n   */\n  getGitCloneTimeout(): number {\n    return this.config.timeouts.gitCloneMs;\n  }\n  \n  /**\n   * Get timeout for npm install operations\n   */\n  getNpmInstallTimeout(): number {\n    return this.config.timeouts.npmInstallMs;\n  }\n  \n  /**\n   * Get timeout for npm update operations\n   */\n  getNpmUpdateTimeout(): number {\n    return this.config.timeouts.npmUpdateMs;\n  }\n  \n  /**\n   * Get timeout for build operations\n   */\n  getBuildTimeout(): number {\n    return this.config.timeouts.buildMs;\n  }\n}"]}

package/dist/server/tools/UpdateTools.d.ts

@@ -1,10 +0,0 @@
-/**
- * Update/maintenance-related tool definitions and handlers
- */
-import { ToolDefinition } from './ToolRegistry.js';
-import { IToolHandler } from '../types.js';
-export declare function getUpdateTools(server: IToolHandler): Array<{
-    tool: ToolDefinition;
-    handler: any;
-}>;
-//# sourceMappingURL=UpdateTools.d.ts.map

package/dist/server/tools/UpdateTools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UpdateTools.d.ts","sourceRoot":"","sources":["../../../src/server/tools/UpdateTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CAgFlG"}