@mcp-shark/mcp-shark 1.5.4 → 1.5.5

package/core/services/ConfigFileService.js

@@ -0,0 +1,210 @@
+import * as fs from 'node:fs';
+import { homedir } from 'node:os';
+import * as path from 'node:path';
+import { getMcpConfigPath } from '#core/configs/index.js';
+
+/**
+ * Service for configuration file operations
+ * Handles file I/O, path resolution, and backup/restore
+ */
+export class ConfigFileService {
+  constructor(logger, configDetectionService, configParserFactory) {
+    this.logger = logger;
+    this.originalConfigData = null;
+    this.detectionService = configDetectionService;
+    this.parserFactory = configParserFactory;
+  }
+
+  /**
+   * Resolve file path (expand ~ to home directory)
+   */
+  resolveFilePath(filePath) {
+    if (!filePath) {
+      return null;
+    }
+    return filePath.startsWith('~') ? path.join(homedir(), filePath.slice(1)) : filePath;
+  }
+
+  /**
+   * Read file content from path or use provided content
+   */
+  resolveFileData(filePath, fileContent) {
+    if (fileContent) {
+      const resolvedFilePath = filePath ? this.resolveFilePath(filePath) : null;
+      return { content: fileContent, resolvedFilePath };
+    }
+
+    if (!filePath) {
+      return null;
+    }
+
+    const resolvedFilePath = this.resolveFilePath(filePath);
+
+    if (!fs.existsSync(resolvedFilePath)) {
+      return null;
+    }
+
+    return {
+      content: fs.readFileSync(resolvedFilePath, 'utf-8'),
+      resolvedFilePath,
+    };
+  }
+
+  /**
+   * Parse JSON or TOML content safely using appropriate parser
+   */
+  parseJsonConfig(content, filePath = null) {
+    try {
+      const config = this.parserFactory.parse(content, filePath);
+      return { config, error: null };
+    } catch (error) {
+      return { config: null, error };
+    }
+  }
+
+  /**
+   * Try to parse JSON or TOML, return null on error
+   */
+  tryParseJson(content, filePath = null) {
+    return this.parserFactory.parse(content, filePath);
+  }
+
+  /**
+   * Read config file content
+   */
+  readConfigFile(filePath) {
+    const resolvedPath = this.resolveFilePath(filePath);
+
+    if (!fs.existsSync(resolvedPath)) {
+      return null;
+    }
+
+    return fs.readFileSync(resolvedPath, 'utf-8');
+  }
+
+  /**
+   * Write config file
+   */
+  writeConfigFile(filePath, content) {
+    const resolvedPath = this.resolveFilePath(filePath);
+    fs.writeFileSync(resolvedPath, content);
+    this.logger?.info({ path: resolvedPath }, 'Wrote config file');
+  }
+
+  /**
+   * Check if file exists
+   */
+  fileExists(filePath) {
+    const resolvedPath = this.resolveFilePath(filePath);
+    return fs.existsSync(resolvedPath);
+  }
+
+  /**
+   * Get file type from path
+   */
+  getFileType(filePath) {
+    if (!filePath) {
+      return 'JSON';
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    return ext === '.toml' ? 'TOML' : 'JSON';
+  }
+
+  /**
+   * Get display path (replace home directory with ~)
+   */
+  getDisplayPath(filePath) {
+    if (!filePath) {
+      return filePath;
+    }
+    const homeDir = homedir();
+    return filePath.replace(homeDir, '~');
+  }
+
+  /**
+   * Get home directory
+   */
+  getHomeDir() {
+    return homedir();
+  }
+
+  /**
+   * Detect config files on the system
+   */
+  detectConfigFiles() {
+    return this.detectionService.detectConfigFiles();
+  }
+
+  /**
+   * Get MCP config path
+   */
+  getMcpConfigPath() {
+    return getMcpConfigPath();
+  }
+
+  /**
+   * Read MCP config file (supports both JSON and TOML)
+   * Uses appropriate parser based on file extension
+   */
+  readMcpConfig() {
+    const configPath = this.getMcpConfigPath();
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(configPath, 'utf-8');
+    return this.parserFactory.parse(content, configPath);
+  }
+
+  /**
+   * Get servers from MCP config
+   */
+  getServersFromConfig() {
+    const config = this.readMcpConfig();
+    if (!config) {
+      return [];
+    }
+
+    return config.servers ? Object.keys(config.servers) : [];
+  }
+
+  /**
+   * Store original config for restoration
+   */
+  storeOriginalConfig(filePath, originalContent, backupPath) {
+    this.originalConfigData = { filePath, originalContent, backupPath };
+  }
+
+  /**
+   * Restore original config
+   */
+  restoreOriginalConfig() {
+    if (this.originalConfigData?.filePath) {
+      try {
+        if (fs.existsSync(this.originalConfigData.filePath)) {
+          fs.writeFileSync(
+            this.originalConfigData.filePath,
+            this.originalConfigData.originalContent
+          );
+          this.logger?.info({ path: this.originalConfigData.filePath }, 'Restored original config');
+          this.originalConfigData = null;
+          return true;
+        }
+        this.originalConfigData = null;
+        return false;
+      } catch (error) {
+        this.logger?.error({ error: error.message }, 'Failed to restore original config');
+        this.originalConfigData = null;
+        return false;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Clear original config reference
+   */
+  clearOriginalConfig() {
+    this.originalConfigData = null;
+  }
+}

package/core/services/ConfigPatchingService.js

@@ -0,0 +1,137 @@
+/**
+ * Service for handling config patching operations
+ * Handles checking if config is patched, restoring original, and repatching
+ */
+export class ConfigPatchingService {
+  /**
+   * @param {ConfigService} configService - Config service instance
+   * @param {BackupService} backupService - Backup service instance
+   * @param {object} logger - Logger instance
+   */
+  constructor(configService, backupService, logger) {
+    this.configService = configService;
+    this.backupService = backupService;
+    this.logger = logger;
+  }
+
+  /**
+   * Restore original config if file is already patched
+   * Should be called before processing setup to ensure original config is read
+   * @param {string} filePath - Path to config file
+   * @returns {{wasPatched: boolean, restored: boolean, warning?: string}}
+   */
+  restoreIfPatched(filePath) {
+    const resolvedPath = this.configService.fileService.resolveFilePath(filePath);
+    const isPatched = this.configService.isFilePatched(resolvedPath);
+
+    if (!isPatched) {
+      return { wasPatched: false, restored: false };
+    }
+
+    // Config is already patched - restore original first
+    this.logger?.warn(
+      { filePath: resolvedPath },
+      'Config file is already patched, restoring original before processing'
+    );
+
+    // Try to restore from in-memory backup first
+    const inMemoryRestored = this.configService.restoreOriginalConfig();
+
+    // If that didn't work, use BackupService to find and restore from backup file
+    const restoreResult = inMemoryRestored
+      ? { success: true }
+      : this._restoreFromBackupFile(resolvedPath);
+
+    const restored = restoreResult.success;
+    const warning = restored
+      ? 'Config was already patched. Restored original before processing.'
+      : 'Config was patched but could not restore original. Proceeding anyway.';
+
+    if (!restored) {
+      this.logger?.warn(
+        { filePath: resolvedPath },
+        'Could not restore original config - may cause issues'
+      );
+    } else {
+      this.logger?.info({ filePath: resolvedPath }, 'Restored original config successfully');
+    }
+
+    return { wasPatched: true, restored, warning };
+  }
+
+  /**
+   * Patch config file, restoring original first if already patched
+   * @param {string} filePath - Path to config file
+   * @param {object} patchedConfig - Config object to write (already patched)
+   * @returns {{wasPatched: boolean, restored: boolean, warning?: string}}
+   */
+  patchConfigFile(filePath, patchedConfig) {
+    const resolvedPath = this.configService.fileService.resolveFilePath(filePath);
+    const isPatched = this.configService.isFilePatched(resolvedPath);
+
+    if (!isPatched) {
+      // Not patched, just write the patched config
+      this.configService.writeConfigAsJson(resolvedPath, patchedConfig);
+      return { wasPatched: false, restored: false };
+    }
+
+    // Config is already patched - restore original first
+    this.logger?.warn(
+      { filePath: resolvedPath },
+      'Config file is already patched, restoring original before repatching'
+    );
+
+    // Try to restore from in-memory backup first
+    const inMemoryRestored = this.configService.restoreOriginalConfig();
+
+    // If that didn't work, use BackupService to find and restore from backup file
+    const restoreResult = inMemoryRestored
+      ? { success: true }
+      : this._restoreFromBackupFile(resolvedPath);
+
+    const restored = restoreResult.success;
+    const warning = restored
+      ? 'Config was already patched. Restored original and repatched.'
+      : 'Config was patched but could not restore original. Proceeding anyway.';
+
+    if (!restored) {
+      this.logger?.warn(
+        { filePath: resolvedPath },
+        'Could not restore original config - may cause issues'
+      );
+    }
+
+    // Now write the patched config
+    this.configService.writeConfigAsJson(resolvedPath, patchedConfig);
+
+    return { wasPatched: true, restored, warning };
+  }
+
+  /**
+   * Restore config from backup file using BackupService
+   * @private
+   * @param {string} filePath - Path to config file to restore
+   * @returns {{success: boolean}}
+   */
+  _restoreFromBackupFile(filePath) {
+    const backups = this.backupService.listBackups();
+    const matchingBackup = backups.find((backup) => backup.originalPath === filePath);
+
+    if (!matchingBackup) {
+      return { success: false };
+    }
+
+    this.logger?.info(
+      { backupPath: matchingBackup.backupPath },
+      'Found backup file, restoring from backup'
+    );
+
+    const restoreResult = this.backupService.restoreBackup(
+      matchingBackup.backupPath,
+      filePath,
+      false
+    );
+
+    return { success: restoreResult.success };
+  }
+}

package/core/services/ConfigService.js

@@ -0,0 +1,250 @@
+/**
+ * Service for configuration file operations
+ * Composes ConfigFileService and ConfigTransformService
+ * Uses dependency injection for all dependencies
+ */
+export class ConfigService {
+  /**
+   * @param {Object} logger - Logger instance
+   * @param {ConfigFileService} configFileService - File service instance
+   * @param {ConfigTransformService} configTransformService - Transform service instance
+   * @param {ConfigDetectionService} configDetectionService - Detection service instance
+   */
+  constructor(logger, configFileService, configTransformService, configDetectionService) {
+    this.fileService = configFileService;
+    this.transformService = configTransformService;
+    this.detectionService = configDetectionService;
+    this.logger = logger;
+  }
+
+  resolveFilePath(filePath) {
+    return this.fileService.resolveFilePath(filePath);
+  }
+
+  resolveFileData(filePath, fileContent) {
+    return this.fileService.resolveFileData(filePath, fileContent);
+  }
+
+  parseJsonConfig(content) {
+    return this.fileService.parseJsonConfig(content);
+  }
+
+  tryParseJson(content) {
+    return this.fileService.tryParseJson(content);
+  }
+
+  readConfigFile(filePath) {
+    return this.fileService.readConfigFile(filePath);
+  }
+
+  writeConfigFile(filePath, content) {
+    return this.fileService.writeConfigFile(filePath, content);
+  }
+
+  fileExists(filePath) {
+    return this.fileService.fileExists(filePath);
+  }
+
+  convertMcpServersToServers(config) {
+    return this.transformService.convertMcpServersToServers(config);
+  }
+
+  extractServices(config) {
+    return this.transformService.extractServices(config);
+  }
+
+  filterServers(config, selectedServices) {
+    return this.transformService.filterServers(config, selectedServices);
+  }
+
+  detectConfigFiles() {
+    return this.fileService.detectConfigFiles();
+  }
+
+  getMcpConfigPath() {
+    return this.fileService.getMcpConfigPath();
+  }
+
+  readMcpConfig() {
+    return this.fileService.readMcpConfig();
+  }
+
+  getServersFromConfig() {
+    return this.fileService.getServersFromConfig();
+  }
+
+  updateConfigForMcpShark(originalConfig) {
+    return this.transformService.updateConfigForMcpShark(originalConfig);
+  }
+
+  getSelectedServiceNames(originalConfig, selectedServices) {
+    return this.transformService.getSelectedServiceNames(originalConfig, selectedServices);
+  }
+
+  storeOriginalConfig(filePath, originalContent, backupPath) {
+    return this.fileService.storeOriginalConfig(filePath, originalContent, backupPath);
+  }
+
+  restoreOriginalConfig() {
+    return this.fileService.restoreOriginalConfig();
+  }
+
+  clearOriginalConfig() {
+    return this.fileService.clearOriginalConfig();
+  }
+
+  getFileType(filePath) {
+    return this.fileService.getFileType(filePath);
+  }
+
+  getDisplayPath(filePath) {
+    return this.fileService.getDisplayPath(filePath);
+  }
+
+  getHomeDir() {
+    return this.fileService.getHomeDir();
+  }
+
+  /**
+   * Extract services from file (handles full flow)
+   */
+  extractServicesFromFile(filePath, fileContent) {
+    const fileData = this.fileService.resolveFileData(filePath, fileContent);
+    if (!fileData) {
+      const resolvedFilePath = filePath ? this.fileService.resolveFilePath(filePath) : null;
+      return {
+        success: false,
+        error: 'File not found',
+        path: resolvedFilePath,
+      };
+    }
+
+    const parseResult = this.fileService.parseJsonConfig(
+      fileData.content,
+      fileData.resolvedFilePath
+    );
+    if (!parseResult.config) {
+      const fileType = this.fileService.getFileType(fileData.resolvedFilePath);
+      return {
+        success: false,
+        error: `Invalid ${fileType} file`,
+        details: parseResult.error ? parseResult.error.message : `Failed to parse ${fileType}`,
+      };
+    }
+
+    const services = this.transformService.extractServices(parseResult.config);
+    return {
+      success: true,
+      services,
+    };
+  }
+
+  /**
+   * Read config file with metadata
+   */
+  readConfigFileWithMetadata(filePath) {
+    const resolvedPath = this.fileService.resolveFilePath(filePath);
+
+    if (!this.fileService.fileExists(resolvedPath)) {
+      return {
+        success: false,
+        error: 'File not found',
+        path: resolvedPath,
+      };
+    }
+
+    const content = this.fileService.readConfigFile(resolvedPath);
+    const parsed = this.fileService.tryParseJson(content, resolvedPath);
+
+    return {
+      success: true,
+      filePath: resolvedPath,
+      displayPath: this.fileService.getDisplayPath(resolvedPath),
+      content,
+      parsed,
+      exists: true,
+    };
+  }
+
+  /**
+   * Process setup: parse, convert, filter, and prepare config
+   */
+  processSetup(filePath, fileContent, selectedServices) {
+    const fileData = this.fileService.resolveFileData(filePath, fileContent);
+    if (!fileData) {
+      const resolvedFilePath = filePath ? this.fileService.resolveFilePath(filePath) : null;
+      return {
+        success: false,
+        error: 'File not found',
+        path: resolvedFilePath,
+      };
+    }
+
+    const parseResult = this.fileService.parseJsonConfig(
+      fileData.content,
+      fileData.resolvedFilePath
+    );
+    if (!parseResult.config) {
+      const fileType = this.fileService.getFileType(fileData.resolvedFilePath);
+      return {
+        success: false,
+        error: `Invalid ${fileType} file`,
+        details: parseResult.error ? parseResult.error.message : `Failed to parse ${fileType}`,
+      };
+    }
+
+    const originalConfig = parseResult.config;
+    const baseConvertedConfig = this.transformService.convertMcpServersToServers(originalConfig);
+
+    const convertedConfig =
+      selectedServices && Array.isArray(selectedServices) && selectedServices.length > 0
+        ? this.transformService.filterServers(baseConvertedConfig, selectedServices)
+        : baseConvertedConfig;
+
+    if (Object.keys(convertedConfig.servers || {}).length === 0) {
+      return {
+        success: false,
+        error: 'No servers found in config',
+      };
+    }
+
+    const updatedConfig = this.transformService.updateConfigForMcpShark(originalConfig);
+
+    return {
+      success: true,
+      fileData,
+      originalConfig,
+      convertedConfig,
+      updatedConfig,
+    };
+  }
+
+  /**
+   * Write config as JSON string
+   * @param {string} filePath - Path to config file
+   * @param {object} config - Config object to write
+   */
+  writeConfigAsJson(filePath, config) {
+    const jsonContent = JSON.stringify(config, null, 2);
+    this.fileService.writeConfigFile(filePath, jsonContent);
+  }
+
+  /**
+   * Check if config file is patched by mcp-shark
+   */
+  isConfigPatched(config) {
+    return this.transformService.isConfigPatched(config);
+  }
+
+  /**
+   * Check if a file path contains a patched config
+   */
+  isFilePatched(filePath) {
+    if (!this.fileService.fileExists(filePath)) {
+      return false;
+    }
+    const content = this.fileService.readConfigFile(filePath);
+    const parseResult = this.fileService.parseJsonConfig(content, filePath);
+    return parseResult.config ? this.isConfigPatched(parseResult.config) : false;
+  }
+}