cas-parser-node-mcp 1.4.0 → 1.7.1

package/src/http.ts

@@ -2,16 +2,17 @@
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-
+import { ClientOptions } from 'cas-parser-node';
 import express from 'express';
-import { fromError } from 'zod-validation-error/v3';
-import { McpOptions, parseQueryOptions } from './options';
-import { ClientOptions, initMcpServer, newMcpServer } from './server';
-import { parseAuthHeaders } from './headers';
+import morgan from 'morgan';
+import morganBody from 'morgan-body';
+import { parseAuthHeaders } from './auth';
+import { McpOptions } from './options';
+import { initMcpServer, newMcpServer } from './server';
 
-const newServer = ({
+const newServer = async ({
   clientOptions,
-  mcpOptions: defaultMcpOptions,
+  mcpOptions,
   req,
   res,
 }: {
@@ -19,39 +20,25 @@ const newServer = ({
   mcpOptions: McpOptions;
   req: express.Request;
   res: express.Response;
-}): McpServer | null => {
-  const server = newMcpServer();
-
-  let mcpOptions: McpOptions;
-  try {
-    mcpOptions = parseQueryOptions(defaultMcpOptions, req.query);
-  } catch (error) {
-    res.status(400).json({
-      jsonrpc: '2.0',
-      error: {
-        code: -32000,
-        message: `Invalid request: ${fromError(error)}`,
-      },
-    });
-    return null;
-  }
+}): Promise<McpServer | null> => {
+  const server = await newMcpServer();
 
   try {
-    const authOptions = parseAuthHeaders(req);
-    initMcpServer({
+    const authOptions = parseAuthHeaders(req, false);
+    await initMcpServer({
       server: server,
+      mcpOptions: mcpOptions,
       clientOptions: {
         ...clientOptions,
         ...authOptions,
       },
-      mcpOptions,
     });
-  } catch {
+  } catch (error) {
     res.status(401).json({
       jsonrpc: '2.0',
       error: {
         code: -32000,
-        message: 'Unauthorized',
+        message: `Unauthorized: ${error instanceof Error ? error.message : error}`,
       },
     });
     return null;
@@ -63,14 +50,11 @@ const newServer = ({
 const post =
   (options: { clientOptions: ClientOptions; mcpOptions: McpOptions }) =>
   async (req: express.Request, res: express.Response) => {
-    const server = newServer({ ...options, req, res });
+    const server = await newServer({ ...options, req, res });
     // If we return null, we already set the authorization error.
     if (server === null) return;
-    const transport = new StreamableHTTPServerTransport({
-      // Stateless server
-      sessionIdGenerator: undefined,
-    });
-    await server.connect(transport);
+    const transport = new StreamableHTTPServerTransport();
+    await server.connect(transport as any);
     await transport.handleRequest(req, res, req.body);
   };
 
@@ -96,15 +80,31 @@ const del = async (req: express.Request, res: express.Response) => {
 
 export const streamableHTTPApp = ({
   clientOptions = {},
-  mcpOptions = {},
+  mcpOptions,
+  debug,
 }: {
   clientOptions?: ClientOptions;
-  mcpOptions?: McpOptions;
+  mcpOptions: McpOptions;
+  debug: boolean;
 }): express.Express => {
   const app = express();
   app.set('query parser', 'extended');
   app.use(express.json());
 
+  if (debug) {
+    morganBody(app, {
+      logAllReqHeader: true,
+      logAllResHeader: true,
+      logRequestBody: true,
+      logResponseBody: true,
+    });
+  } else {
+    app.use(morgan('combined'));
+  }
+
+  app.get('/health', async (req: express.Request, res: express.Response) => {
+    res.status(200).send('OK');
+  });
   app.get('/', get);
   app.post('/', post({ clientOptions, mcpOptions }));
   app.delete('/', del);
@@ -112,9 +112,13 @@ export const streamableHTTPApp = ({
   return app;
 };
 
-export const launchStreamableHTTPServer = async (options: McpOptions, port: number | string | undefined) => {
-  const app = streamableHTTPApp({ mcpOptions: options });
-  const server = app.listen(port);
+export const launchStreamableHTTPServer = async (params: {
+  mcpOptions: McpOptions;
+  debug: boolean;
+  port: number | string | undefined;
+}) => {
+  const app = streamableHTTPApp({ mcpOptions: params.mcpOptions, debug: params.debug });
+  const server = app.listen(params.port);
   const address = server.address();
 
   if (typeof address === 'string') {
@@ -122,6 +126,6 @@ export const launchStreamableHTTPServer = async (options: McpOptions, port: numb
   } else if (address !== null) {
     console.error(`MCP Server running on streamable HTTP on port ${address.port}`);
   } else {
-    console.error(`MCP Server running on streamable HTTP on port ${port}`);
+    console.error(`MCP Server running on streamable HTTP on port ${params.port}`);
   }
 };

package/src/index.ts

@@ -1,20 +1,15 @@
 #!/usr/bin/env node
 
 import { selectTools } from './server';
-import { Endpoint, endpoints } from './tools';
 import { McpOptions, parseCLIOptions } from './options';
 import { launchStdioServer } from './stdio';
 import { launchStreamableHTTPServer } from './http';
+import type { McpTool } from './types';
 
 async function main() {
   const options = parseOptionsOrError();
 
-  if (options.list) {
-    listAllTools();
-    return;
-  }
-
-  const selectedTools = await selectToolsOrError(endpoints, options);
+  const selectedTools = await selectToolsOrError(options);
 
   console.error(
     `MCP Server starting with ${selectedTools.length} tools:`,
@@ -26,7 +21,11 @@ async function main() {
       await launchStdioServer(options);
       break;
     case 'http':
-      await launchStreamableHTTPServer(options, options.port ?? options.socket);
+      await launchStreamableHTTPServer({
+        mcpOptions: options,
+        debug: options.debug,
+        port: options.port ?? options.socket,
+      });
       break;
   }
 }
@@ -47,9 +46,9 @@ function parseOptionsOrError() {
   }
 }
 
-async function selectToolsOrError(endpoints: Endpoint[], options: McpOptions): Promise<Endpoint[]> {
+async function selectToolsOrError(options: McpOptions): Promise<McpTool[]> {
   try {
-    const includedTools = await selectTools(endpoints, options);
+    const includedTools = selectTools(options);
     if (includedTools.length === 0) {
       console.error('No tools match the provided filters.');
       process.exit(1);
@@ -64,45 +63,3 @@ async function selectToolsOrError(endpoints: Endpoint[], options: McpOptions): P
     process.exit(1);
   }
 }
-
-function listAllTools() {
-  if (endpoints.length === 0) {
-    console.log('No tools available.');
-    return;
-  }
-  console.log('Available tools:\n');
-
-  // Group endpoints by resource
-  const resourceGroups = new Map<string, typeof endpoints>();
-
-  for (const endpoint of endpoints) {
-    const resource = endpoint.metadata.resource;
-    if (!resourceGroups.has(resource)) {
-      resourceGroups.set(resource, []);
-    }
-    resourceGroups.get(resource)!.push(endpoint);
-  }
-
-  // Sort resources alphabetically
-  const sortedResources = Array.from(resourceGroups.keys()).sort();
-
-  // Display hierarchically by resource
-  for (const resource of sortedResources) {
-    console.log(`Resource: ${resource}`);
-
-    const resourceEndpoints = resourceGroups.get(resource)!;
-    // Sort endpoints by tool name
-    resourceEndpoints.sort((a, b) => a.tool.name.localeCompare(b.tool.name));
-
-    for (const endpoint of resourceEndpoints) {
-      const {
-        tool,
-        metadata: { operation, tags },
-      } = endpoint;
-
-      console.log(`  - ${tool.name} (${operation}) ${tags.length > 0 ? `tags: ${tags.join(', ')}` : ''}`);
-      console.log(`    Description: ${tool.description}`);
-    }
-    console.log('');
-  }
-}

package/src/methods.ts

@@ -0,0 +1,188 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { McpOptions } from './options';
+
+export type SdkMethod = {
+  clientCallName: string;
+  fullyQualifiedName: string;
+  httpMethod?: 'get' | 'post' | 'put' | 'patch' | 'delete' | 'query';
+  httpPath?: string;
+};
+
+export const sdkMethods: SdkMethod[] = [
+  {
+    clientCallName: 'client.credits.check',
+    fullyQualifiedName: 'credits.check',
+    httpMethod: 'post',
+    httpPath: '/credits',
+  },
+  {
+    clientCallName: 'client.logs.create',
+    fullyQualifiedName: 'logs.create',
+    httpMethod: 'post',
+    httpPath: '/logs',
+  },
+  {
+    clientCallName: 'client.logs.getSummary',
+    fullyQualifiedName: 'logs.getSummary',
+    httpMethod: 'post',
+    httpPath: '/logs/summary',
+  },
+  {
+    clientCallName: 'client.accessToken.create',
+    fullyQualifiedName: 'accessToken.create',
+    httpMethod: 'post',
+    httpPath: '/v1/access-token',
+  },
+  {
+    clientCallName: 'client.verifyToken.verify',
+    fullyQualifiedName: 'verifyToken.verify',
+    httpMethod: 'post',
+    httpPath: '/v1/verify-token',
+  },
+  {
+    clientCallName: 'client.camsKfintech.parse',
+    fullyQualifiedName: 'camsKfintech.parse',
+    httpMethod: 'post',
+    httpPath: '/v4/cams_kfintech/parse',
+  },
+  {
+    clientCallName: 'client.cdsl.parsePdf',
+    fullyQualifiedName: 'cdsl.parsePdf',
+    httpMethod: 'post',
+    httpPath: '/v4/cdsl/parse',
+  },
+  {
+    clientCallName: 'client.cdsl.fetch.requestOtp',
+    fullyQualifiedName: 'cdsl.fetch.requestOtp',
+    httpMethod: 'post',
+    httpPath: '/v4/cdsl/fetch',
+  },
+  {
+    clientCallName: 'client.cdsl.fetch.verifyOtp',
+    fullyQualifiedName: 'cdsl.fetch.verifyOtp',
+    httpMethod: 'post',
+    httpPath: '/v4/cdsl/fetch/{session_id}/verify',
+  },
+  {
+    clientCallName: 'client.contractNote.parse',
+    fullyQualifiedName: 'contractNote.parse',
+    httpMethod: 'post',
+    httpPath: '/v4/contract_note/parse',
+  },
+  {
+    clientCallName: 'client.inbox.checkConnectionStatus',
+    fullyQualifiedName: 'inbox.checkConnectionStatus',
+    httpMethod: 'post',
+    httpPath: '/v4/inbox/status',
+  },
+  {
+    clientCallName: 'client.inbox.connectEmail',
+    fullyQualifiedName: 'inbox.connectEmail',
+    httpMethod: 'post',
+    httpPath: '/v4/inbox/connect',
+  },
+  {
+    clientCallName: 'client.inbox.disconnectEmail',
+    fullyQualifiedName: 'inbox.disconnectEmail',
+    httpMethod: 'post',
+    httpPath: '/v4/inbox/disconnect',
+  },
+  {
+    clientCallName: 'client.inbox.listCasFiles',
+    fullyQualifiedName: 'inbox.listCasFiles',
+    httpMethod: 'post',
+    httpPath: '/v4/inbox/cas',
+  },
+  {
+    clientCallName: 'client.kfintech.generateCas',
+    fullyQualifiedName: 'kfintech.generateCas',
+    httpMethod: 'post',
+    httpPath: '/v4/kfintech/generate',
+  },
+  {
+    clientCallName: 'client.nsdl.parse',
+    fullyQualifiedName: 'nsdl.parse',
+    httpMethod: 'post',
+    httpPath: '/v4/nsdl/parse',
+  },
+  {
+    clientCallName: 'client.smart.parseCasPdf',
+    fullyQualifiedName: 'smart.parseCasPdf',
+    httpMethod: 'post',
+    httpPath: '/v4/smart/parse',
+  },
+];
+
+function allowedMethodsForCodeTool(options: McpOptions | undefined): SdkMethod[] | undefined {
+  if (!options) {
+    return undefined;
+  }
+
+  let allowedMethods: SdkMethod[];
+
+  if (options.codeAllowHttpGets || options.codeAllowedMethods) {
+    // Start with nothing allowed and then add into it from options
+    let allowedMethodsSet = new Set<SdkMethod>();
+
+    if (options.codeAllowHttpGets) {
+      // Add all methods that map to an HTTP GET
+      sdkMethods
+        .filter((method) => method.httpMethod === 'get')
+        .forEach((method) => allowedMethodsSet.add(method));
+    }
+
+    if (options.codeAllowedMethods) {
+      // Add all methods that match any of the allowed regexps
+      const allowedRegexps = options.codeAllowedMethods.map((pattern) => {
+        try {
+          return new RegExp(pattern);
+        } catch (e) {
+          throw new Error(
+            `Invalid regex pattern for allowed method: "${pattern}": ${e instanceof Error ? e.message : e}`,
+          );
+        }
+      });
+
+      sdkMethods
+        .filter((method) => allowedRegexps.some((regexp) => regexp.test(method.fullyQualifiedName)))
+        .forEach((method) => allowedMethodsSet.add(method));
+    }
+
+    allowedMethods = Array.from(allowedMethodsSet);
+  } else {
+    // Start with everything allowed
+    allowedMethods = [...sdkMethods];
+  }
+
+  if (options.codeBlockedMethods) {
+    // Filter down based on blocked regexps
+    const blockedRegexps = options.codeBlockedMethods.map((pattern) => {
+      try {
+        return new RegExp(pattern);
+      } catch (e) {
+        throw new Error(
+          `Invalid regex pattern for blocked method: "${pattern}": ${e instanceof Error ? e.message : e}`,
+        );
+      }
+    });
+
+    allowedMethods = allowedMethods.filter(
+      (method) => !blockedRegexps.some((regexp) => regexp.test(method.fullyQualifiedName)),
+    );
+  }
+
+  return allowedMethods;
+}
+
+export function blockedMethodsForCodeTool(options: McpOptions | undefined): SdkMethod[] | undefined {
+  const allowedMethods = allowedMethodsForCodeTool(options);
+  if (!allowedMethods) {
+    return undefined;
+  }
+
+  const allowedSet = new Set(allowedMethods.map((method) => method.fullyQualifiedName));
+
+  // Return any methods that are not explicitly allowed
+  return sdkMethods.filter((method) => !allowedSet.has(method.fullyQualifiedName));
+}