@mcp-shark/mcp-shark 1.4.2 → 1.5.0

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');
-}

package/ui/server/utils/scan-cache/all-results.js

@@ -1,5 +1,6 @@
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import logger from '../logger.js';
 import { getScanResultsDirectory } from './directory.js';
 
 /**
@@ -9,13 +10,13 @@ import { getScanResultsDirectory } from './directory.js';
  * @returns {string} Server name
  */
 function extractServerName(data, scanData) {
-  let serverName = data.serverName; // From cache file metadata (most reliable)
+  const cachedServerName = data.serverName; // From cache file metadata (most reliable)
 
   // If not found at top level, try to extract from scan data (API response)
-  if (!serverName || serverName === 'Unknown Server') {
+  if (!cachedServerName || cachedServerName === 'Unknown Server') {
     const actualScanData = scanData.data || scanData;
 
-    serverName =
+    const serverName =
       actualScanData.serverName ||
       actualScanData.server_name ||
       actualScanData.server?.name ||
@@ -25,9 +26,11 @@ function extractServerName(data, scanData) {
       scanData.server?.name ||
       scanData.mcp_server_data?.server?.name ||
       'Unknown Server';
+
+    return serverName;
   }
 
-  return serverName;
+  return cachedServerName;
 }
 
 /**
@@ -39,25 +42,29 @@ function extractServerName(data, scanData) {
 function processScanFile(file, scanResultsDir) {
   try {
     const filePath = join(scanResultsDir, file);
-    console.log(`[getAllCachedScanResults] Reading file: ${file}`);
+    logger.debug({ file }, 'Reading cached scan result file');
 
     const fileContent = readFileSync(filePath, 'utf8');
     const data = JSON.parse(fileContent);
 
     // Validate that this is a scan result file
     if (!data || typeof data !== 'object') {
-      console.warn(`[getAllCachedScanResults] Invalid data in file ${file}: not an object`);
+      logger.warn({ file }, 'Invalid data in file: not an object');
       return null;
     }
 
     // Debug: Log the structure to understand what we're working with
-    console.log(`[getAllCachedScanResults] File ${file} structure:`, {
-      hasServerName: !!data.serverName,
-      serverName: data.serverName,
-      hasScanData: !!data.scanData,
-      scanDataKeys: data.scanData ? Object.keys(data.scanData) : [],
-      topLevelKeys: Object.keys(data),
-    });
+    logger.debug(
+      {
+        file,
+        hasServerName: !!data.serverName,
+        serverName: data.serverName,
+        hasScanData: !!data.scanData,
+        scanDataKeys: data.scanData ? Object.keys(data.scanData) : [],
+        topLevelKeys: Object.keys(data),
+      },
+      'File structure'
+    );
 
     // Create a scan-like object with id, server name, and scan data
     const scanData = data.scanData || data;
@@ -66,17 +73,16 @@ function processScanFile(file, scanResultsDir) {
 
     // Log if we couldn't find server name
     if (serverName === 'Unknown Server') {
-      console.warn(`[getAllCachedScanResults] Could not find server name in ${file}`);
-      console.warn(`[getAllCachedScanResults] data.serverName: ${data.serverName}`);
-      console.warn(`[getAllCachedScanResults] data keys: ${Object.keys(data || {}).join(', ')}`);
-      console.warn(
-        `[getAllCachedScanResults] scanData keys: ${Object.keys(scanData || {}).join(', ')}`
+      logger.warn(
+        {
+          file,
+          dataServerName: data.serverName,
+          dataKeys: Object.keys(data || {}).join(', '),
+          scanDataKeys: Object.keys(scanData || {}).join(', '),
+          scanDataDataKeys: scanData?.data ? Object.keys(scanData.data || {}).join(', ') : null,
+        },
+        'Could not find server name in file'
       );
-      if (scanData?.data) {
-        console.warn(
-          `[getAllCachedScanResults] scanData.data keys: ${Object.keys(scanData.data || {}).join(', ')}`
-        );
-      }
     }
 
     const scanResult = {
@@ -98,17 +104,18 @@ function processScanFile(file, scanResultsDir) {
       result: scanData,
     };
 
-    console.log(`[getAllCachedScanResults] Successfully loaded scan: ${serverName} (${scanId})`);
+    logger.debug({ serverName, scanId }, 'Successfully loaded scan');
     return scanResult;
   } catch (error) {
-    console.warn(
-      `[getAllCachedScanResults] Error reading scan result file ${file}:`,
-      error.message
+    logger.warn(
+      {
+        file,
+        filePath: join(scanResultsDir, file),
+        error: error.message,
+        stack: error.stack,
+      },
+      'Error reading scan result file'
     );
-    console.warn(`[getAllCachedScanResults] File path: ${join(scanResultsDir, file)}`);
-    if (error.stack) {
-      console.warn(`[getAllCachedScanResults] Stack: ${error.stack}`);
-    }
     return null;
   }
 }
@@ -120,46 +127,46 @@ function processScanFile(file, scanResultsDir) {
 export function getAllCachedScanResults() {
   try {
     const scanResultsDir = getScanResultsDirectory();
-    console.log('[getAllCachedScanResults] Reading cached scans from directory:', scanResultsDir);
+    logger.debug({ scanResultsDir }, 'Reading cached scans from directory');
 
     // Check if directory exists (don't create it, just check)
     if (!existsSync(scanResultsDir)) {
-      console.log(
-        '[getAllCachedScanResults] Scan results directory does not exist:',
-        scanResultsDir
-      );
+      logger.debug({ scanResultsDir }, 'Scan results directory does not exist');
       return [];
     }
 
     // Read all files in the directory
     const allFiles = readdirSync(scanResultsDir);
-    console.log(`[getAllCachedScanResults] Total files in directory: ${allFiles.length}`);
+    logger.debug({ count: allFiles.length }, 'Total files in directory');
 
     // Filter for JSON files only
     const jsonFiles = allFiles.filter((f) => f.endsWith('.json'));
-    console.log(
-      `[getAllCachedScanResults] Found ${jsonFiles.length} JSON files in ${scanResultsDir}`
-    );
+    logger.debug({ count: jsonFiles.length, scanResultsDir }, 'Found JSON files');
 
     if (jsonFiles.length === 0) {
-      console.log('[getAllCachedScanResults] No cached scan JSON files found');
+      logger.debug('No cached scan JSON files found');
       return [];
     }
 
-    const results = [];
-    let successCount = 0;
-    let errorCount = 0;
-
     // Read each file
-    for (const file of jsonFiles) {
-      const result = processScanFile(file, scanResultsDir);
-      if (result) {
-        results.push(result);
-        successCount++;
-      } else {
-        errorCount++;
-      }
-    }
+    const { results, successCount, errorCount } = jsonFiles.reduce(
+      (acc, file) => {
+        const result = processScanFile(file, scanResultsDir);
+        if (result) {
+          return {
+            results: [...acc.results, result],
+            successCount: acc.successCount + 1,
+            errorCount: acc.errorCount,
+          };
+        }
+        return {
+          results: acc.results,
+          successCount: acc.successCount,
+          errorCount: acc.errorCount + 1,
+        };
+      },
+      { results: [], successCount: 0, errorCount: 0 }
+    );
 
     // Sort by updatedAt descending (most recent first)
     results.sort((a, b) => {
@@ -168,13 +175,23 @@ export function getAllCachedScanResults() {
       return bTime - aTime;
     });
 
-    console.log(
-      `[getAllCachedScanResults] Summary: ${successCount} successful, ${errorCount} errors, ${results.length} total scans loaded`
+    logger.info(
+      {
+        successCount,
+        errorCount,
+        total: results.length,
+      },
+      'Summary: cached scans loaded'
     );
     return results;
   } catch (error) {
-    console.error('[getAllCachedScanResults] Fatal error getting all cached scan results:', error);
-    console.error('[getAllCachedScanResults] Error stack:', error.stack);
+    logger.error(
+      {
+        error: error.message,
+        stack: error.stack,
+      },
+      'Fatal error getting all cached scan results'
+    );
     return [];
   }
 }

package/ui/server/utils/scan-cache/directory.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { getWorkingDirectory } from 'mcp-shark-common/configs/index.js';
 

package/ui/server/utils/scan-cache/file-operations.js

@@ -1,5 +1,6 @@
-import { readFileSync, writeFileSync, existsSync, unlinkSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import logger from '../logger.js';
 import { getScanResultFilePath, getScanResultsDirectory } from './directory.js';
 
 /**
@@ -26,7 +27,7 @@ export function getCachedScanResult(hash) {
       serverName: data.serverName,
     };
   } catch (error) {
-    console.error('Error getting cached scan result:', error);
+    logger.error({ hash, error: error.message }, 'Error getting cached scan result');
     return null;
   }
 }
@@ -44,17 +45,19 @@ export function storeScanResult(serverName, hash, scanData) {
     const now = Date.now();
 
     // Check if file exists to preserve original creation time
-    let createdAt = now;
-    if (existsSync(filePath)) {
+    const getCreatedAt = (filePath, defaultTime) => {
+      if (!existsSync(filePath)) {
+        return defaultTime;
+      }
       try {
         const existingContent = readFileSync(filePath, 'utf8');
         const existingData = JSON.parse(existingContent);
-        createdAt = existingData.createdAt || now;
-      } catch (e) {
-        // If we can't read existing file, use current time
-        createdAt = now;
+        return existingData.createdAt || defaultTime;
+      } catch (_e) {
+        return defaultTime;
       }
-    }
+    };
+    const createdAt = getCreatedAt(filePath, now);
 
     const dataToStore = {
       serverName,
@@ -67,7 +70,7 @@ export function storeScanResult(serverName, hash, scanData) {
     writeFileSync(filePath, JSON.stringify(dataToStore, null, 2), 'utf8');
     return true;
   } catch (error) {
-    console.error('Error storing scan result:', error);
+    logger.error({ serverName, hash, error: error.message }, 'Error storing scan result');
     return false;
   }
 }
@@ -84,21 +87,21 @@ export function clearAllScanResults() {
     }
 
     const files = readdirSync(scanResultsDir).filter((f) => f.endsWith('.json'));
-    let deletedCount = 0;
 
-    for (const file of files) {
+    const deletedCount = files.reduce((count, file) => {
       try {
         const filePath = join(scanResultsDir, file);
         unlinkSync(filePath);
-        deletedCount++;
+        return count + 1;
       } catch (error) {
-        console.warn(`Error deleting scan result file ${file}:`, error);
+        logger.warn({ file, error: error.message }, 'Error deleting scan result file');
+        return count;
       }
-    }
+    }, 0);
 
     return deletedCount;
   } catch (error) {
-    console.error('Error clearing all scan results:', error);
+    logger.error({ error: error.message }, 'Error clearing all scan results');
     return 0;
   }
 }