@mcp-shark/mcp-shark 1.4.1 → 1.5.0

package/ui/server/utils/config-update.js

@@ -1,7 +1,8 @@
 import * as fs from 'node:fs';
-import * as path from 'node:path';
 import { homedir } from 'node:os';
+import * as path from 'node:path';
 import { storeOriginalConfig } from './config.js';
+import logger from './logger.js';
 
 function findLatestBackup(filePath) {
   const dir = path.dirname(filePath);
@@ -51,143 +52,144 @@ function findLatestBackup(filePath) {
     backups.sort((a, b) => b.modifiedAt - a.modifiedAt);
     return backups[0].backupPath;
   } catch (error) {
-    console.error('Error finding latest backup:', error);
+    logger.error({ error: error.message }, 'Error finding latest backup');
     return null;
   }
 }
 
-export function updateConfigFile(
-  originalConfig,
-  selectedServiceNames,
+function shouldCreateBackup(
+  latestBackupPath,
   resolvedFilePath,
   content,
   mcpSharkLogs,
   broadcastLogUpdate
 ) {
-  const hasMcpServers = originalConfig.mcpServers && typeof originalConfig.mcpServers === 'object';
-  const hasServers = originalConfig.servers && typeof originalConfig.servers === 'object';
-
-  const updatedConfig = { ...originalConfig };
-
-  if (hasMcpServers) {
-    const updatedMcpServers = {};
-    if (selectedServiceNames.size > 0) {
-      updatedMcpServers['mcp-shark-server'] = {
-        type: 'http',
-        url: 'http://localhost:9851/mcp',
-      };
-    }
-    Object.entries(originalConfig.mcpServers).forEach(([name, cfg]) => {
-      if (!selectedServiceNames.has(name)) {
-        updatedMcpServers[name] = cfg;
-      }
-    });
-    updatedConfig.mcpServers = updatedMcpServers;
-  } else if (hasServers) {
-    const updatedServers = {};
-    if (selectedServiceNames.size > 0) {
-      updatedServers['mcp-shark-server'] = {
-        type: 'http',
-        url: 'http://localhost:9851/mcp',
-      };
-    }
-    Object.entries(originalConfig.servers).forEach(([name, cfg]) => {
-      if (!selectedServiceNames.has(name)) {
-        updatedServers[name] = cfg;
-      }
-    });
-    updatedConfig.servers = updatedServers;
-  } else {
-    updatedConfig.mcpServers = {
-      'mcp-shark-server': {
-        type: 'http',
-        url: 'http://localhost:9851/mcp',
-      },
-    };
+  if (!latestBackupPath || !fs.existsSync(latestBackupPath)) {
+    return true;
   }
 
-  let createdBackupPath = null;
-  if (resolvedFilePath && fs.existsSync(resolvedFilePath)) {
-    // Check if we need to create a backup by comparing with latest backup
-    const latestBackupPath = findLatestBackup(resolvedFilePath);
-    let shouldCreateBackup = true;
+  try {
+    const latestBackupContent = fs.readFileSync(latestBackupPath, 'utf-8');
+    const currentContent = content || fs.readFileSync(resolvedFilePath, 'utf-8');
 
-    if (latestBackupPath && fs.existsSync(latestBackupPath)) {
+    // Normalize both contents for comparison (remove whitespace differences)
+    const normalizeContent = (str) => {
       try {
-        const latestBackupContent = fs.readFileSync(latestBackupPath, 'utf-8');
-        const currentContent = content || fs.readFileSync(resolvedFilePath, 'utf-8');
-
-        // Normalize both contents for comparison (remove whitespace differences)
-        const normalizeContent = (str) => {
-          try {
-            // Try to parse as JSON and re-stringify to normalize
-            return JSON.stringify(JSON.parse(str), null, 2);
-          } catch {
-            // If not valid JSON, just trim
-            return str.trim();
-          }
-        };
-
-        const normalizedBackup = normalizeContent(latestBackupContent);
-        const normalizedCurrent = normalizeContent(currentContent);
-
-        if (normalizedBackup === normalizedCurrent) {
-          shouldCreateBackup = false;
-          const timestamp = new Date().toISOString();
-          const skipLog = {
-            timestamp,
-            type: 'stdout',
-            line: `[BACKUP] Skipped backup (no changes detected): ${resolvedFilePath.replace(homedir(), '~')}`,
-          };
-          mcpSharkLogs.push(skipLog);
-          if (mcpSharkLogs.length > 10000) {
-            mcpSharkLogs.shift();
-          }
-          broadcastLogUpdate(skipLog);
-        }
-      } catch (error) {
-        console.error('Error comparing with latest backup:', error);
-        // If comparison fails, create backup to be safe
-        shouldCreateBackup = true;
+        // Try to parse as JSON and re-stringify to normalize
+        return JSON.stringify(JSON.parse(str), null, 2);
+      } catch {
+        // If not valid JSON, just trim
+        return str.trim();
       }
-    }
+    };
 
-    if (shouldCreateBackup) {
-      // Create backup with new format: .mcp.json-mcpshark.<datetime>.json
-      const now = new Date();
-      // Format: YYYY-MM-DD_HH-MM-SS
-      const year = now.getFullYear();
-      const month = String(now.getMonth() + 1).padStart(2, '0');
-      const day = String(now.getDate()).padStart(2, '0');
-      const hours = String(now.getHours()).padStart(2, '0');
-      const minutes = String(now.getMinutes()).padStart(2, '0');
-      const seconds = String(now.getSeconds()).padStart(2, '0');
-      const datetimeStr = `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
-      const dir = path.dirname(resolvedFilePath);
-      const basename = path.basename(resolvedFilePath);
-      createdBackupPath = path.join(dir, `.${basename}-mcpshark.${datetimeStr}.json`);
-      fs.copyFileSync(resolvedFilePath, createdBackupPath);
-      storeOriginalConfig(resolvedFilePath, content, createdBackupPath);
+    const normalizedBackup = normalizeContent(latestBackupContent);
+    const normalizedCurrent = normalizeContent(currentContent);
 
+    if (normalizedBackup === normalizedCurrent) {
       const timestamp = new Date().toISOString();
-      const backupLog = {
+      const skipLog = {
         timestamp,
         type: 'stdout',
-        line: `[BACKUP] Created backup: ${createdBackupPath.replace(homedir(), '~')}`,
+        line: `[BACKUP] Skipped backup (no changes detected): ${resolvedFilePath.replace(homedir(), '~')}`,
       };
-      mcpSharkLogs.push(backupLog);
+      mcpSharkLogs.push(skipLog);
       if (mcpSharkLogs.length > 10000) {
         mcpSharkLogs.shift();
       }
-      broadcastLogUpdate(backupLog);
-    } else {
-      // Still store the original config reference even if we didn't create a new backup
-      // Use the latest backup path if available
-      storeOriginalConfig(resolvedFilePath, content, latestBackupPath);
+      broadcastLogUpdate(skipLog);
+      return false;
     }
+    return true;
+  } catch (error) {
+    logger.error({ error: error.message }, 'Error comparing with latest backup');
+    // If comparison fails, create backup to be safe
+    return true;
+  }
+}
 
+function createBackup(resolvedFilePath, content, mcpSharkLogs, broadcastLogUpdate) {
+  // Create backup with new format: .mcp.json-mcpshark.<datetime>.json
+  const datetimeStr = formatDateTimeForBackup();
+  const dir = path.dirname(resolvedFilePath);
+  const basename = path.basename(resolvedFilePath);
+  const backupPath = path.join(dir, `.${basename}-mcpshark.${datetimeStr}.json`);
+  fs.copyFileSync(resolvedFilePath, backupPath);
+  storeOriginalConfig(resolvedFilePath, content, backupPath);
+
+  const timestamp = new Date().toISOString();
+  const backupLog = {
+    timestamp,
+    type: 'stdout',
+    line: `[BACKUP] Created backup: ${backupPath.replace(homedir(), '~')}`,
+  };
+  mcpSharkLogs.push(backupLog);
+  if (mcpSharkLogs.length > 10000) {
+    mcpSharkLogs.shift();
+  }
+  broadcastLogUpdate(backupLog);
+  return backupPath;
+}
+
+function computeBackupPath(resolvedFilePath, content, mcpSharkLogs, broadcastLogUpdate) {
+  if (!resolvedFilePath || !fs.existsSync(resolvedFilePath)) {
+    return null;
+  }
+
+  // Check if we need to create a backup by comparing with latest backup
+  const latestBackupPath = findLatestBackup(resolvedFilePath);
+  const needsBackup = shouldCreateBackup(
+    latestBackupPath,
+    resolvedFilePath,
+    content,
+    mcpSharkLogs,
+    broadcastLogUpdate
+  );
+
+  if (needsBackup) {
+    return createBackup(resolvedFilePath, content, mcpSharkLogs, broadcastLogUpdate);
+  }
+
+  // Still store the original config reference even if we didn't create a new backup
+  // Use the latest backup path if available
+  storeOriginalConfig(resolvedFilePath, content, latestBackupPath);
+  return null;
+}
+
+export function updateConfigFile(
+  originalConfig,
+  _selectedServiceNames,
+  resolvedFilePath,
+  content,
+  mcpSharkLogs,
+  broadcastLogUpdate
+) {
+  const [serverObject, serverType] = getServerObject(originalConfig);
+  const updatedConfig = { ...originalConfig };
+
+  if (serverObject) {
+    const updatedServers = {};
+    // Transform all original servers to HTTP URLs pointing to MCP shark server
+    // Each server gets its own endpoint to avoid tool name prefixing issues
+    Object.entries(serverObject).forEach(([name, _cfg]) => {
+      updatedServers[name] = {
+        type: 'http',
+        url: `http://localhost:9851/mcp/${encodeURIComponent(name)}`,
+      };
+    });
+    updatedConfig[serverType] = updatedServers;
+  }
+
+  const createdBackupPath = computeBackupPath(
+    resolvedFilePath,
+    content,
+    mcpSharkLogs,
+    broadcastLogUpdate
+  );
+
+  if (resolvedFilePath && fs.existsSync(resolvedFilePath)) {
     fs.writeFileSync(resolvedFilePath, JSON.stringify(updatedConfig, null, 2));
-    console.log(`Updated config file: ${resolvedFilePath}`);
+    logger.info({ path: resolvedFilePath }, 'Updated config file');
   }
 
   return { updatedConfig, backupPath: createdBackupPath };
@@ -210,3 +212,29 @@ export function getSelectedServiceNames(originalConfig, selectedServices) {
 
   return selectedServiceNames;
 }
+
+function getServerObject(originalConfig) {
+  const hasMcpServers = originalConfig.mcpServers && typeof originalConfig.mcpServers === 'object';
+  const hasServers = originalConfig.servers && typeof originalConfig.servers === 'object';
+
+  if (hasMcpServers) {
+    return [originalConfig.mcpServers, 'mcpServers'];
+  }
+
+  if (hasServers) {
+    return [originalConfig.servers, 'servers'];
+  }
+
+  return [null, null];
+}
+
+export function formatDateTimeForBackup() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  const seconds = String(now.getSeconds()).padStart(2, '0');
+  return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
+}

package/ui/server/utils/config.js

@@ -1,5 +1,5 @@
 import * as fs from 'node:fs';
-import { homedir } from 'node:os';
+import logger from './logger.js';
 
 const state = { originalConfigData: null };
 
@@ -8,21 +8,21 @@ export function storeOriginalConfig(filePath, originalContent, backupPath) {
 }
 
 export function restoreOriginalConfig(mcpSharkLogs, broadcastLogUpdate) {
-  if (state.originalConfigData && state.originalConfigData.filePath) {
+  if (state.originalConfigData?.filePath) {
     try {
       if (fs.existsSync(state.originalConfigData.filePath)) {
         fs.writeFileSync(
           state.originalConfigData.filePath,
           state.originalConfigData.originalContent
         );
-        console.log(`Restored original config to: ${state.originalConfigData.filePath}`);
+        logger.info({ path: state.originalConfigData.filePath }, 'Restored original config');
         state.originalConfigData = null;
         return true;
       }
       state.originalConfigData = null;
       return false;
     } catch (error) {
-      console.error('Failed to restore original config:', error);
+      logger.error({ error: error.message }, 'Failed to restore original config');
       const timestamp = new Date().toISOString();
       const errorLog = {
         timestamp,

package/ui/server/utils/logger.js

@@ -0,0 +1,2 @@
+// Re-export shared logger
+export { default } from '../../../shared/logger.js';

package/ui/server/utils/paths.js

@@ -1,10 +1,26 @@
-import * as path from 'node:path';
+import { execSync } from 'node:child_process';
 import * as fs from 'node:fs';
-import { fileURLToPath } from 'url';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import logger from './logger.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+function getNvmNodeBinPaths(homeDir) {
+  try {
+    const nvmVersionsPath = path.join(homeDir, '.nvm', 'versions', 'node');
+    if (fs.existsSync(nvmVersionsPath)) {
+      return fs
+        .readdirSync(nvmVersionsPath, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => path.join(nvmVersionsPath, dirent.name, 'bin'));
+    }
+  } catch (_e) {}
+  return [];
+}
+
 export function findMcpServerPath() {
   const pathsToCheck = [
     path.join(process.cwd(), '../mcp-server'),
@@ -21,3 +37,195 @@ export function findMcpServerPath() {
 
   return path.join(process.cwd(), '../mcp-server');
 }
+
+/**
+ * Get system PATH from the host machine's shell environment
+ * This works in Electron by executing a shell command to get the actual PATH
+ * Includes both system PATH and user's custom PATH from shell config files
+ */
+function getSystemPath() {
+  try {
+    if (process.platform === 'win32') {
+      const pathOutput = execSync('cmd /c echo %PATH%', {
+        encoding: 'utf8',
+        timeout: 2000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+      return pathOutput.trim();
+    }
+    const userShell = process.env.SHELL || '/bin/zsh';
+    const shells = [userShell, '/bin/zsh', '/bin/bash', '/bin/sh'];
+
+    for (const shell of shells) {
+      if (fs.existsSync(shell)) {
+        try {
+          const shellName = path.basename(shell);
+
+          const getPathOutput = (shell, shellName) => {
+            const execOptions = {
+              encoding: 'utf8',
+              timeout: 2000,
+              stdio: ['ignore', 'pipe', 'ignore'],
+              maxBuffer: 1024 * 1024,
+              env: {
+                ...Object.fromEntries(
+                  Object.entries(process.env).filter(([key]) => key !== 'PATH')
+                ),
+              },
+            };
+
+            if (shellName === 'zsh') {
+              try {
+                return execSync(`${shell} -i -c 'echo $PATH'`, execOptions);
+              } catch (_e) {
+                return execSync(`${shell} -l -c 'echo $PATH'`, execOptions);
+              }
+            }
+
+            return execSync(`${shell} -l -c 'echo $PATH'`, execOptions);
+          };
+
+          const pathOutput = getPathOutput(shell, shellName);
+          const systemPath = pathOutput.trim();
+          if (systemPath) {
+            logger.info({ shell, shellName }, 'Got PATH from shell');
+            return systemPath;
+          }
+        } catch (_e) {}
+      }
+    }
+
+    const homeDir = os.homedir();
+    const configFiles = [
+      { file: path.join(homeDir, '.zshrc'), shell: 'zsh', interactive: true },
+      { file: path.join(homeDir, '.zprofile'), shell: 'zsh', interactive: false },
+      { file: path.join(homeDir, '.zlogin'), shell: 'zsh', interactive: false },
+      { file: path.join(homeDir, '.bashrc'), shell: 'bash', interactive: true },
+      { file: path.join(homeDir, '.bash_profile'), shell: 'bash', interactive: false },
+      { file: path.join(homeDir, '.profile'), shell: 'sh', interactive: false },
+    ];
+
+    for (const { file, shell: shellName, interactive } of configFiles) {
+      if (fs.existsSync(file)) {
+        try {
+          const flag = shellName === 'zsh' && interactive ? '-i' : '';
+          const pathOutput = execSync(
+            `/bin/${shellName} ${flag} -c 'source ${file} 2>/dev/null; echo $PATH'`,
+            {
+              encoding: 'utf8',
+              timeout: 2000,
+              stdio: ['ignore', 'pipe', 'ignore'],
+              maxBuffer: 1024 * 1024,
+              env: {
+                ...Object.fromEntries(
+                  Object.entries(process.env).filter(([key]) => key !== 'PATH')
+                ),
+              },
+            }
+          );
+          const systemPath = pathOutput.trim();
+          if (systemPath && systemPath.length > 10) {
+            logger.info({ file }, 'Got PATH from file');
+            return systemPath;
+          }
+        } catch (_e) {}
+      }
+    }
+  } catch (error) {
+    logger.warn({ error: error.message }, 'Could not get system PATH');
+  }
+  return null;
+}
+
+/**
+ * Enhance PATH environment variable to include system paths and user paths
+ * This is especially important in Electron where PATH might not include system executables
+ */
+export function enhancePath(originalPath) {
+  const homeDir = os.homedir();
+  const pathSeparator = process.platform === 'win32' ? ';' : ':';
+
+  const systemPath = getSystemPath();
+  if (systemPath) {
+    logger.info('Using system PATH from host machine');
+    const userPaths = [
+      path.join(homeDir, '.local', 'bin'),
+      path.join(homeDir, '.npm-global', 'bin'),
+      path.join(homeDir, '.cargo', 'bin'),
+      path.join(homeDir, 'bin'),
+      path.join(homeDir, '.nvm', 'current', 'bin'),
+      ...getNvmNodeBinPaths(homeDir),
+      path.join(homeDir, '.fnm', 'node-versions', 'v20.0.0', 'install', 'bin'),
+      path.join(homeDir, '.pyenv', 'shims'),
+      path.join(homeDir, '.pyenv', 'bin'),
+      path.join(homeDir, '.gvm', 'bin'),
+      path.join(homeDir, '.gvm', 'gos', 'current', 'bin'),
+      path.join(homeDir, '.cargo', 'bin'),
+      path.join(homeDir, 'go', 'bin'),
+      path.join(homeDir, '.go', 'bin'),
+      '/Applications/iTerm.app/Contents/Resources/utilities',
+      ...(process.platform === 'win32'
+        ? [
+            path.join(homeDir, 'AppData', 'Local', 'Programs'),
+            path.join(homeDir, 'AppData', 'Roaming', 'npm'),
+            path.join(homeDir, 'AppData', 'Local', 'Microsoft', 'WindowsApps'),
+          ]
+        : []),
+    ].filter((p) => {
+      if (p.includes('v20.0.0') || p.includes('current')) {
+        return fs.existsSync(path.dirname(p));
+      }
+      return fs.existsSync(p);
+    });
+
+    return [systemPath, ...userPaths, originalPath || ''].filter((p) => p).join(pathSeparator);
+  }
+
+  logger.info('Could not get system PATH, adding common locations');
+  const pathsToAdd = [
+    '/usr/local/bin',
+    '/usr/bin',
+    '/opt/homebrew/bin',
+    '/usr/local/opt/node/bin',
+    '/opt/local/bin',
+    '/sbin',
+    '/usr/sbin',
+    ...(process.platform === 'darwin'
+      ? [
+          '/opt/homebrew/opt/python/bin',
+          '/usr/local/opt/python/bin',
+          '/Applications/Docker.app/Contents/Resources/bin',
+        ]
+      : []),
+    ...(process.platform === 'linux' ? ['/snap/bin', path.join(homeDir, '.local', 'bin')] : []),
+    ...(process.platform === 'win32'
+      ? [
+          path.join(process.env.ProgramFiles || '', 'nodejs'),
+          path.join(process.env['ProgramFiles(x86)'] || '', 'nodejs'),
+          path.join(homeDir, 'AppData', 'Roaming', 'npm'),
+          path.join(process.env.ProgramFiles || '', 'Docker', 'Docker', 'resources', 'bin'),
+        ]
+      : []),
+    path.join(homeDir, '.local', 'bin'),
+    path.join(homeDir, '.npm-global', 'bin'),
+    path.join(homeDir, '.cargo', 'bin'),
+    path.join(homeDir, 'bin'),
+    path.join(homeDir, '.nvm', 'current', 'bin'),
+    ...getNvmNodeBinPaths(homeDir),
+    path.join(homeDir, '.pyenv', 'shims'),
+    path.join(homeDir, '.pyenv', 'bin'),
+    path.join(homeDir, '.gvm', 'bin'),
+    path.join(homeDir, '.gvm', 'gos', 'current', 'bin'),
+    path.join(homeDir, 'go', 'bin'),
+    path.join(homeDir, '.go', 'bin'),
+    '/Applications/iTerm.app/Contents/Resources/utilities',
+    ...(process.platform === 'win32'
+      ? [
+          path.join(homeDir, 'AppData', 'Local', 'Programs'),
+          path.join(homeDir, 'AppData', 'Local', 'Microsoft', 'WindowsApps'),
+        ]
+      : []),
+  ].filter((p) => p && fs.existsSync(p));
+
+  return [...pathsToAdd, originalPath || ''].filter((p) => p).join(pathSeparator);
+}

package/ui/server/utils/port.js

@@ -1,4 +1,4 @@
-import { createConnection } from 'net';
+import { createConnection } from 'node:net';
 
 export function checkPortReady(port, host = 'localhost', timeout = 10000) {
   return new Promise((resolve, reject) => {
@@ -12,7 +12,7 @@ export function checkPortReady(port, host = 'localhost', timeout = 10000) {
         resolve(true);
       });
 
-      socket.on('error', (err) => {
+      socket.on('error', (_err) => {
         socket.destroy();
         const elapsed = Date.now() - startTime;
         if (elapsed >= timeout) {

package/ui/server/utils/process.js

@@ -1,9 +1,3 @@
-import { spawn } from 'node:child_process';
-import * as path from 'node:path';
-import { findMcpServerPath } from './paths.js';
-import { enhancePath } from '../../paths.js';
-import { getMcpConfigPath, getWorkingDirectory } from 'mcp-shark-common/configs/index.js';
-
 const MAX_LOG_LINES = 10000;
 
 export function createLogEntry(mcpSharkLogs, broadcastLogUpdate) {
@@ -17,64 +11,3 @@ export function createLogEntry(mcpSharkLogs, broadcastLogUpdate) {
     broadcastLogUpdate({ timestamp, type, line });
   };
 }
-
-export function spawnMcpSharkServer(mcpSharkJsPath, mcpsJsonPath, logEntry) {
-  const mcpServerPath = findMcpServerPath();
-  const nodeExecutable = process.execPath || 'node';
-  const enhancedPath = enhancePath(process.env.PATH);
-
-  logEntry('info', `[UI Server] Spawning MCP-Shark server...`);
-  logEntry('info', `[UI Server] Executable: ${nodeExecutable}`);
-  logEntry('info', `[UI Server] Script: ${mcpSharkJsPath}`);
-  logEntry('info', `[UI Server] Config: ${mcpsJsonPath}`);
-  logEntry('info', `[UI Server] CWD: ${mcpServerPath}`);
-  logEntry('info', `[UI Server] Data dir: ${getWorkingDirectory()}`);
-  logEntry('info', `[UI Server] Enhanced PATH: ${enhancedPath}`);
-
-  const processHandle = spawn(nodeExecutable, [mcpSharkJsPath, mcpsJsonPath], {
-    cwd: mcpServerPath,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: {
-      ...process.env,
-      PATH: enhancedPath,
-    },
-  });
-
-  console.log(`[UI Server] MCP-Shark process spawned with PID: ${processHandle.pid}`);
-
-  processHandle.stdout.on('data', (data) => {
-    logEntry('stdout', data);
-    process.stdout.write(data);
-  });
-
-  processHandle.stderr.on('data', (data) => {
-    logEntry('stderr', data);
-    process.stderr.write(data);
-  });
-
-  return processHandle;
-}
-
-export function setupProcessHandlers(processHandle, logEntry, onError, onExit) {
-  processHandle.on('error', (err) => {
-    console.error('Failed to start mcp-shark server:', err);
-    logEntry('error', `Failed to start mcp-shark server: ${err.message}`);
-    if (onError) onError(err);
-  });
-
-  processHandle.on('exit', (code, signal) => {
-    const message = `MCP Shark server process exited with code ${code}${signal ? ` (signal: ${signal})` : ''}`;
-    console.log(`[UI Server] ${message}`);
-    logEntry('exit', message);
-    if (code !== 0 && code !== null) {
-      console.error(`[UI Server] MCP-Shark process exited with non-zero code: ${code}`);
-      logEntry('error', `Process exited with code ${code}`);
-    }
-    if (onExit) onExit(code, signal);
-  });
-}
-
-export function getMcpSharkJsPath() {
-  const mcpServerPath = findMcpServerPath();
-  return path.join(mcpServerPath, 'mcp-shark.js');
-}