@sqlx-mcp/sqlx-mcp/index.js

Rust MCP server for SQLx database management

#!/usr/bin/env node

const { spawn } = require('child_process');
const path = require('path');
const fs = require('fs');

function getPlatformPackage() {
  const platform = process.platform;
  const arch = process.arch;
  
  let platformName;
  if (platform === 'win32' && arch === 'x64') {
    platformName = 'windows-x64';
  } else if (platform === 'linux' && arch === 'x64') {
    platformName = 'linux-x64';
  } else if (platform === 'darwin' && arch === 'x64') {
    platformName = 'macos-x64';
  } else if (platform === 'darwin' && arch === 'arm64') {
    platformName = 'macos-arm64';
  } else {
    throw new Error(`Unsupported platform: ${platform}-${arch}`);
  }
  
  return `@sqlx-mcp/${platformName}`;
}

function getBinaryPath() {
  console.log('🔍 Debug: Starting binary path detection...');
  console.log(`🔍 Debug: Platform: ${process.platform}, Arch: ${process.arch}`);
  
  try {
    // 获取平台特定的包名
    const platformPackageName = getPlatformPackage();
    console.log(`🔍 Debug: Expected platform package: ${platformPackageName}`);
    
    // 尝试加载平台特定的包
    try {
      console.log(`🔍 Debug: Attempting to require('${platformPackageName}')...`);
      const platformPackage = require(platformPackageName);
      console.log(`🔍 Debug: Platform package loaded successfully`);
      
      const binaryPath = platformPackage.getBinaryPath();
      console.log(`🔍 Debug: Binary path from platform package: ${binaryPath}`);
      
      if (fs.existsSync(binaryPath)) {
        console.log(`🔍 Debug: Binary file exists at ${binaryPath}`);
        return binaryPath;
      } else {
        console.log(`🔍 Debug: Binary file NOT found at ${binaryPath}`);
        throw new Error(`Binary not found at ${binaryPath}`);
      }
    } catch (requireError) {
      console.log(`🔍 Debug: Failed to require platform package: ${requireError.message}`);
      console.log(`🔍 Debug: Error code: ${requireError.code}`);
      
      // 检查 node_modules 中是否存在平台包
      const nodeModulesPath = path.join(__dirname, 'node_modules', platformPackageName.replace('/', path.sep));
      console.log(`🔍 Debug: Checking for platform package at: ${nodeModulesPath}`);
      
      if (fs.existsSync(nodeModulesPath)) {
        console.log(`🔍 Debug: Platform package directory exists`);
        const packageJsonPath = path.join(nodeModulesPath, 'package.json');
        if (fs.existsSync(packageJsonPath)) {
          console.log(`🔍 Debug: package.json exists in platform package`);
          const indexJsPath = path.join(nodeModulesPath, 'index.js');
          if (fs.existsSync(indexJsPath)) {
            console.log(`🔍 Debug: index.js exists in platform package`);
          } else {
            console.log(`🔍 Debug: index.js NOT found in platform package`);
          }
        } else {
          console.log(`🔍 Debug: package.json NOT found in platform package`);
        }
      } else {
        console.log(`🔍 Debug: Platform package directory does NOT exist`);
      }
      
      throw requireError;
    }
    
  } catch (error) {
    console.log(`🔍 Debug: Platform package approach failed, trying fallback...`);
    
    // Fallback: 尝试从本地构建的二进制文件
    const localBinaryPath = path.join(__dirname, 'target', 'release', 
      process.platform === 'win32' ? 'sqlx-mcp.exe' : 'sqlx-mcp');
    
    console.log(`🔍 Debug: Checking local binary at: ${localBinaryPath}`);
    
    if (fs.existsSync(localBinaryPath)) {
      console.log('🔍 Debug: Using local build binary');
      return localBinaryPath;
    } else {
      console.log(`🔍 Debug: Local binary NOT found at ${localBinaryPath}`);
    }
    
    // 列出当前目录内容用于调试
    console.log(`🔍 Debug: Current directory (__dirname): ${__dirname}`);
    console.log(`🔍 Debug: Directory contents:`);
    try {
      const files = fs.readdirSync(__dirname);
      files.forEach(file => {
        const filePath = path.join(__dirname, file);
        const stats = fs.statSync(filePath);
        console.log(`🔍 Debug:   ${stats.isDirectory() ? '[DIR]' : '[FILE]'} ${file}`);
      });
    } catch (e) {
      console.log(`🔍 Debug: Failed to list directory: ${e.message}`);
    }
    
    // 检查 node_modules 目录
    const nodeModulesPath = path.join(__dirname, 'node_modules');
    console.log(`🔍 Debug: node_modules path: ${nodeModulesPath}`);
    if (fs.existsSync(nodeModulesPath)) {
      console.log(`🔍 Debug: node_modules exists, listing @sqlx-mcp packages:`);
      try {
        const nmContents = fs.readdirSync(nodeModulesPath);
        const sqlxMcpPath = path.join(nodeModulesPath, '@sqlx-mcp');
        if (fs.existsSync(sqlxMcpPath)) {
          const sqlxMcpPackages = fs.readdirSync(sqlxMcpPath);
          console.log(`🔍 Debug: @sqlx-mcp packages: ${sqlxMcpPackages.join(', ')}`);
        } else {
          console.log(`🔍 Debug: @sqlx-mcp directory not found in node_modules`);
        }
      } catch (e) {
        console.log(`🔍 Debug: Error reading node_modules: ${e.message}`);
      }
    } else {
      console.log(`🔍 Debug: node_modules does NOT exist`);
    }
    
    // 如果都找不到，提供错误信息
    const supportedPlatforms = [
      'win32-x64 (Windows 64-bit)',
      'linux-x64 (Linux 64-bit)', 
      'darwin-x64 (macOS Intel)',
      'darwin-arm64 (macOS Apple Silicon)'
    ];
    
    throw new Error(
      `Platform package not available.\n` +
      `Current platform: ${process.platform}-${process.arch}\n` +
      `Supported platforms:\n${supportedPlatforms.map(p => `  - ${p}`).join('\n')}\n\n` +
      `To fix this issue:\n` +
      `1. Check if your platform is supported\n` +
      `2. Try reinstalling: npm install @sqlx-mcp/sqlx-mcp\n` +
      `3. Build from source: cargo build --release\n` +
      `4. Download binary from GitHub releases`
    );
  }
}

function main() {
  try {
    const executablePath = getBinaryPath();
    
    // 启动MCP服务器
    const child = spawn(executablePath, process.argv.slice(2), {
      stdio: 'inherit'
    });

    child.on('exit', (code) => {
      process.exit(code);
    });

    child.on('error', (err) => {
      console.error('Failed to start sqlx-mcp:', err.message);
      process.exit(1);
    });
  } catch (error) {
    console.error('❌ Error:', error.message);
    process.exit(1);
  }
}

if (require.main === module) {
  main();
}

module.exports = { getBinaryPath, main };