@dollhousemcp/mcp-server 1.4.0 → 1.4.2

package/dist/utils/installation.js

@@ -0,0 +1,160 @@
+/**
+ * Installation detection utilities
+ * Determines whether the application is running from npm or git installation
+ */
+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();
+    }
+    /**
+     * Detect the installation type (npm global, git clone, or unknown)
+     */
+    static getInstallationType() {
+        // Return cached result if available
+        if (this.cachedType !== null) {
+            return this.cachedType;
+        }
+        try {
+            // Get the directory where this file is located
+            const currentFileUrl = import.meta.url;
+            const currentFilePath = fileURLToPath(currentFileUrl);
+            let currentDir = path.dirname(currentFilePath);
+            // Resolve symlinks to get the real path
+            try {
+                currentDir = fs.realpathSync(currentDir);
+            }
+            catch (error) {
+                // If realpath fails, continue with original path
+                logger.debug('[InstallationDetector] Could not resolve real path, using original');
+            }
+            // 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)) {
+                logger.debug('[InstallationDetector] Detected npm installation');
+                this.cachedType = 'npm';
+                return 'npm';
+            }
+            // Check for .git directory (git installation)
+            // Search up from current directory
+            let searchDir = currentDir;
+            for (let i = 0; i < this.MAX_SEARCH_DEPTH; i++) {
+                const gitDir = path.join(searchDir, '.git');
+                try {
+                    if (fs.existsSync(gitDir) && fs.statSync(gitDir).isDirectory()) {
+                        logger.debug('[InstallationDetector] Detected git installation');
+                        this.cachedType = 'git';
+                        return 'git';
+                    }
+                }
+                catch (error) {
+                    // Ignore errors and continue searching
+                }
+                const parentDir = path.dirname(searchDir);
+                if (parentDir === searchDir) {
+                    // Reached root directory
+                    break;
+                }
+                searchDir = parentDir;
+            }
+            logger.warn('[InstallationDetector] Could not determine installation type');
+            this.cachedType = 'unknown';
+            return 'unknown';
+        }
+        catch (error) {
+            logger.error('[InstallationDetector] Error detecting installation type:', error);
+            this.cachedType = 'unknown';
+            return 'unknown';
+        }
+    }
+    /**
+     * Get the npm global installation path if running from npm
+     */
+    static getNpmGlobalPath() {
+        if (this.getInstallationType() !== 'npm') {
+            return null;
+        }
+        try {
+            const currentFileUrl = import.meta.url;
+            const currentFilePath = fileURLToPath(currentFileUrl);
+            let currentDir = path.dirname(currentFilePath);
+            // Find the root of the npm package
+            while (currentDir.includes('node_modules/@dollhousemcp/mcp-server')) {
+                const packageJsonPath = path.join(currentDir, 'package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    return currentDir;
+                }
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir)
+                    break;
+                currentDir = parentDir;
+            }
+        }
+        catch (error) {
+            logger.error('[InstallationDetector] Error finding npm global path:', error);
+        }
+        return null;
+    }
+    /**
+     * Get the git repository root path if running from git
+     */
+    static getGitRepositoryPath() {
+        if (this.getInstallationType() !== 'git') {
+            return null;
+        }
+        try {
+            const currentFileUrl = import.meta.url;
+            const currentFilePath = fileURLToPath(currentFileUrl);
+            let currentDir = path.dirname(currentFilePath);
+            // Search up for .git directory
+            for (let i = 0; i < 10; i++) {
+                const gitDir = path.join(currentDir, '.git');
+                if (fs.existsSync(gitDir) && fs.statSync(gitDir).isDirectory()) {
+                    return currentDir;
+                }
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir)
+                    break;
+                currentDir = parentDir;
+            }
+        }
+        catch (error) {
+            logger.error('[InstallationDetector] Error finding git repository path:', error);
+        }
+        return null;
+    }
+    /**
+     * Get a human-readable description of the installation
+     */
+    static getInstallationDescription() {
+        const type = this.getInstallationType();
+        switch (type) {
+            case 'npm':
+                const npmPath = this.getNpmGlobalPath();
+                return npmPath
+                    ? `npm global installation at ${npmPath}`
+                    : 'npm global installation';
+            case 'git':
+                const gitPath = this.getGitRepositoryPath();
+                return gitPath
+                    ? `git installation at ${gitPath}`
+                    : 'git installation';
+            default:
+                return 'unknown installation type';
+        }
+    }
+    /**
+     * Clear the cached installation type (mainly for testing)
+     */
+    static clearCache() {
+        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}"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dollhousemcp/mcp-server",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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",
@@ -9,12 +9,14 @@
     "mcp-server": "dist/index.js"
   },
   "scripts": {
+    "prebuild": "node scripts/generate-version.js",
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "tsx watch 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)",