@mcp-shark/mcp-shark 1.4.2 → 1.5.2

package/ui/package.json

@@ -1,12 +0,0 @@
-{
-  "name": "mcp-shark-ui",
-  "version": "1.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview",
-    "prestart": "npm run build",
-    "start": "node server.js"
-  }
-}

package/ui/paths.js

@@ -1,282 +0,0 @@
-import { execSync } from 'child_process';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-
-/**
- * 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') {
-      // Windows: use cmd to get PATH (includes user PATH)
-      const pathOutput = execSync('cmd /c echo %PATH%', {
-        encoding: 'utf8',
-        timeout: 2000,
-        stdio: ['ignore', 'pipe', 'ignore'],
-      });
-      return pathOutput.trim();
-    } else {
-      // Unix-like: use shell to get PATH from user's actual shell environment
-      // Try to detect the user's default shell first
-      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 {
-            // For zsh, we need to load both login and interactive configs
-            // zsh -l loads .zprofile/.zlogin, but .zshrc has interactive configs
-            // Try interactive mode first (loads .zshrc), then login mode
-            const shellName = path.basename(shell);
-            let pathOutput;
-
-            if (shellName === 'zsh') {
-              // For zsh, try interactive mode to get .zshrc PATH additions
-              try {
-                pathOutput = execSync(`${shell} -i -c 'echo $PATH'`, {
-                  encoding: 'utf8',
-                  timeout: 2000,
-                  stdio: ['ignore', 'pipe', 'ignore'],
-                  maxBuffer: 1024 * 1024,
-                  env: {
-                    ...Object.fromEntries(
-                      Object.entries(process.env).filter(([key]) => key !== 'PATH')
-                    ),
-                  },
-                });
-              } catch (_e) {
-                // Fallback to login shell
-                pathOutput = execSync(`${shell} -l -c 'echo $PATH'`, {
-                  encoding: 'utf8',
-                  timeout: 2000,
-                  stdio: ['ignore', 'pipe', 'ignore'],
-                  maxBuffer: 1024 * 1024,
-                  env: {
-                    ...Object.fromEntries(
-                      Object.entries(process.env).filter(([key]) => key !== 'PATH')
-                    ),
-                  },
-                });
-              }
-            } else {
-              // For bash/sh, use login shell
-              pathOutput = execSync(`${shell} -l -c '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) {
-              console.log(`[Server Manager] Got PATH from ${shell} (${shellName})`);
-              return systemPath;
-            }
-          } catch (_e) {
-            // Try next shell
-            continue;
-          }
-        }
-      }
-
-      // Fallback: try to read from common shell config files
-      // For zsh, check .zshrc first (interactive), then .zprofile (login)
-      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 {
-            // For zsh interactive configs, use -i flag
-            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) {
-              // Only use if we got a meaningful PATH
-              console.log(`[Server Manager] Got PATH from ${file}`);
-              return systemPath;
-            }
-          } catch (_e) {
-            // Try next config file
-            continue;
-          }
-        }
-      }
-    }
-  } catch (error) {
-    console.warn('[Server Manager] Could not get system PATH:', error.message);
-  }
-  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' ? ';' : ':';
-
-  // Try to get the actual system PATH from the host (includes user's custom PATH)
-  const systemPath = getSystemPath();
-  if (systemPath) {
-    console.log('[Server Manager] Using system PATH from host machine');
-    // Combine system PATH with original PATH, prioritizing system PATH
-    // Also add user-specific paths that might not be in system PATH
-    const userPaths = [
-      // Common user-specific binary locations
-      path.join(homeDir, '.local', 'bin'),
-      path.join(homeDir, '.npm-global', 'bin'),
-      path.join(homeDir, '.cargo', 'bin'),
-      path.join(homeDir, 'bin'),
-      // Node version managers
-      path.join(homeDir, '.nvm', 'current', 'bin'),
-      // Try to find actual nvm node version (check common versions)
-      ...(function () {
-        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) {
-          // Ignore errors reading nvm directory
-        }
-        return [];
-      })(),
-      path.join(homeDir, '.fnm', 'node-versions', 'v20.0.0', 'install', 'bin'), // fnm
-      // Python version managers
-      path.join(homeDir, '.pyenv', 'shims'),
-      path.join(homeDir, '.pyenv', 'bin'),
-      // Go version managers
-      path.join(homeDir, '.gvm', 'bin'),
-      path.join(homeDir, '.gvm', 'gos', 'current', 'bin'),
-      // Rust/Cargo
-      path.join(homeDir, '.cargo', 'bin'),
-      // Go
-      path.join(homeDir, 'go', 'bin'),
-      path.join(homeDir, '.go', 'bin'),
-      // iTerm utilities
-      '/Applications/iTerm.app/Contents/Resources/utilities',
-      // Windows user paths
-      ...(process.platform === 'win32'
-        ? [
-            path.join(homeDir, 'AppData', 'Local', 'Programs'),
-            path.join(homeDir, 'AppData', 'Roaming', 'npm'),
-            path.join(homeDir, 'AppData', 'Local', 'Microsoft', 'WindowsApps'),
-          ]
-        : []),
-    ].filter((p) => {
-      // Filter out paths that don't exist, but allow dynamic version paths
-      if (p.includes('v20.0.0') || p.includes('current')) {
-        // For version manager paths, check if parent directory exists
-        return fs.existsSync(path.dirname(p));
-      }
-      return fs.existsSync(p);
-    });
-
-    // Combine: system PATH (from shell) + user-specific paths + original PATH
-    return [systemPath, ...userPaths, originalPath || ''].filter((p) => p).join(pathSeparator);
-  }
-
-  // Fallback: add common system and user locations
-  console.log('[Server Manager] Could not get system PATH, adding common locations');
-  const pathsToAdd = [
-    // System binary locations
-    '/usr/local/bin',
-    '/usr/bin',
-    '/opt/homebrew/bin',
-    '/usr/local/opt/node/bin',
-    '/opt/local/bin',
-    '/sbin',
-    '/usr/sbin',
-    // macOS specific
-    ...(process.platform === 'darwin'
-      ? [
-          '/opt/homebrew/opt/python/bin',
-          '/usr/local/opt/python/bin',
-          '/Applications/Docker.app/Contents/Resources/bin',
-        ]
-      : []),
-    // Linux specific
-    ...(process.platform === 'linux' ? ['/snap/bin', path.join(homeDir, '.local', 'bin')] : []),
-    // Windows specific
-    ...(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'),
-        ]
-      : []),
-    // User-specific paths (prioritize these)
-    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'),
-    // Try to find actual nvm node version (check common versions)
-    ...(function () {
-      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) {
-        // Ignore errors reading nvm directory
-      }
-      return [];
-    })(),
-    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'),
-    // iTerm utilities
-    '/Applications/iTerm.app/Contents/Resources/utilities',
-    // Windows user paths
-    ...(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/routes/backups.js

@@ -1,251 +0,0 @@
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import { homedir } from 'node:os';
-
-export function createBackupRoutes() {
-  const router = {};
-
-  router.listBackups = (req, res) => {
-    try {
-      const backups = [];
-      const homeDir = homedir();
-
-      const commonPaths = [
-        path.join(homeDir, '.cursor', 'mcp.json'),
-        path.join(homeDir, '.codeium', 'windsurf', 'mcp_config.json'),
-      ];
-
-      const backupDirs = [
-        path.join(homeDir, '.cursor'),
-        path.join(homeDir, '.codeium', 'windsurf'),
-      ];
-
-      // Find backups with new format: .mcp.json-mcpshark.<datetime>.json
-      backupDirs.forEach((dir) => {
-        if (fs.existsSync(dir)) {
-          const files = fs.readdirSync(dir);
-          files
-            .filter((file) => {
-              // Match pattern: .<basename>-mcpshark.<datetime>.json
-              return /^\.(.+)-mcpshark\.\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.json$/.test(file);
-            })
-            .forEach((file) => {
-              const backupPath = path.join(dir, file);
-              // Extract original filename from backup name
-              // .mcp.json-mcpshark.<datetime>.json -> mcp.json
-              const match = file.match(/^\.(.+)-mcpshark\./);
-              if (match) {
-                const originalBasename = match[1];
-                const originalPath = path.join(dir, originalBasename);
-                const stats = fs.statSync(backupPath);
-                backups.push({
-                  originalPath: originalPath,
-                  backupPath: backupPath,
-                  createdAt: stats.birthtime.toISOString(),
-                  modifiedAt: stats.mtime.toISOString(),
-                  size: stats.size,
-                  displayPath: originalPath.replace(homeDir, '~'),
-                  backupFileName: file,
-                });
-              }
-            });
-        }
-      });
-
-      // Also check for old .backup format for backward compatibility
-      commonPaths.forEach((configPath) => {
-        const backupPath = `${configPath}.backup`;
-        if (fs.existsSync(backupPath)) {
-          const stats = fs.statSync(backupPath);
-          backups.push({
-            originalPath: configPath,
-            backupPath: backupPath,
-            createdAt: stats.birthtime.toISOString(),
-            modifiedAt: stats.mtime.toISOString(),
-            size: stats.size,
-            displayPath: configPath.replace(homeDir, '~'),
-            backupFileName: path.basename(backupPath),
-          });
-        }
-      });
-
-      // Sort by modifiedAt (latest first)
-      res.json({
-        backups: backups.sort(
-          (a, b) => new Date(b.modifiedAt || b.createdAt) - new Date(a.modifiedAt || a.createdAt)
-        ),
-      });
-    } catch (error) {
-      res.status(500).json({ error: 'Failed to list backups', details: error.message });
-    }
-  };
-
-  router.restoreBackup = (req, res, mcpSharkLogs, broadcastLogUpdate) => {
-    try {
-      const { backupPath, originalPath } = req.body;
-
-      if (!backupPath) {
-        return res.status(400).json({ error: 'backupPath is required' });
-      }
-
-      const resolvedBackupPath = backupPath.startsWith('~')
-        ? path.join(homedir(), backupPath.slice(1))
-        : backupPath;
-
-      if (!fs.existsSync(resolvedBackupPath)) {
-        return res.status(404).json({ error: 'Backup file not found', path: resolvedBackupPath });
-      }
-
-      // Determine original path
-      let targetPath;
-      if (originalPath) {
-        targetPath = originalPath.startsWith('~')
-          ? path.join(homedir(), originalPath.slice(1))
-          : originalPath;
-      } else {
-        // Try to extract from backup filename
-        if (resolvedBackupPath.endsWith('.backup')) {
-          targetPath = resolvedBackupPath.replace('.backup', '');
-        } else {
-          // New format: .mcp.json-mcpshark.<datetime>.json
-          const match = path.basename(resolvedBackupPath).match(/^\.(.+)-mcpshark\./);
-          if (match) {
-            const originalBasename = match[1];
-            targetPath = path.join(path.dirname(resolvedBackupPath), originalBasename);
-          } else {
-            return res.status(400).json({ error: 'Could not determine original file path' });
-          }
-        }
-      }
-
-      const backupContent = fs.readFileSync(resolvedBackupPath, 'utf8');
-      fs.writeFileSync(targetPath, backupContent);
-
-      const timestamp = new Date().toISOString();
-      const restoreLog = {
-        timestamp,
-        type: 'stdout',
-        line: `[RESTORE] Restored config from backup: ${targetPath.replace(homedir(), '~')}`,
-      };
-      mcpSharkLogs.push(restoreLog);
-      if (mcpSharkLogs.length > 10000) {
-        mcpSharkLogs.shift();
-      }
-      broadcastLogUpdate(restoreLog);
-
-      res.json({
-        success: true,
-        message: 'Config file restored from backup',
-        originalPath: targetPath.replace(homedir(), '~'),
-      });
-    } catch (error) {
-      const timestamp = new Date().toISOString();
-      const errorLog = {
-        timestamp,
-        type: 'error',
-        line: `[RESTORE ERROR] Failed to restore: ${error.message}`,
-      };
-      mcpSharkLogs.push(errorLog);
-      if (mcpSharkLogs.length > 10000) {
-        mcpSharkLogs.shift();
-      }
-      broadcastLogUpdate(errorLog);
-      res.status(500).json({ error: 'Failed to restore backup', details: error.message });
-    }
-  };
-
-  router.viewBackup = (req, res) => {
-    try {
-      const { backupPath } = req.query;
-
-      if (!backupPath) {
-        return res.status(400).json({ error: 'backupPath is required' });
-      }
-
-      const resolvedBackupPath = backupPath.startsWith('~')
-        ? path.join(homedir(), backupPath.slice(1))
-        : backupPath;
-
-      if (!fs.existsSync(resolvedBackupPath)) {
-        return res.status(404).json({ error: 'Backup file not found', path: resolvedBackupPath });
-      }
-
-      const content = fs.readFileSync(resolvedBackupPath, 'utf-8');
-      const parsed = (() => {
-        try {
-          return JSON.parse(content);
-        } catch (e) {
-          return null;
-        }
-      })();
-
-      const stats = fs.statSync(resolvedBackupPath);
-
-      res.json({
-        success: true,
-        backupPath: resolvedBackupPath,
-        displayPath: resolvedBackupPath.replace(homedir(), '~'),
-        content: content,
-        parsed: parsed,
-        createdAt: stats.birthtime.toISOString(),
-        modifiedAt: stats.mtime.toISOString(),
-        size: stats.size,
-      });
-    } catch (error) {
-      res.status(500).json({ error: 'Failed to read backup file', details: error.message });
-    }
-  };
-
-  router.deleteBackup = (req, res, mcpSharkLogs, broadcastLogUpdate) => {
-    try {
-      const { backupPath } = req.body;
-
-      if (!backupPath) {
-        return res.status(400).json({ error: 'backupPath is required' });
-      }
-
-      const resolvedBackupPath = backupPath.startsWith('~')
-        ? path.join(homedir(), backupPath.slice(1))
-        : backupPath;
-
-      if (!fs.existsSync(resolvedBackupPath)) {
-        return res.status(404).json({ error: 'Backup file not found', path: resolvedBackupPath });
-      }
-
-      fs.unlinkSync(resolvedBackupPath);
-
-      const timestamp = new Date().toISOString();
-      const deleteLog = {
-        timestamp,
-        type: 'stdout',
-        line: `[DELETE] Deleted backup: ${resolvedBackupPath.replace(homedir(), '~')}`,
-      };
-      mcpSharkLogs.push(deleteLog);
-      if (mcpSharkLogs.length > 10000) {
-        mcpSharkLogs.shift();
-      }
-      broadcastLogUpdate(deleteLog);
-
-      res.json({
-        success: true,
-        message: 'Backup file deleted successfully',
-        backupPath: resolvedBackupPath.replace(homedir(), '~'),
-      });
-    } catch (error) {
-      const timestamp = new Date().toISOString();
-      const errorLog = {
-        timestamp,
-        type: 'error',
-        line: `[DELETE ERROR] Failed to delete backup: ${error.message}`,
-      };
-      mcpSharkLogs.push(errorLog);
-      if (mcpSharkLogs.length > 10000) {
-        mcpSharkLogs.shift();
-      }
-      broadcastLogUpdate(errorLog);
-      res.status(500).json({ error: 'Failed to delete backup', details: error.message });
-    }
-  };
-
-  return router;
-}