@mcp-shark/mcp-shark 1.4.0 → 1.4.2

package/README.md

@@ -66,11 +66,20 @@ Or if installed locally:
 npx @mcp-shark/mcp-shark
 ```
 
+**Open browser automatically:**
+
+```bash
+mcp-shark --open
+# or
+mcp-shark -o
+```
+
 The UI will automatically:
 
 - Install dependencies if needed
 - Build the frontend if needed
 - Start the server on `http://localhost:9853`
+- Optionally open your browser automatically (with `--open` flag)
 
 Open your browser to `http://localhost:9853` to access the MCP Shark interface.
 
@@ -331,8 +340,14 @@ No manual configuration editing required - MCP Shark handles everything for you.
    mcp-shark
 ```
 
+Or to automatically open your browser:
+
+```bash
+   mcp-shark --open
+```
+
 3. **Open your browser:**
-   Navigate to `http://localhost:9853`
+   Navigate to `http://localhost:9853` (or it will open automatically with `--open` flag)
 
 4. **Interactive Tour**: On first launch, you'll see an interactive tour - follow it to get started
 

package/bin/mcp-shark.js

@@ -3,67 +3,110 @@
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { dirname, join, resolve } from 'node:path';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { Command } from 'commander';
+import open from 'open';
+
+const SERVER_URL = 'http://localhost:9853';
+const BROWSER_OPEN_DELAY = 1000;
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const rootDir = resolve(__dirname, '..');
-const uiDir = join(rootDir, 'ui');
 
-// Check if UI directory exists
-if (!existsSync(uiDir)) {
-  console.error('Error: UI directory not found. Please ensure you are in the correct directory.');
-  process.exit(1);
-}
+/**
+ * Display welcome banner
+ */
+function displayWelcomeBanner() {
+  const pkgPath = join(rootDir, 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const version = pkg.version;
 
-// Check if node_modules exists in root directory
-const rootNodeModules = join(rootDir, 'node_modules');
-if (!existsSync(rootNodeModules)) {
-  console.log('Installing dependencies...');
-  const installProcess = spawn('npm', ['install'], {
-    cwd: rootDir,
-    stdio: 'inherit',
-    shell: true,
-  });
+  const banner = `
+   ███╗   ███╗ ██████╗ ██████╗      ███████╗██╗  ██╗ █████╗ ██████╗ ██╗  ██╗
+   ████╗ ████║██╔════╝██╔══██╗     ██╔════╝██║  ██║██╔══██╗██╔══██╗██║ ██╔╝
+   ██╔████╔██║██║     ██████╔╝     ███████╗███████║███████║██████╔╝█████╔╝ 
+   ██║╚██╔╝██║██║     ██╔═══╝      ╚════██║██╔══██║██╔══██║██╔══██╗██╔═██╗ 
+   ██║ ╚═╝ ██║╚██████╗██║          ███████║██║  ██║██║  ██║██║  ██║██║  ██╗
+   ╚═╝     ╚═╝ ╚═════╝╚═╝          ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝
+   
+   Aggregate multiple MCP servers into a unified interface
+   Version: ${version} | Homepage: https://mcpshark.sh
+`;
 
-  installProcess.on('close', (code) => {
-    if (code !== 0) {
-      console.error('Failed to install dependencies');
-      process.exit(1);
-    }
-    console.log('Dependencies installed successfully!\n');
-    startUIServer();
-  });
-} else {
-  startUIServer();
+  console.log(banner);
 }
 
-function startUIServer() {
-  // Check if dist directory exists (production build)
-  const distDir = join(uiDir, 'dist');
-  if (!existsSync(distDir)) {
-    console.log('Building UI for production...');
-    const buildProcess = spawn('npm', ['run', 'build'], {
-      cwd: uiDir,
+const uiDir = join(rootDir, 'ui');
+const distDir = join(uiDir, 'dist');
+const rootNodeModules = join(rootDir, 'node_modules');
+
+/**
+ * Run a command and return a promise that resolves when it completes
+ */
+function runCommand(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const process = spawn(command, args, {
+      ...options,
       stdio: 'inherit',
       shell: true,
     });
 
-    buildProcess.on('close', (code) => {
+    process.on('close', (code) => {
       if (code !== 0) {
-        console.error('Failed to build UI');
-        process.exit(1);
+        reject(new Error(`Command failed with exit code ${code}`));
+      } else {
+        resolve();
       }
-      runServer();
     });
-  } else {
-    runServer();
+
+    process.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Install dependencies in the root directory
+ */
+async function installDependencies() {
+  console.log('Installing dependencies...');
+  try {
+    await runCommand('npm', ['install'], { cwd: rootDir });
+    console.log('Dependencies installed successfully!\n');
+  } catch (error) {
+    console.error('Failed to install dependencies:', error.message);
+    process.exit(1);
   }
 }
 
-function runServer() {
+/**
+ * Build the UI for production
+ */
+async function buildUI() {
+  console.log('Building UI for production...');
+  try {
+    await runCommand('npm', ['run', 'build'], { cwd: uiDir });
+  } catch (error) {
+    console.error('Failed to build UI:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Open the browser after a short delay
+ */
+async function openBrowser() {
+  await new Promise((resolve) => setTimeout(resolve, BROWSER_OPEN_DELAY));
+  open(SERVER_URL);
+}
+
+/**
+ * Start the UI server
+ */
+async function startServer(shouldOpenBrowser = false) {
   console.log('Starting MCP Shark UI server...');
-  console.log('Open http://localhost:9853 in your browser');
+  console.log(`Open ${SERVER_URL} in your browser`);
   console.log('Press Ctrl+C to stop\n');
 
   const serverProcess = spawn('node', ['server.js'], {
@@ -72,22 +115,105 @@ function runServer() {
     shell: true,
   });
 
+  if (shouldOpenBrowser) {
+    await openBrowser();
+  }
+
+  let isShuttingDown = false;
+
   serverProcess.on('close', (code) => {
-    if (code !== 0 && code !== null) {
-      console.error(`Server exited with code ${code}`);
-      process.exit(code);
+    if (!isShuttingDown) {
+      if (code !== 0 && code !== null) {
+        console.error(`Server exited with code ${code}`);
+        process.exit(code);
+      }
+    } else {
+      process.exit(0);
     }
   });
 
   // Handle process termination
-  process.on('SIGINT', () => {
-    console.log('\nShutting down...');
-    serverProcess.kill('SIGINT');
-    process.exit(0);
-  });
+  const shutdown = async (signal) => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
 
-  process.on('SIGTERM', () => {
-    serverProcess.kill('SIGTERM');
-    process.exit(0);
-  });
+    console.log('Shutting down...');
+
+    // Send signal to child process
+    serverProcess.kill(signal);
+
+    // Wait for child process to exit, with timeout
+    const timeout = setTimeout(() => {
+      console.log('Forcefully terminating server process...');
+      serverProcess.kill('SIGKILL');
+      process.exit(1);
+    }, 5000);
+
+    serverProcess.once('close', () => {
+      clearTimeout(timeout);
+      process.exit(0);
+    });
+  };
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+
+/**
+ * Validate that required directories exist
+ */
+function validateDirectories() {
+  if (!existsSync(uiDir)) {
+    console.error('Error: UI directory not found. Please ensure you are in the correct directory.');
+    process.exit(1);
+  }
+}
+
+/**
+ * Ensure dependencies are installed
+ */
+async function ensureDependencies() {
+  if (!existsSync(rootNodeModules)) {
+    await installDependencies();
+  }
+}
+
+/**
+ * Ensure UI is built
+ */
+async function ensureUIBuilt() {
+  if (!existsSync(distDir)) {
+    await buildUI();
+  }
 }
+
+/**
+ * Main execution function
+ */
+async function main() {
+  // Display welcome banner
+  displayWelcomeBanner();
+
+  // Parse command line options
+  const program = new Command();
+  program.option('-o, --open', 'Open the browser', false).parse(process.argv);
+
+  const options = program.opts();
+
+  // Validate environment
+  validateDirectories();
+
+  // Ensure dependencies are installed
+  await ensureDependencies();
+
+  // Ensure UI is built
+  await ensureUIBuilt();
+
+  // Start the server
+  await startServer(options.open);
+}
+
+main().catch((error) => {
+  console.error('Unexpected error:', error);
+  process.exit(1);
+});

package/mcp-server/lib/auditor/audit.js

@@ -135,14 +135,22 @@ export async function withAuditRequestResponseHandler(
   transport,
   req,
   res,
-  auditLogger
+  auditLogger,
+  requestedMcpServer,
+  initialSessionId
 ) {
   const reqBuf = await readBody(req);
   const reqJsonRpc = tryParseJsonRpc(reqBuf);
 
   // Extract session ID from request
   // If no session ID exists, it's an initiation request
-  const sessionId = getSessionFromRequest(req);
+  const sessionIdFromRequest = getSessionFromRequest(req);
+  const sessionId =
+    sessionIdFromRequest === null ||
+    sessionIdFromRequest === undefined ||
+    sessionIdFromRequest === ''
+      ? initialSessionId
+      : sessionIdFromRequest;
 
   // Extract request body as string
   const reqBodyStr = reqBuf.toString('utf8');
@@ -161,7 +169,7 @@ export async function withAuditRequestResponseHandler(
     headers: req.headers,
     body: reqBodyJson || reqBodyStr,
     userAgent: req.headers['user-agent'] || req.headers['User-Agent'] || null,
-    remoteAddress: req.socket?.remoteAddress || null,
+    remoteAddress: requestedMcpServer,
     sessionId: sessionId || null,
   });
 
@@ -223,6 +231,6 @@ export async function withAuditRequestResponseHandler(
     jsonrpcId,
     sessionId: sessionId || null,
     userAgent: req.headers['user-agent'] || req.headers['User-Agent'] || null,
-    remoteAddress: req.socket?.remoteAddress || null,
+    remoteAddress: requestedMcpServer || null,
   });
 }

package/mcp-server/lib/server/external/kv.js

@@ -1,14 +1,5 @@
 const kv = new Map();
 
-function buildName(name, typeName) {
-  return `${name}.${typeName}`;
-}
-
-export function extractName(name) {
-  const [serverName, typeName] = name.split('.');
-  return { serverName, typeName };
-}
-
 export function buildKv(downstreamServers) {
   for (const downstreamServer of downstreamServers) {
     const {
@@ -43,16 +34,16 @@ export function buildKv(downstreamServers) {
         resourcesMap,
         promptsMap,
         tools: tools.map(tool => {
-          return { ...tool, name: buildName(name, tool.name) };
+          return { ...tool, name: tool.name };
         }),
         resources: resources.map(resource => {
           return {
             ...resource,
-            name: buildName(name, resource.name),
+            name: resource.name,
           };
         }),
         prompts: prompts.map(prompt => {
-          return { ...prompt, name: buildName(name, prompt.name) };
+          return { ...prompt, name: prompt.name };
         }),
       });
     }
@@ -61,42 +52,40 @@ export function buildKv(downstreamServers) {
   return kv;
 }
 
-export function getBy(database, calledName, action) {
-  const { serverName, typeName } = extractName(calledName);
-  if (!serverName || !typeName) {
-    return null;
-  }
-  const entry = database.get(serverName);
+export function getBy(database, requestedMcpServer, calledName, action) {
+  const entry = database.get(requestedMcpServer);
   if (!entry) {
     return null;
   }
 
   // Type-based lookup
   if (action === 'getTools') {
-    return entry.toolsMap.get(typeName);
+    return entry.toolsMap.get(calledName);
   }
   if (action === 'getResources') {
-    return entry.resourcesMap.get(typeName);
+    return entry.resourcesMap.get(calledName);
   }
   if (action === 'getPrompts') {
-    return entry.promptsMap.get(typeName);
+    return entry.promptsMap.get(calledName);
   }
 
   // Action-based lookup
   if (action === 'callTool') {
-    return entry.toolsMap.get(typeName);
+    return entry.toolsMap.get(calledName);
   }
   if (action === 'readResource') {
-    return entry.resourcesMap.get(typeName);
+    return entry.resourcesMap.get(calledName);
   }
   if (action === 'getPrompt') {
-    return entry.promptsMap.get(typeName);
+    return entry.promptsMap.get(calledName);
   }
   return null;
 }
 
-export function listAll(database, type) {
-  return Array.from(database.values())
-    .map(entry => entry[type])
-    .flat();
+export function listAll(database, requestedMcpServer, type) {
+  const serverEntry = database.get(requestedMcpServer);
+  if (!serverEntry) {
+    return [];
+  }
+  return serverEntry[type];
 }

package/mcp-server/lib/server/internal/handlers/prompts-get.js

@@ -1,20 +1,28 @@
-import { getBy, extractName } from '../../external/kv.js';
+import { getBy } from '../../external/kv.js';
 import { InternalServerError } from './error.js';
 
-export function createPromptsGetHandler(logger, mcpServers) {
+export function createPromptsGetHandler(
+  logger,
+  mcpServers,
+  requestedMcpServer
+) {
   return async req => {
     const name = req.params.name;
     const promptArgs = req?.params?.arguments || {};
     logger.debug('Prompt get', name, promptArgs);
 
-    const { typeName } = extractName(name);
-
-    const getPrompt = getBy(mcpServers, name, 'getPrompt', promptArgs);
+    const getPrompt = getBy(
+      mcpServers,
+      requestedMcpServer,
+      name,
+      'getPrompt',
+      promptArgs
+    );
     if (!getPrompt) {
       throw new InternalServerError(`Prompt not found: ${name}`);
     }
 
-    const result = await getPrompt(typeName, promptArgs);
+    const result = await getPrompt(name, promptArgs);
     logger.debug('Prompt get result', result);
 
     return result;

package/mcp-server/lib/server/internal/handlers/prompts-list.js

@@ -1,10 +1,15 @@
 import { listAll } from '../../external/kv.js';
 
-export function createPromptsListHandler(logger, mcpServers) {
-  return async _req => {
-    logger.debug('Prompts list');
+export function createPromptsListHandler(
+  logger,
+  mcpServers,
+  requestedMcpServer
+) {
+  return async req => {
+    const path = req.path;
+    logger.debug('Prompts list', path);
 
-    const res = await listAll(mcpServers, 'prompts');
+    const res = await listAll(mcpServers, requestedMcpServer, 'prompts');
     const result = Array.isArray(res) ? { prompts: res } : res;
 
     return result;

package/mcp-server/lib/server/internal/handlers/resources-list.js

@@ -1,10 +1,15 @@
 import { listAll } from '../../external/kv.js';
 
-export function createResourcesListHandler(logger, mcpServers) {
-  return async _req => {
-    logger.debug('Resources list');
+export function createResourcesListHandler(
+  logger,
+  mcpServers,
+  requestedMcpServer
+) {
+  return async req => {
+    const path = req.path;
+    logger.debug('Resources list', path);
 
-    const res = await listAll(mcpServers, 'resources');
+    const res = await listAll(mcpServers, requestedMcpServer, 'resources');
     const result = Array.isArray(res) ? { resources: res } : res;
 
     return result;

package/mcp-server/lib/server/internal/handlers/resources-read.js

@@ -1,12 +1,22 @@
 import { getBy } from '../../external/kv.js';
 import { InternalServerError } from './error.js';
 
-export function createResourcesReadHandler(logger, mcpServers) {
+export function createResourcesReadHandler(
+  logger,
+  mcpServers,
+  requestedMcpServer
+) {
   return async req => {
+    const path = req.path;
     const uri = req.params.uri;
-    logger.debug('Resource read', uri);
+    logger.debug('Resource read', path, uri);
 
-    const readResource = getBy(mcpServers, uri, 'readResource');
+    const readResource = getBy(
+      mcpServers,
+      requestedMcpServer,
+      uri,
+      'readResource'
+    );
     if (!readResource) {
       throw new InternalServerError(`Resource not found: ${uri}`);
     }

package/mcp-server/lib/server/internal/handlers/tools-call.js

@@ -1,24 +1,28 @@
-import { getBy, extractName } from '../../external/kv.js';
+import { getBy } from '../../external/kv.js';
 import { InternalServerError } from './error.js';
 
 const isAsyncIterable = v => v && typeof v[Symbol.asyncIterator] === 'function';
 
-export function createToolsCallHandler(logger, mcpServers) {
+export function createToolsCallHandler(logger, mcpServers, requestedMcpServer) {
   return async req => {
+    const path = req.path;
     const { name, arguments: args } = req.params;
-    logger.debug('Tool call', name, args);
+    logger.debug('Tool call', path, name, args);
 
-    // Extract real server name from concatenated name
-    const { typeName } = extractName(name);
-
-    const callTool = getBy(mcpServers, name, 'callTool', args || {});
+    const callTool = getBy(
+      mcpServers,
+      requestedMcpServer,
+      name,
+      'callTool',
+      args || {}
+    );
     if (!callTool) {
       throw new InternalServerError(`Tool not found: ${name}`);
     }
 
     const result = await callTool({
       ...req.params,
-      name: typeName,
+      name,
     });
     logger.debug('Tool call result', result);
 

package/mcp-server/lib/server/internal/handlers/tools-list.js

@@ -1,10 +1,11 @@
 import { listAll } from '../../external/kv.js';
 
-export function createToolsListHandler(logger, mcpServers) {
+export function createToolsListHandler(logger, mcpServers, requestedMcpServer) {
   return async req => {
-    logger.debug('Listing tools', req);
+    const path = req.path;
+    logger.debug('Listing tools', path);
 
-    const res = await listAll(mcpServers, 'tools');
+    const res = await listAll(mcpServers, requestedMcpServer, 'tools');
     logger.debug('Tools list result', res);
 
     const result = Array.isArray(res) ? { tools: res } : res;

package/mcp-server/lib/server/internal/run.js

@@ -22,7 +22,7 @@ export function getInternalServer(
     })
   );
 
-  app.all('/mcp', async (req, res) => {
+  app.all('/mcp/*', async (req, res) => {
     await withSession(
       serverFactory,
       withAuditRequestResponseHandler,

package/mcp-server/lib/server/internal/server.js

@@ -15,49 +15,49 @@ import { createPromptsListHandler } from './handlers/prompts-list.js';
 import { createPromptsGetHandler } from './handlers/prompts-get.js';
 import { createResourcesListHandler } from './handlers/resources-list.js';
 import { createResourcesReadHandler } from './handlers/resources-read.js';
-import { SERVER_NAME } from './handlers/common.js';
 
-export function createInternalServer(logger, mcpServers) {
+export function createInternalServer(logger, mcpServers, requestedMcpServer) {
   // create MCP server
   const server = new Server(
-    { name: SERVER_NAME, version: '1.0.0' },
+    { name: requestedMcpServer, version: '1.0.0' },
     { capabilities: { tools: {}, prompts: {}, resources: {} } }
   );
 
   // Register handlers
   server.setRequestHandler(
     ListToolsRequestSchema,
-    createToolsListHandler(logger, mcpServers)
+    createToolsListHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     CallToolRequestSchema,
-    createToolsCallHandler(logger, mcpServers)
+    createToolsCallHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     ListPromptsRequestSchema,
-    createPromptsListHandler(logger, mcpServers)
+    createPromptsListHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     GetPromptRequestSchema,
-    createPromptsGetHandler(logger, mcpServers)
+    createPromptsGetHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     ListResourcesRequestSchema,
-    createResourcesListHandler(logger, mcpServers)
+    createResourcesListHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     ReadResourceRequestSchema,
-    createResourcesReadHandler(logger, mcpServers)
+    createResourcesReadHandler(logger, mcpServers, requestedMcpServer)
   );
 
   return server;
 }
 
 export function createInternalServerFactory(logger, mcpServers) {
-  return () => createInternalServer(logger, mcpServers);
+  return requestedMcpServer =>
+    createInternalServer(logger, mcpServers, requestedMcpServer);
 }