@zavudev/sdk-mcp 0.14.0

package/src/headers.ts

@@ -0,0 +1,25 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { IncomingMessage } from 'node:http';
+import { ClientOptions } from '@zavudev/sdk';
+
+export const parseAuthHeaders = (req: IncomingMessage): Partial<ClientOptions> => {
+  if (req.headers.authorization) {
+    const scheme = req.headers.authorization.split(' ')[0]!;
+    const value = req.headers.authorization.slice(scheme.length + 1);
+    switch (scheme) {
+      case 'Bearer':
+        return { apiKey: req.headers.authorization.slice('Bearer '.length) };
+      default:
+        throw new Error(
+          'Unsupported authorization scheme. Expected the "Authorization" header to be a supported scheme (Bearer).',
+        );
+    }
+  }
+
+  const apiKey =
+    Array.isArray(req.headers['x-zavudev-api-key']) ?
+      req.headers['x-zavudev-api-key'][0]
+    : req.headers['x-zavudev-api-key'];
+  return { apiKey };
+};

package/src/http.ts

@@ -0,0 +1,127 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+
+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';
+
+const newServer = ({
+  clientOptions,
+  mcpOptions: defaultMcpOptions,
+  req,
+  res,
+}: {
+  clientOptions: ClientOptions;
+  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;
+  }
+
+  try {
+    const authOptions = parseAuthHeaders(req);
+    initMcpServer({
+      server: server,
+      clientOptions: {
+        ...clientOptions,
+        ...authOptions,
+      },
+      mcpOptions,
+    });
+  } catch (error) {
+    res.status(401).json({
+      jsonrpc: '2.0',
+      error: {
+        code: -32000,
+        message: `Unauthorized: ${error instanceof Error ? error.message : error}`,
+      },
+    });
+    return null;
+  }
+
+  return server;
+};
+
+const post =
+  (options: { clientOptions: ClientOptions; mcpOptions: McpOptions }) =>
+  async (req: express.Request, res: express.Response) => {
+    const server = 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);
+    await transport.handleRequest(req, res, req.body);
+  };
+
+const get = async (req: express.Request, res: express.Response) => {
+  res.status(405).json({
+    jsonrpc: '2.0',
+    error: {
+      code: -32000,
+      message: 'Method not supported',
+    },
+  });
+};
+
+const del = async (req: express.Request, res: express.Response) => {
+  res.status(405).json({
+    jsonrpc: '2.0',
+    error: {
+      code: -32000,
+      message: 'Method not supported',
+    },
+  });
+};
+
+export const streamableHTTPApp = ({
+  clientOptions = {},
+  mcpOptions = {},
+}: {
+  clientOptions?: ClientOptions;
+  mcpOptions?: McpOptions;
+}): express.Express => {
+  const app = express();
+  app.set('query parser', 'extended');
+  app.use(express.json());
+
+  app.get('/', get);
+  app.post('/', post({ clientOptions, mcpOptions }));
+  app.delete('/', del);
+
+  return app;
+};
+
+export const launchStreamableHTTPServer = async (options: McpOptions, port: number | string | undefined) => {
+  const app = streamableHTTPApp({ mcpOptions: options });
+  const server = app.listen(port);
+  const address = server.address();
+
+  if (typeof address === 'string') {
+    console.error(`MCP Server running on streamable HTTP at ${address}`);
+  } 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}`);
+  }
+};

package/src/index.ts

@@ -0,0 +1,108 @@
+#!/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';
+
+async function main() {
+  const options = parseOptionsOrError();
+
+  if (options.list) {
+    listAllTools();
+    return;
+  }
+
+  const selectedTools = await selectToolsOrError(endpoints, options);
+
+  console.error(
+    `MCP Server starting with ${selectedTools.length} tools:`,
+    selectedTools.map((e) => e.tool.name),
+  );
+
+  switch (options.transport) {
+    case 'stdio':
+      await launchStdioServer(options);
+      break;
+    case 'http':
+      await launchStreamableHTTPServer(options, options.port ?? options.socket);
+      break;
+  }
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error('Fatal error in main():', error);
+    process.exit(1);
+  });
+}
+
+function parseOptionsOrError() {
+  try {
+    return parseCLIOptions();
+  } catch (error) {
+    console.error('Error parsing options:', error);
+    process.exit(1);
+  }
+}
+
+async function selectToolsOrError(endpoints: Endpoint[], options: McpOptions): Promise<Endpoint[]> {
+  try {
+    const includedTools = await selectTools(endpoints, options);
+    if (includedTools.length === 0) {
+      console.error('No tools match the provided filters.');
+      process.exit(1);
+    }
+    return includedTools;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error('Error filtering tools:', error.message);
+    } else {
+      console.error('Error filtering tools:', error);
+    }
+    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('');
+  }
+}