@morphllm/morphmcp 0.8.42 → 0.8.43

package/dist/index.js

@@ -80,26 +80,21 @@ if (args.length === 0 && !ENABLE_WORKSPACE_MODE) {
 // =============================================================================
 const AUTO_UPDATE_INTERVAL_MS = parseInt(process.env.AUTO_UPDATE_INTERVAL_MS || '1800000', 10); // Default: 30 minutes
 const DISABLE_AUTO_UPDATE = process.env.DISABLE_AUTO_UPDATE === 'true';
+const EXIT_ON_SDK_UPDATE = process.env.EXIT_ON_SDK_UPDATE !== 'false'; // Default: true - exit after SDK update so client reconnects with fresh SDK
 // Get current installed version from package.json
 async function getInstalledVersion(packageName) {
+    // Get package root (parent of dist/ where package.json and node_modules live)
+    const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+    const packageRoot = path.resolve(scriptDir, '..');
+    const packageJsonPath = path.join(packageRoot, 'node_modules', ...packageName.split('/'), 'package.json');
     try {
-        // For @morphllm/morphsdk, check the node_modules
-        const packageJsonPath = path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'node_modules', ...packageName.split('/'), 'package.json');
         const content = await fs.readFile(packageJsonPath, 'utf-8');
         const pkg = JSON.parse(content);
         return pkg.version || null;
     }
     catch {
-        // Try alternative path (when running from dist)
-        try {
-            const altPath = path.join(path.dirname(new URL(import.meta.url).pathname), 'node_modules', ...packageName.split('/'), 'package.json');
-            const content = await fs.readFile(altPath, 'utf-8');
-            const pkg = JSON.parse(content);
-            return pkg.version || null;
-        }
-        catch {
-            return null;
-        }
+        // Package not installed locally - this is fine, we'll fetch latest
+        return null;
     }
 }
 // Fetch latest version from npm registry
@@ -132,6 +127,56 @@ async function checkPackageUpdate(packageName) {
         updateAvailable,
     };
 }
+// Clear npm cache for morph packages specifically
+async function clearMorphCache() {
+    try {
+        const homeDir = os.homedir();
+        const npxCacheDir = path.join(homeDir, '.npm', '_npx');
+        // Find and remove morph-related npx cache entries
+        try {
+            const entries = await fs.readdir(npxCacheDir);
+            for (const entry of entries) {
+                const entryPath = path.join(npxCacheDir, entry, 'node_modules', '@morphllm');
+                try {
+                    await fs.access(entryPath);
+                    // Found a morph cache entry - remove the entire npx cache folder
+                    const cacheFolder = path.join(npxCacheDir, entry);
+                    await fs.rm(cacheFolder, { recursive: true, force: true });
+                    console.error(`🗑️  Cleared npx cache: ${entry}`);
+                }
+                catch {
+                    // Not a morph cache entry, skip
+                }
+            }
+        }
+        catch (error) {
+            // npx cache dir doesn't exist or can't be read
+            if (error.code !== 'ENOENT') {
+                reportMorphError({
+                    error_message: `Failed to read npx cache dir: ${error instanceof Error ? error.message : String(error)}`,
+                    error_type: 'CacheClearError',
+                    context: {
+                        action: 'read_npx_cache_dir',
+                        npx_cache_dir: npxCacheDir
+                    },
+                    source: 'mcp-filesystem-autoupdate'
+                }).catch(() => { });
+            }
+        }
+    }
+    catch (error) {
+        // Report cache clear failures
+        reportMorphError({
+            error_message: `Cache clear failed: ${error instanceof Error ? error.message : String(error)}`,
+            error_type: 'CacheClearError',
+            context: {
+                action: 'clear_morph_cache'
+            },
+            stack_trace: error instanceof Error ? error.stack : undefined,
+            source: 'mcp-filesystem-autoupdate'
+        }).catch(() => { });
+    }
+}
 // Run npm/bun update and wait for completion
 function runPackageUpdate(packageName) {
     return new Promise((resolve) => {
@@ -140,9 +185,26 @@ function runPackageUpdate(packageName) {
         const args = packageManager === 'bun'
             ? ['add', packageName + '@latest']
             : ['install', packageName + '@latest'];
-        const packageDir = path.dirname(new URL(import.meta.url).pathname);
+        // Get package root (parent of dist/ where package.json lives)
+        const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+        const packageRoot = path.resolve(scriptDir, '..');
+        console.error(`🔧 Running: ${packageManager} ${args.join(' ')} in ${packageRoot}`);
+        // Check if we can write to the package root
+        fs.access(packageRoot, 2 /* W_OK */).catch(() => {
+            console.error(`⚠️  Warning: Package root may not be writable: ${packageRoot}`);
+            reportMorphError({
+                error_message: `Package root not writable: ${packageRoot}`,
+                error_type: 'AutoUpdatePermissionError',
+                context: {
+                    package_name: packageName,
+                    package_root: packageRoot,
+                    action: 'check_write_permission'
+                },
+                source: 'mcp-filesystem-autoupdate'
+            }).catch(() => { });
+        });
         const child = spawn(packageManager, args, {
-            cwd: packageDir,
+            cwd: packageRoot,
             stdio: 'pipe', // Capture output for debugging
             env: { ...process.env, npm_config_fund: 'false', npm_config_audit: 'false' }, // Skip fund/audit for speed
         });
@@ -150,16 +212,59 @@ function runPackageUpdate(packageName) {
         child.stderr?.on('data', (data) => { stderr += data.toString(); });
         child.on('error', (err) => {
             console.error(`Update error: ${err.message}`);
+            // Report spawn errors (e.g., npm not found)
+            reportMorphError({
+                error_message: `Failed to spawn ${packageManager}: ${err.message}`,
+                error_type: 'AutoUpdateSpawnError',
+                context: {
+                    package_name: packageName,
+                    package_manager: packageManager,
+                    package_root: packageRoot,
+                    error_code: err.code,
+                    action: 'spawn_package_manager',
+                    // Include PATH for debugging
+                    path_env: process.env.PATH?.split(':').slice(0, 5).join(':') + '...'
+                },
+                stack_trace: err.stack,
+                source: 'mcp-filesystem-autoupdate'
+            }).catch(() => { });
             resolve(false);
         });
         child.on('close', (code) => {
-            if (code !== 0 && stderr) {
-                console.error(`Update failed: ${stderr.slice(0, 200)}`);
+            if (code !== 0) {
+                console.error(`Update failed (exit ${code}): ${stderr.slice(0, 300)}`);
+                // Report non-zero exit
+                reportMorphError({
+                    error_message: `${packageManager} exited with code ${code}`,
+                    error_type: 'AutoUpdateExitError',
+                    context: {
+                        package_name: packageName,
+                        package_manager: packageManager,
+                        package_root: packageRoot,
+                        exit_code: code,
+                        stderr: stderr.slice(0, 1000),
+                        action: 'npm_install'
+                    },
+                    source: 'mcp-filesystem-autoupdate'
+                }).catch(() => { });
             }
             resolve(code === 0);
         });
         // Timeout after 60 seconds
         setTimeout(() => {
+            console.error(`Update timed out after 60s`);
+            reportMorphError({
+                error_message: `${packageManager} install timed out after 60s`,
+                error_type: 'AutoUpdateTimeoutError',
+                context: {
+                    package_name: packageName,
+                    package_manager: packageManager,
+                    package_root: packageRoot,
+                    stderr: stderr.slice(0, 1000),
+                    action: 'npm_install_timeout'
+                },
+                source: 'mcp-filesystem-autoupdate'
+            }).catch(() => { });
             child.kill();
             resolve(false);
         }, 60000);
@@ -167,9 +272,9 @@ function runPackageUpdate(packageName) {
 }
 // Main auto-update check function
 async function checkAndUpdatePackages() {
+    // Only check SDK - MCP is updated via npx @morphllm/morphmcp@latest
     const packagesToCheck = [
         '@morphllm/morphsdk',
-        '@morphllm/morphmcp',
     ];
     for (const packageName of packagesToCheck) {
         try {
@@ -224,17 +329,51 @@ async function checkUpdateThenReportError(errorDetails) {
 }
 // Start auto-update interval
 let autoUpdateInterval = null;
+let sdkWasUpdatedAtStartup = false;
+// Blocking startup check - runs before server starts
+async function checkSdkAtStartup() {
+    if (DISABLE_AUTO_UPDATE) {
+        return;
+    }
+    try {
+        const info = await checkPackageUpdate('@morphllm/morphsdk');
+        if (info.updateAvailable) {
+            console.error(`⚠️  SDK outdated: ${info.currentVersion} → ${info.latestVersion}`);
+            console.error(`📦 Updating SDK...`);
+            // Clear morph-related npm/npx cache first
+            await clearMorphCache();
+            const updateSucceeded = await runPackageUpdate('@morphllm/morphsdk');
+            if (updateSucceeded) {
+                console.error(`✅ SDK updated to ${info.latestVersion}`);
+                sdkWasUpdatedAtStartup = true;
+                if (EXIT_ON_SDK_UPDATE) {
+                    console.error(`🔄 Restarting to use updated SDK...`);
+                    // Exit with code 0 so MCP client will reconnect automatically
+                    process.exit(0);
+                }
+                else {
+                    console.error(`⚠️  RESTART REQUIRED: The updated SDK will be used on next restart.`);
+                }
+            }
+            else {
+                console.error(`❌ SDK update failed - continuing with ${info.currentVersion}`);
+            }
+        }
+        else {
+            console.error(`SDK version: ${info.currentVersion} (up to date)`);
+        }
+    }
+    catch (error) {
+        console.error(`SDK version check failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 function startAutoUpdate() {
     if (DISABLE_AUTO_UPDATE) {
         console.error('Auto-update disabled via DISABLE_AUTO_UPDATE=true');
         return;
     }
     console.error(`Auto-update enabled: checking every ${Math.round(AUTO_UPDATE_INTERVAL_MS / 60000)} minutes`);
-    // Check immediately on startup (after a short delay to not block initialization)
-    setTimeout(() => {
-        checkAndUpdatePackages().catch(() => { });
-    }, 5000);
-    // Then check periodically
+    // Periodic checks (startup check is done separately before server starts)
     autoUpdateInterval = setInterval(() => {
         checkAndUpdatePackages().catch(() => { });
     }, AUTO_UPDATE_INTERVAL_MS);
@@ -1241,13 +1380,15 @@ server.oninitialized = async () => {
 };
 // Start server
 async function runServer() {
+    // BLOCKING: Check and update SDK before starting server
+    await checkSdkAtStartup();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error("Secure MCP Filesystem Server running on stdio");
     if (allowedDirectories.length === 0) {
         console.error("Started without allowed directories - waiting for client to provide roots via MCP protocol");
     }
-    // Start auto-update system
+    // Start periodic auto-update system
     startAutoUpdate();
 }
 runServer().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morphllm/morphmcp",
-  "version": "0.8.42",
+  "version": "0.8.43",
   "description": "Fast & accurate MCP server with AI-powered file editing and intelligent code search. Prevents context pollution and saves time for a better user experience.",
   "license": "MIT",
   "author": "Morph (https://morphllm.com)",
@@ -29,14 +29,14 @@
     "build:obfuscated": "npm run build && npm run obfuscate",
     "obfuscate": "npx javascript-obfuscator dist --output dist --target node --compact true --string-array true --exclude '**/dist/__tests__/**'",
     "prepare": "npm run build",
-    "postinstall": "npm install @morphllm/morphsdk@latest --no-save --silent 2>/dev/null || true",
+    "postinstall": "echo '📦 Updating Morph SDK...' && npm install @morphllm/morphsdk@latest --no-save && echo '✅ SDK updated'",
     "watch": "tsc --watch",
     "test": "jest --config=jest.config.cjs --coverage"
   },
   "dependencies": {
     "@google/generative-ai": "^0.21.0",
     "@modelcontextprotocol/sdk": "^1.12.3",
-    "@morphllm/morphsdk": "latest",
+    "@morphllm/morphsdk": "^0.2.58",
     "@vscode/ripgrep": "^1.15.14",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",