@mcp-shark/mcp-shark 1.4.1 → 1.5.0

package/bin/mcp-shark.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 
 import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname, join, resolve } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
 import open from 'open';
+import logger from '../shared/logger.js';
 
 const SERVER_URL = 'http://localhost:9853';
 const BROWSER_OPEN_DELAY = 1000;
@@ -34,7 +35,7 @@ function displayWelcomeBanner() {
    Version: ${version} | Homepage: https://mcpshark.sh
 `;
 
-  console.log(banner);
+  logger.log(banner);
 }
 
 const uiDir = join(rootDir, 'ui');
@@ -70,25 +71,25 @@ function runCommand(command, args, options) {
  * Install dependencies in the root directory
  */
 async function installDependencies() {
-  console.log('Installing dependencies...');
+  logger.info('Installing dependencies...');
   try {
     await runCommand('npm', ['install'], { cwd: rootDir });
-    console.log('Dependencies installed successfully!\n');
+    logger.info('Dependencies installed successfully!\n');
   } catch (error) {
-    console.error('Failed to install dependencies:', error.message);
+    logger.error({ error: error.message }, 'Failed to install dependencies');
     process.exit(1);
   }
 }
 
 /**
- * Build the UI for production
+ * Validate that UI dist directory exists
  */
-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);
+function validateUIBuilt() {
+  if (!existsSync(distDir)) {
+    logger.error(
+      'Error: UI build not found. The package should include pre-built UI files.\n' +
+        'If you are developing, run: npm run build:ui'
+    );
     process.exit(1);
   }
 }
@@ -105,9 +106,9 @@ async function openBrowser() {
  * Start the UI server
  */
 async function startServer(shouldOpenBrowser = false) {
-  console.log('Starting MCP Shark UI server...');
-  console.log(`Open ${SERVER_URL} in your browser`);
-  console.log('Press Ctrl+C to stop\n');
+  logger.info('Starting MCP Shark UI server...');
+  logger.info(`Open ${SERVER_URL} in your browser`);
+  logger.info('Press Ctrl+C to stop\n');
 
   const serverProcess = spawn('node', ['server.js'], {
     cwd: uiDir,
@@ -119,12 +120,12 @@ async function startServer(shouldOpenBrowser = false) {
     await openBrowser();
   }
 
-  let isShuttingDown = false;
+  const shutdownState = { isShuttingDown: false };
 
   serverProcess.on('close', (code) => {
-    if (!isShuttingDown) {
+    if (!shutdownState.isShuttingDown) {
       if (code !== 0 && code !== null) {
-        console.error(`Server exited with code ${code}`);
+        logger.error({ code }, 'Server exited with code');
         process.exit(code);
       }
     } else {
@@ -134,17 +135,19 @@ async function startServer(shouldOpenBrowser = false) {
 
   // Handle process termination
   const shutdown = async (signal) => {
-    if (isShuttingDown) return;
-    isShuttingDown = true;
+    if (shutdownState.isShuttingDown) {
+      return;
+    }
+    shutdownState.isShuttingDown = true;
 
-    console.log('Shutting down...');
+    logger.info('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...');
+      logger.info('Forcefully terminating server process...');
       serverProcess.kill('SIGKILL');
       process.exit(1);
     }, 5000);
@@ -164,7 +167,7 @@ async function startServer(shouldOpenBrowser = false) {
  */
 function validateDirectories() {
   if (!existsSync(uiDir)) {
-    console.error('Error: UI directory not found. Please ensure you are in the correct directory.');
+    logger.error('Error: UI directory not found. Please ensure you are in the correct directory.');
     process.exit(1);
   }
 }
@@ -178,15 +181,6 @@ async function ensureDependencies() {
   }
 }
 
-/**
- * Ensure UI is built
- */
-async function ensureUIBuilt() {
-  if (!existsSync(distDir)) {
-    await buildUI();
-  }
-}
-
 /**
  * Main execution function
  */
@@ -206,14 +200,14 @@ async function main() {
   // Ensure dependencies are installed
   await ensureDependencies();
 
-  // Ensure UI is built
-  await ensureUIBuilt();
+  // Validate UI is built (pre-built files should be included in package)
+  validateUIBuilt();
 
   // Start the server
   await startServer(options.open);
 }
 
 main().catch((error) => {
-  console.error('Unexpected error:', error);
+  logger.error({ error: error.message }, 'Unexpected error');
   process.exit(1);
 });

package/mcp-server/index.js

@@ -0,0 +1,115 @@
+import { createServer } from 'node:http';
+
+import serverLogger from '../shared/logger.js';
+import { isError } from './lib/common/error.js';
+import { runAllExternalServers } from './lib/server/external/all.js';
+
+import {
+  getDatabaseFile,
+  getMcpConfigPath,
+  prepareAppDataSpaces,
+} from 'mcp-shark-common/configs/index.js';
+import { initDb } from 'mcp-shark-common/db/init.js';
+import { getLogger } from 'mcp-shark-common/db/logger.js';
+import { withAuditRequestResponseHandler } from './lib/auditor/audit.js';
+import { getInternalServer } from './lib/server/internal/run.js';
+import { createInternalServerFactory } from './lib/server/internal/server.js';
+
+function initAuditLogger(serverLogger) {
+  serverLogger.info({ path: getDatabaseFile() }, 'Initializing audit logger at');
+  return getLogger(initDb(getDatabaseFile()));
+}
+
+/**
+ * Start the MCP Shark server
+ * @param {Object} options - Configuration options
+ * @param {string} [options.configPath] - Path to MCP config file (defaults to getMcpConfigPath())
+ * @param {number} [options.port=9851] - Port to listen on
+ * @param {Function} [options.onError] - Error callback
+ * @param {Function} [options.onReady] - Ready callback
+ * @returns {Promise<{app: Express, server: http.Server, stop: Function}>} Server instance
+ */
+export async function startMcpSharkServer(options = {}) {
+  const { configPath = getMcpConfigPath(), port = 9851, onError, onReady } = options;
+
+  prepareAppDataSpaces();
+
+  serverLogger.info('[MCP-Shark] Starting MCP server...');
+  serverLogger.info(`[MCP-Shark] Config path: ${configPath}`);
+  serverLogger.info(`[MCP-Shark] Database path: ${getDatabaseFile()}`);
+  serverLogger.info(`[MCP-Shark] Working directory: ${process.cwd()}`);
+  serverLogger.info(`[MCP-Shark] PATH: ${process.env.PATH}`);
+
+  try {
+    const auditLogger = initAuditLogger(serverLogger);
+    const externalServersResult = await runAllExternalServers(serverLogger, configPath);
+
+    if (isError(externalServersResult)) {
+      const error = new Error(JSON.stringify(externalServersResult));
+      if (onError) onError(error);
+      throw error;
+    }
+
+    const { kv, servers: externalServers } = externalServersResult;
+
+    const internalServerFactory = createInternalServerFactory(serverLogger, kv);
+    const app = getInternalServer(
+      internalServerFactory,
+      auditLogger,
+      withAuditRequestResponseHandler
+    );
+
+    const httpServer = createServer(app);
+
+    const server = await new Promise((resolve, reject) => {
+      httpServer.on('error', (err) => {
+        if (onError) onError(err);
+        reject(err);
+      });
+
+      httpServer.listen(port, '0.0.0.0', () => {
+        serverLogger.info(`MCP proxy HTTP server listening on http://localhost:${port}/mcp`);
+        if (onReady) onReady();
+        resolve(httpServer);
+      });
+    });
+
+    const stop = async () => {
+      // Close all external server clients
+      for (const serverInfo of externalServers) {
+        if (serverInfo?.client && !isError(serverInfo)) {
+          try {
+            await serverInfo.client.close();
+          } catch (err) {
+            serverLogger.warn({ error: err.message }, 'Error closing external server client');
+          }
+        }
+      }
+
+      // Close all connections forcefully
+      if (server.closeAllConnections) {
+        server.closeAllConnections();
+      }
+
+      // Close the server
+      return new Promise((resolve) => {
+        server.close(() => {
+          serverLogger.info('MCP Shark server stopped');
+          resolve();
+        });
+      });
+    };
+
+    return {
+      app,
+      server,
+      stop,
+      auditLogger,
+    };
+  } catch (error) {
+    const errorMsg = 'Error starting MCP server';
+    serverLogger.error({ error: error.message, stack: error.stack }, `[MCP-Shark] ${errorMsg}`);
+    if (onError) onError(error);
+    throw error;
+  }
+}

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

@@ -4,6 +4,17 @@ import { getSessionFromRequest } from '../server/internal/handlers/common.js';
 
 /* ---------- helpers ---------- */
 
+/**
+ * Safely parse JSON string, returning null if parsing fails
+ */
+function parseJsonSafely(jsonString) {
+  try {
+    return JSON.parse(jsonString);
+  } catch {
+    return null;
+  }
+}
+
 function toBuffer(body) {
   if (body === undefined || body === null) {
     return Buffer.alloc(0);
@@ -13,11 +24,7 @@ function toBuffer(body) {
     return body;
   }
 
-  if (
-    typeof body === 'object' &&
-    body.type === 'Buffer' &&
-    Array.isArray(body.data)
-  ) {
+  if (typeof body === 'object' && body.type === 'Buffer' && Array.isArray(body.data)) {
     return Buffer.from(body.data);
   }
 
@@ -52,7 +59,7 @@ function captureResponse(res) {
   const wrapped = new Proxy(res, {
     get(target, prop, receiver) {
       if (prop === 'write') {
-        return function (chunk, ...args) {
+        return (chunk, ...args) => {
           if (chunk) {
             const buf = toBuffer(chunk);
             chunks.push(buf);
@@ -62,7 +69,7 @@ function captureResponse(res) {
       }
 
       if (prop === 'end') {
-        return function (chunk, ...args) {
+        return (chunk, ...args) => {
           if (chunk) {
             const buf = toBuffer(chunk);
             chunks.push(buf);
@@ -114,12 +121,12 @@ function rebuildReq(req, buf) {
 }
 
 function waitForResponseFinish(res) {
-  return new Promise(resolve => {
-    let done = false;
+  return new Promise((resolve) => {
+    const state = { done: false };
 
     function finishOnce() {
-      if (!done) {
-        done = true;
+      if (!state.done) {
+        state.done = true;
         resolve();
       }
     }
@@ -135,24 +142,26 @@ 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');
-  const reqBodyJson = (() => {
-    try {
-      return JSON.parse(reqBodyStr);
-    } catch {
-      return null;
-    }
-  })();
+  const reqBodyJson = parseJsonSafely(reqBodyStr);
 
   // Log request packet to database
   const requestResult = auditLogger.logRequestPacket({
@@ -161,7 +170,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,
   });
 
@@ -169,15 +178,7 @@ export async function withAuditRequestResponseHandler(
 
   const replayReq = req.body ? req : rebuildReq(req, reqBuf);
 
-  const parsedForTransport = reqJsonRpc
-    ? (() => {
-        try {
-          return JSON.parse(reqBuf.toString('utf8'));
-        } catch {
-          return undefined;
-        }
-      })()
-    : undefined;
+  const parsedForTransport = reqJsonRpc ? parseJsonSafely(reqBuf.toString('utf8')) : undefined;
 
   // hand over to transport
   if (!transport || typeof transport.handleRequest !== 'function') {
@@ -198,19 +199,10 @@ export async function withAuditRequestResponseHandler(
 
   // Extract response body as string
   const resBodyStr = resBuf.toString('utf8');
-  const resBodyJson = (() => {
-    try {
-      return JSON.parse(resBodyStr);
-    } catch {
-      return null;
-    }
-  })();
+  const resBodyJson = parseJsonSafely(resBodyStr);
 
   // Extract JSON-RPC ID from request for correlation
-  const jsonrpcId =
-    reqJsonRpc?.payload?.id !== undefined
-      ? String(reqJsonRpc.payload.id)
-      : null;
+  const jsonrpcId = reqJsonRpc?.payload?.id !== undefined ? String(reqJsonRpc.payload.id) : null;
 
   // Log response packet to database
   // Use the same session ID from the request
@@ -223,6 +215,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/common/error.js

@@ -11,5 +11,5 @@ export function isError(error) {
 }
 
 export function getErrors(results) {
-  return results.filter(result => isError(result));
+  return results.filter((result) => isError(result));
 }

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

@@ -1,7 +1,7 @@
-import { normalizeConfig } from './config.js';
-import { runExternalServer } from './single/run.js';
 import { CompositeError, getErrors } from '../../common/error.js';
+import { normalizeConfig } from './config.js';
 import { buildKv } from './kv.js';
+import { runExternalServer } from './single/run.js';
 
 export class RunAllExternalServersError extends CompositeError {
   constructor(message, error, errors = []) {
@@ -13,9 +13,7 @@ export class RunAllExternalServersError extends CompositeError {
 export async function runAllExternalServers(logger, parsedConfig) {
   const configs = normalizeConfig(parsedConfig);
   const results = await Promise.all(
-    Object.entries(configs).map(([name, config]) =>
-      runExternalServer({ logger, name, config })
-    )
+    Object.entries(configs).map(([name, config]) => runExternalServer({ logger, name, config }))
   );
 
   const flattenedResults = results.flat();
@@ -28,5 +26,6 @@ export async function runAllExternalServers(logger, parsedConfig) {
     );
   }
 
-  return buildKv(flattenedResults);
+  const kv = buildKv(flattenedResults);
+  return { kv, servers: flattenedResults };
 }

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

@@ -16,9 +16,7 @@ function parseConfig(configPath) {
     }
     return new ConfigError(
       'Invalid config file',
-      new Error(
-        `Invalid config file: ${configPath} - ${JSON.stringify(conf, null, 2)}`
-      )
+      new Error(`Invalid config file: ${configPath} - ${JSON.stringify(conf, null, 2)}`)
     );
   } catch (error) {
     return new ConfigError(

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

@@ -1,25 +1,8 @@
 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 {
-      name,
-      tools,
-      resources,
-      prompts,
-      callTool,
-      getPrompt,
-      readResource,
-    } = downstreamServer;
+    const { name, tools, resources, prompts, callTool, getPrompt, readResource } = downstreamServer;
 
     if (!kv.has(name)) {
       const toolsMap = new Map();
@@ -42,17 +25,17 @@ export function buildKv(downstreamServers) {
         toolsMap,
         resourcesMap,
         promptsMap,
-        tools: tools.map(tool => {
-          return { ...tool, name: buildName(name, tool.name) };
+        tools: tools.map((tool) => {
+          return { ...tool, name: tool.name };
         }),
-        resources: resources.map(resource => {
+        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) };
+        prompts: prompts.map((prompt) => {
+          return { ...prompt, name: prompt.name };
         }),
       });
     }
@@ -61,42 +44,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/external/single/request.js

@@ -1,7 +1,7 @@
 import {
-  ListToolsResultSchema,
-  ListResourcesResultSchema,
   ListPromptsResultSchema,
+  ListResourcesResultSchema,
+  ListToolsResultSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 
 import { CompositeError } from '../../../common/error.js';
@@ -22,10 +22,7 @@ async function getListOf(client, typeOfList, schema) {
     [typeOfList]: [],
   };
   try {
-    const result = await client.request(
-      { method: `${typeOfList}/list` },
-      schema
-    );
+    const result = await client.request({ method: `${typeOfList}/list` }, schema);
     fetchedList[typeOfList] = result[typeOfList];
     return fetchedList;
   } catch (error) {

package/mcp-server/lib/server/external/single/run.js

@@ -1,7 +1,7 @@
-import { makeTransport } from './transport.js';
+import { CompositeError, getErrors, isError } from '../../../common/error.js';
 import { createClient } from './client.js';
 import * as requests from './request.js';
-import { isError, CompositeError, getErrors } from '../../../common/error.js';
+import { makeTransport } from './transport.js';
 
 export class RunError extends CompositeError {
   constructor(message, error, errors = []) {
@@ -11,27 +11,18 @@ export class RunError extends CompositeError {
 }
 
 export async function runExternalServer({ logger, name, config }) {
-  logger.debug(
-    `Starting external server run for server ${name} with config:`,
-    config
-  );
+  logger.debug(`Starting external server run for server ${name} with config:`, config);
 
   // Create transport
   const transport = makeTransport(config);
   if (isError(transport)) {
-    return new RunError(
-      `Error creating transport for external server ${name}`,
-      transport.error
-    );
+    return new RunError(`Error creating transport for external server ${name}`, transport.error);
   }
 
   // Create client
   const client = await createClient({ transport });
   if (isError(client)) {
-    return new RunError(
-      `Error creating client for external server ${name}`,
-      client.error
-    );
+    return new RunError(`Error creating client for external server ${name}`, client.error);
   }
 
   // Run requests
@@ -52,17 +43,15 @@ export async function runExternalServer({ logger, name, config }) {
     );
   }
 
-  const [{ tools }, { resources }, { prompts }] = results.map(
-    result => result.value
-  );
+  const [{ tools }, { resources }, { prompts }] = results.map((result) => result.value);
   return {
     name,
     client,
     tools,
     resources,
     prompts,
-    callTool: args => client.callTool.bind(client)(args),
-    readResource: resourceUri => {
+    callTool: (args) => client.callTool.bind(client)(args),
+    readResource: (resourceUri) => {
       return client.readResource.bind(client)(resourceUri);
     },
     getPrompt: (promptName, args) => {