deveco-mcp-server 0.1.7 → 0.1.9

package/index.js

@@ -1,179 +1,383 @@
 #!/usr/bin/env node
 
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
+
+const OFFICIAL_REGISTRY = 'https://registry.npmjs.org';
+const INSTALL_TIMEOUT = 60000;
+const VERSION_CHECK_TIMEOUT = 5000; // 版本检查超时时间（5秒）
 
 function getPlatformPackage() {
   const platform = process.platform;
   const arch = process.arch;
   
-  if (platform === 'win32' && arch === 'x64') {
-    return 'deveco-mcp-server-win32-x64';
-  } else if (platform === 'darwin' && arch === 'x64') {
-    return 'deveco-mcp-server-darwin-x64';
-  } else if (platform === 'darwin' && arch === 'arm64') {
-    return 'deveco-mcp-server-darwin-arm64';
+  const platformMap = {
+    'win32-x64': 'deveco-mcp-server-win32-x64',
+    'darwin-x64': 'deveco-mcp-server-darwin-x64',
+    'darwin-arm64': 'deveco-mcp-server-darwin-arm64'
+  };
+  
+  const key = `${platform}-${arch}`;
+  if (platformMap[key]) {
+    return platformMap[key];
   }
   
   throw new Error(`Unsupported platform: ${platform}-${arch}`);
 }
 
+function getNpmRegistry() {
+  try {
+    return execSync('npm config get registry', { encoding: 'utf-8' }).trim();
+  } catch (err) {
+    return null;
+  }
+}
+
+function checkAndWarnRegistry() {
+  const registry = getNpmRegistry();
+  if (registry && !registry.includes('npmjs.org')) {
+    console.warn(`\n⚠️  Detected non-official npm registry: ${registry}`);
+    console.warn(`Auto-install will use official registry (${OFFICIAL_REGISTRY}) to ensure package availability.\n`);
+  }
+}
+
+function buildBinaryPaths(binDir) {
+  if (process.platform === 'win32') {
+    return {
+      server: path.join(binDir, 'deveco-mcp-server.exe'),
+      toolbox: path.join(binDir, 'deveco-toolbox.exe')
+    };
+  } else {
+    return {
+      server: path.join(binDir, 'Contents', 'MacOS', 'deveco-mcp-server'),
+      toolbox: path.join(binDir, 'Contents', 'MacOS', 'deveco-toolbox')
+    };
+  }
+}
+
+function isNpxEnvironment() {
+  return __dirname.includes('_npx') || 
+         __dirname.includes('npm-cache') || 
+         __dirname.includes('npx-') ||
+         !!process.env.npm_config_user_config;
+}
+
+function getInstallDirectory() {
+  if (isNpxEnvironment()) {
+    const installDir = path.join(os.homedir(), '.deveco-mcp-cache');
+    if (!fs.existsSync(installDir)) {
+      fs.mkdirSync(installDir, { recursive: true });
+    }
+    return installDir;
+  }
+  return __dirname;
+}
+
+function findInstalledPackage(packageName, installDir) {
+  const nodeModulesPath = path.join(installDir, 'node_modules', packageName);
+  const packageJsonPath = path.join(nodeModulesPath, 'package.json');
+  
+  if (fs.existsSync(packageJsonPath)) {
+    return nodeModulesPath;
+  }
+  
+  // Try to resolve using require with multiple paths
+  const searchPaths = [
+    installDir,
+    path.join(installDir, 'node_modules'),
+    __dirname,
+    path.join(__dirname, 'node_modules')
+  ];
+  
+  for (const searchPath of searchPaths) {
+    try {
+      const packagePath = require.resolve(packageName, { paths: [searchPath] });
+      return path.dirname(packagePath);
+    } catch (resolveErr) {
+      // Continue to next path
+    }
+  }
+  
+  return nodeModulesPath;
+}
+
+function installPackage(packageName, installDir) {
+  try {
+    execSync(`npm install ${packageName}`, {
+      stdio: 'ignore',
+      cwd: installDir,
+      timeout: INSTALL_TIMEOUT
+    });
+    return findInstalledPackage(packageName, installDir);
+  } catch (installErr) {
+    // Try alternative: install to current directory with official registry
+    try {
+      execSync(`npm install --registry=${OFFICIAL_REGISTRY} ${packageName}`, {
+        stdio: 'ignore',
+        cwd: __dirname,
+        timeout: INSTALL_TIMEOUT
+      });
+      
+      const localNodeModules = path.join(__dirname, 'node_modules', packageName);
+      const localPackageJson = path.join(localNodeModules, 'package.json');
+      
+      if (fs.existsSync(localPackageJson)) {
+        return localNodeModules;
+      }
+      throw installErr;
+    } catch (altErr) {
+      throw new Error('All installation attempts failed');
+    }
+  }
+}
+
+function getLocalVersion(packageName, binDir) {
+  try {
+    const packageJsonPath = path.join(binDir, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+      return packageJson.version || null;
+    }
+  } catch (err) {
+    // 忽略错误
+  }
+  return null;
+}
+
+function getLatestVersion(packageName) {
+  try {
+    const output = execSync(`npm view ${packageName} version --registry=${OFFICIAL_REGISTRY}`, {
+      encoding: 'utf-8',
+      timeout: VERSION_CHECK_TIMEOUT,
+      stdio: ['ignore', 'pipe', 'ignore']
+    });
+    return output.trim();
+  } catch (err) {
+    return null;
+  }
+}
+
+function compareVersions(version1, version2) {
+  // 简单的版本比较，如果需要更复杂的可以使用 semver 库
+  const v1parts = version1.split('.').map(Number);
+  const v2parts = version2.split('.').map(Number);
+  
+  for (let i = 0; i < Math.max(v1parts.length, v2parts.length); i++) {
+    const v1part = v1parts[i] || 0;
+    const v2part = v2parts[i] || 0;
+    if (v1part < v2part) return -1;
+    if (v1part > v2part) return 1;
+  }
+  return 0;
+}
+
+function shouldSkipUpdate() {
+  // 默认自动更新，除非明确禁用
+  return process.env.DEVECO_MCP_NO_AUTO_UPDATE === 'true' || 
+         process.argv.includes('--no-update') ||
+         process.argv.includes('--skip-update');
+}
+
+function updatePackage(packageName, installDir) {
+  try {
+    execSync(`npm install ${packageName}@latest --registry=${OFFICIAL_REGISTRY}`, {
+      stdio: 'ignore',
+      cwd: installDir,
+      timeout: INSTALL_TIMEOUT
+    });
+    return findInstalledPackage(packageName, installDir);
+  } catch (err) {
+    // 如果更新失败，尝试在当前目录更新
+    try {
+      execSync(`npm install ${packageName}@latest --registry=${OFFICIAL_REGISTRY}`, {
+        stdio: 'ignore',
+        cwd: __dirname,
+        timeout: INSTALL_TIMEOUT
+      });
+      const localNodeModules = path.join(__dirname, 'node_modules', packageName);
+      if (fs.existsSync(path.join(localNodeModules, 'package.json'))) {
+        return localNodeModules;
+      }
+    } catch (altErr) {
+      // 更新失败，返回null
+    }
+    return null;
+  }
+}
+
+function checkAndUpdateIfNeeded(packageName, binDir) {
+  const localVersion = getLocalVersion(packageName, binDir);
+  if (!localVersion) {
+    return binDir; // 无法获取本地版本，直接返回
+  }
+  
+  const latestVersion = getLatestVersion(packageName);
+  if (!latestVersion) {
+    return binDir; // 无法获取最新版本，直接返回
+  }
+  
+  if (compareVersions(localVersion, latestVersion) < 0) {
+    // 本地版本较旧，默认自动更新
+    if (shouldSkipUpdate()) {
+      // 用户明确禁用了自动更新，仅提示
+      console.warn(`\n⚠️  New version available: ${latestVersion} (current: ${localVersion})`);
+      console.warn(`   To enable auto-update, remove --no-update flag or DEVECO_MCP_NO_AUTO_UPDATE env var`);
+      console.warn(`   Or manually run: npm install -g ${packageName}@latest\n`);
+      return binDir;
+    }
+    
+    // 默认自动更新
+    const installDir = getInstallDirectory();
+    const updatedBinDir = updatePackage(packageName, installDir);
+    if (updatedBinDir) {
+      return updatedBinDir;
+    } else {
+      console.error(`⚠️  Failed to update ${packageName}, using existing version ${localVersion}`);
+      return binDir;
+    }
+  }
+  
+  return binDir;
+}
+
+function printTroubleshootingSteps(packageName) {
+  console.error('\n❌ Failed to install platform package automatically.');
+  console.error('\nTroubleshooting steps:');
+  console.error(`\n1. Check npm registry (should be ${OFFICIAL_REGISTRY}/):`);
+  console.error(`   npm config get registry`);
+  console.error(`   npm config set registry ${OFFICIAL_REGISTRY}/`);
+  console.error(`\n2. Clear npm cache:`);
+  console.error(`   npm cache clean --force`);
+  console.error(`\n3. Manual install (recommended):`);
+  console.error(`   npm install -g ${packageName}`);
+  console.error(`   npm install -g deveco-mcp-server`);
+  console.error(`\n4. Or use with registry flag in MCP config:`);
+  console.error(`   "args": ["--registry=${OFFICIAL_REGISTRY}", "-y", "deveco-mcp-server"]`);
+  console.error(`\n5. Check if package exists:`);
+  console.error(`   npm view ${packageName}`);
+}
+
 function getBinaryPaths() {
   const packageName = getPlatformPackage();
   
+  // Try to resolve existing package
   try {
     const packagePath = require.resolve(packageName);
-    const binDir = path.dirname(packagePath);
+    let binDir = path.dirname(packagePath);
     
-    if (process.platform === 'win32') {
-      return {
-        server: path.join(binDir, 'deveco-mcp-server.exe'),
-        toolbox: path.join(binDir, 'deveco-toolbox.exe')
-      };
-    } else {
-      return {
-        server: path.join(binDir, 'Contents', 'MacOS', 'deveco-mcp-server'),
-        toolbox: path.join(binDir, 'Contents', 'MacOS', 'deveco-toolbox')
-      };
-    }
-  } catch (err) {
-    console.error(`Platform package ${packageName} not found.`);
-    console.error('Installing platform package automatically...');
+    // Check for updates if package is found locally
+    binDir = checkAndUpdateIfNeeded(packageName, binDir);
     
-    const { execSync } = require('child_process');
-    const os = require('os');
+    const binaryPaths = buildBinaryPaths(binDir);
     
-    // Detect if we're in npx temporary directory
-    const isNpx = __dirname.includes('_npx') || 
-                  __dirname.includes('npm-cache') || 
-                  __dirname.includes('npx-') ||
-                  process.env.npm_config_user_config;
+    // Verify server binary exists
+    if (!fs.existsSync(binaryPaths.server)) {
+      console.error(`Error: Server executable not found at ${binaryPaths.server}`);
+      console.error('Please run: npm install --force');
+      process.exit(1);
+    }
     
-    let installDir = __dirname;
-    let binDir = null;
+    return binaryPaths;
+  } catch (err) {
     
-    // If in npx, install to user's home directory cache
-    if (isNpx) {
-      const homeDir = os.homedir();
-      installDir = path.join(homeDir, '.deveco-mcp-cache');
-      
-      // Create cache directory if it doesn't exist
-      if (!fs.existsSync(installDir)) {
-        fs.mkdirSync(installDir, { recursive: true });
-      }
-    }
+    checkAndWarnRegistry();
+    
+    const installDir = getInstallDirectory();
+    let binDir;
     
     try {
-      // Install the platform package
-      execSync(`npm install ${packageName}`, {
-        stdio: 'pipe',
-        cwd: installDir,
-        timeout: 60000 // 60 second timeout
-      });
-      
-      // Find the installed package
-      const nodeModulesPath = path.join(installDir, 'node_modules', packageName);
-      if (fs.existsSync(nodeModulesPath)) {
-        binDir = nodeModulesPath;
-      } else {
-        // Try to resolve using require
-        try {
-          const packagePath = require.resolve(packageName, { paths: [installDir] });
-          binDir = path.dirname(packagePath);
-        } catch (resolveErr) {
-          // If resolve fails, use the node_modules path directly
-          binDir = nodeModulesPath;
-        }
-      }
+      binDir = installPackage(packageName, installDir);
     } catch (installErr) {
-      // Installation failed, try alternative: install to current directory
-      try {
-        execSync(`npm install ${packageName}`, {
-          stdio: 'pipe',
-          cwd: __dirname,
-          timeout: 60000
-        });
-        
-        const localNodeModules = path.join(__dirname, 'node_modules', packageName);
-        if (fs.existsSync(localNodeModules)) {
-          binDir = localNodeModules;
-        } else {
-          throw installErr;
-        }
-      } catch (altErr) {
-        // All installation attempts failed
-        console.error('\n❌ Failed to install platform package automatically.');
-        console.error('\nPlease try one of the following:');
-        console.error(`\n1. Global install (recommended):`);
-        console.error(`   npm install -g deveco-mcp-server`);
-        console.error(`\n2. Manual install:`);
-        console.error(`   npm install -g ${packageName}`);
-        console.error(`   npm install -g deveco-mcp-server`);
-        console.error(`\n3. Force reinstall:`);
-        console.error(`   npm cache clean --force`);
-        console.error(`   npm install -g deveco-mcp-server`);
-        process.exit(1);
-      }
+      printTroubleshootingSteps(packageName);
+      process.exit(1);
     }
     
-    // Use the installed package path
-    if (binDir && fs.existsSync(binDir)) {
-      if (process.platform === 'win32') {
-        return {
-          server: path.join(binDir, 'deveco-mcp-server.exe'),
-          toolbox: path.join(binDir, 'deveco-toolbox.exe')
-        };
-      } else {
-        return {
-          server: path.join(binDir, 'Contents', 'MacOS', 'deveco-mcp-server'),
-          toolbox: path.join(binDir, 'Contents', 'MacOS', 'deveco-toolbox')
-        };
-      }
+    // Verify the installed package exists and has the expected structure
+    if (!binDir || !fs.existsSync(binDir)) {
+      console.error('Failed to locate installed platform package.');
+      process.exit(1);
     }
     
-    // Should not reach here, but just in case
-    console.error('Failed to locate installed platform package.');
-    process.exit(1);
+    const binaryPaths = buildBinaryPaths(binDir);
+    
+    // Verify server binary exists
+    if (!fs.existsSync(binaryPaths.server)) {
+      console.error(`Installed package found at ${binDir}, but binary not at expected location.`);
+      console.error(`Expected: ${binaryPaths.server}`);
+      process.exit(1);
+    }
+    
+    return binaryPaths;
   }
 }
 
-const { server: serverExePath, toolbox: toolboxExePath } = getBinaryPaths();
-
-if (!fs.existsSync(serverExePath)) {
-  console.error(`Error: Server executable not found at ${serverExePath}`);
-  console.error('Please run: npm install --force');
-  process.exit(1);
-}
-
-// Ensure execution permissions on Unix-like systems
-if (process.platform !== 'win32') {
+function ensureExecutablePermissions(filePath) {
+  if (process.platform === 'win32') {
+    return;
+  }
+  
   try {
-    fs.chmodSync(serverExePath, 0o755);
-    if (toolboxExePath && fs.existsSync(toolboxExePath)) {
-      fs.chmodSync(toolboxExePath, 0o755);
-    }
+    fs.chmodSync(filePath, 0o755);
   } catch (err) {
-    console.warn(`Warning: Failed to set executable permissions: ${err.message}`);
+    console.error(`Warning: Failed to set executable permissions for ${filePath}: ${err.message}`);
+  }
+  
+  // On macOS, remove quarantine attribute and ad-hoc sign to avoid "Unknown system error -86"
+  if (process.platform === 'darwin') {
+    try {
+      // Remove quarantine attribute
+      execSync(`xattr -d com.apple.quarantine "${filePath}" 2>/dev/null || true`, { 
+        stdio: 'ignore',
+        timeout: 5000 
+      });
+      
+      // Ad-hoc sign the binary
+      execSync(`codesign --force --sign - "${filePath}" 2>/dev/null`, { 
+        stdio: 'ignore',
+        timeout: 10000 
+      });
+    } catch (err) {
+      // Silently ignore - binary might already be signed or user lacks permissions
+    }
   }
 }
 
-const args = process.argv.slice(2);
-const env = { 
-  ...process.env,
-  DEVECO_TOOLBOX_PATH: toolboxExePath 
-};
+function startServer() {
+  const { server: serverExePath, toolbox: toolboxExePath } = getBinaryPaths();
+
+  if (!fs.existsSync(serverExePath)) {
+    console.error(`Error: Server executable not found at ${serverExePath}`);
+    console.error('Please run: npm install --force');
+    process.exit(1);
+  }
+
+  // Ensure execution permissions on Unix-like systems
+  ensureExecutablePermissions(serverExePath);
+  if (toolboxExePath && fs.existsSync(toolboxExePath)) {
+    ensureExecutablePermissions(toolboxExePath);
+  }
+
+  const args = process.argv.slice(2);
+  const env = { 
+    ...process.env,
+    DEVECO_TOOLBOX_PATH: toolboxExePath 
+  };
 
-const child = spawn(serverExePath, args, {
-  stdio: 'inherit',
-  env: env
-});
+  const child = spawn(serverExePath, args, {
+    stdio: 'inherit',
+    env: env
+  });
 
-child.on('error', (err) => {
-  console.error('Failed to start deveco-mcp-server:', err);
-  process.exit(1);
-});
+  child.on('error', (err) => {
+    console.error('Failed to start deveco-mcp-server:', err);
+    process.exit(1);
+  });
+
+  child.on('close', (code) => {
+    process.exit(code);
+  });
+}
 
-child.on('close', (code) => {
-  process.exit(code);
-});
+startServer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deveco-mcp-server",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "NPM wrapper for deveco-mcp-server - HarmonyOS development MCP server with platform-specific binaries",
   "keywords": [
     "mcp",
@@ -16,12 +16,13 @@
     "deveco-mcp-server": "index.js"
   },
   "optionalDependencies": {
-    "deveco-mcp-server-win32-x64": "0.1.7",
-    "deveco-mcp-server-darwin-arm64": "0.1.7"
+    "deveco-mcp-server-darwin-arm64": "0.1.9",
+    "deveco-mcp-server-darwin-x64": "0.1.9",
+    "deveco-mcp-server-win32-x64": "^0.1.9"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/your-org/deveco-mcp.git"
+    "url": "https://github.com/open-deveco/deveco-toolbox.git"
   },
   "author": "",
   "license": "ISC"