@notionhq/notion-mcp-server 1.0.0

package/scripts/start-server.ts

@@ -0,0 +1,70 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'url'
+
+import { OpenAPIV3 } from 'openapi-types'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import OpenAPISchemaValidator from 'openapi-schema-validator'
+
+import { MCPProxy } from '../src/openapi-mcp-server/mcp/proxy'
+
+export class ValidationError extends Error {
+  constructor(public errors: any[]) {
+    super('OpenAPI validation failed')
+    this.name = 'ValidationError'
+  }
+}
+
+export async function loadOpenApiSpec(specPath: string): Promise<OpenAPIV3.Document> {
+  let rawSpec: string
+
+  try {
+    rawSpec = fs.readFileSync(path.resolve(process.cwd(), specPath), 'utf-8')
+  } catch (error) {
+    console.error('Failed to read OpenAPI specification file:', (error as Error).message)
+    process.exit(1)
+  }
+
+  // Parse and validate the spec
+  try {
+    const parsed = JSON.parse(rawSpec)
+    const baseUrl = process.env.BASE_URL
+
+    if (baseUrl) {
+      parsed.servers[0].url = baseUrl
+    }
+
+    return parsed as OpenAPIV3.Document
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      throw error
+    }
+    console.error('Failed to parse OpenAPI specification:', (error as Error).message)
+    process.exit(1)
+  }
+}
+
+// Main execution
+export async function main(args: string[] = process.argv.slice(2)) {
+  const filename = fileURLToPath(import.meta.url)
+  const directory = path.dirname(filename)
+  const specPath = path.resolve(directory, '../scripts/notion-openapi.json')
+  const openApiSpec = await loadOpenApiSpec(specPath)
+  const proxy = new MCPProxy('OpenAPI Tools', openApiSpec)
+
+  return proxy.connect(new StdioServerTransport())
+}
+
+const shouldStart = process.argv[1].endsWith('notion-mcp-server')
+// Only run main if this is the entry point
+if (shouldStart) {
+  main().catch(error => {
+    if (error instanceof ValidationError) {
+      console.error('Invalid OpenAPI 3.1 specification:')
+      error.errors.forEach(err => console.error(err))
+    } else {
+      console.error('Error:', error.message)
+    }
+    process.exit(1)
+  })
+}

package/src/openapi-mcp-server/README.md

@@ -0,0 +1 @@
+Note: This is a fork from v1 of https://github.com/snaggle-ai/openapi-mcp-server. The library took a different direction with v2 which is not compatible with our development approach.

package/src/openapi-mcp-server/auth/index.ts

@@ -0,0 +1,2 @@
+export * from './types'
+export * from './template'

package/src/openapi-mcp-server/auth/template.ts

@@ -0,0 +1,24 @@
+import Mustache from 'mustache'
+import { AuthTemplate, TemplateContext } from './types'
+
+export function renderAuthTemplate(template: AuthTemplate, context: TemplateContext): AuthTemplate {
+  // Disable HTML escaping for URLs
+  Mustache.escape = (text) => text
+
+  // Render URL with template variables
+  const renderedUrl = Mustache.render(template.url, context)
+
+  // Create a new template object with rendered values
+  const renderedTemplate: AuthTemplate = {
+    ...template,
+    url: renderedUrl,
+    headers: { ...template.headers }, // Create a new headers object to avoid modifying the original
+  }
+
+  // Render body if it exists
+  if (template.body) {
+    renderedTemplate.body = Mustache.render(template.body, context)
+  }
+
+  return renderedTemplate
+}

package/src/openapi-mcp-server/auth/types.ts

@@ -0,0 +1,26 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
+
+export interface AuthTemplate {
+  url: string
+  method: HttpMethod
+  headers: Record<string, string>
+  body?: string
+}
+
+export interface SecurityScheme {
+  [key: string]: {
+    tokenUrl?: string
+    [key: string]: any
+  }
+}
+
+export interface Server {
+  url: string
+  description?: string
+}
+
+export interface TemplateContext {
+  securityScheme?: SecurityScheme
+  servers?: Server[]
+  args: Record<string, string>
+}

package/src/openapi-mcp-server/client/__tests__/http-client-upload.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { HttpClient } from '../http-client'
+import { OpenAPIV3 } from 'openapi-types'
+import fs from 'fs'
+import FormData from 'form-data'
+
+vi.mock('fs')
+vi.mock('form-data')
+
+describe('HttpClient File Upload', () => {
+  let client: HttpClient
+  const mockApiInstance = {
+    uploadFile: vi.fn(),
+  }
+
+  const baseConfig = {
+    baseUrl: 'http://test.com',
+    headers: {},
+  }
+
+  const mockOpenApiSpec: OpenAPIV3.Document = {
+    openapi: '3.0.0',
+    info: {
+      title: 'Test API',
+      version: '1.0.0',
+    },
+    paths: {
+      '/upload': {
+        post: {
+          operationId: 'uploadFile',
+          responses: {
+            '200': {
+              description: 'File uploaded successfully',
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: {
+                      success: {
+                        type: 'boolean',
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          requestBody: {
+            content: {
+              'multipart/form-data': {
+                schema: {
+                  type: 'object',
+                  properties: {
+                    file: {
+                      type: 'string',
+                      format: 'binary',
+                    },
+                    description: {
+                      type: 'string',
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    client = new HttpClient(baseConfig, mockOpenApiSpec)
+    // @ts-expect-error - Mock the private api property
+    client['api'] = Promise.resolve(mockApiInstance)
+  })
+
+  it('should handle file uploads with FormData', async () => {
+    const mockFormData = new FormData()
+    const mockFileStream = { pipe: vi.fn() }
+    const mockFormDataHeaders = { 'content-type': 'multipart/form-data; boundary=---123' }
+
+    vi.mocked(fs.createReadStream).mockReturnValue(mockFileStream as any)
+    vi.mocked(FormData.prototype.append).mockImplementation(() => {})
+    vi.mocked(FormData.prototype.getHeaders).mockReturnValue(mockFormDataHeaders)
+
+    const uploadPath = mockOpenApiSpec.paths['/upload']
+    if (!uploadPath?.post) {
+      throw new Error('Upload path not found in spec')
+    }
+    const operation = uploadPath.post as OpenAPIV3.OperationObject & { method: string; path: string }
+    const params = {
+      file: '/path/to/test.txt',
+      description: 'Test file',
+    }
+
+    mockApiInstance.uploadFile.mockResolvedValue({
+      data: { success: true },
+      status: 200,
+      headers: {},
+    })
+
+    await client.executeOperation(operation, params)
+
+    expect(fs.createReadStream).toHaveBeenCalledWith('/path/to/test.txt')
+    expect(FormData.prototype.append).toHaveBeenCalledWith('file', mockFileStream)
+    expect(FormData.prototype.append).toHaveBeenCalledWith('description', 'Test file')
+    expect(mockApiInstance.uploadFile).toHaveBeenCalledWith({}, expect.any(FormData), { headers: mockFormDataHeaders })
+  })
+
+  it('should throw error for invalid file path', async () => {
+    vi.mocked(fs.createReadStream).mockImplementation(() => {
+      throw new Error('File not found')
+    })
+
+    const uploadPath = mockOpenApiSpec.paths['/upload']
+    if (!uploadPath?.post) {
+      throw new Error('Upload path not found in spec')
+    }
+    const operation = uploadPath.post as OpenAPIV3.OperationObject & { method: string; path: string }
+    const params = {
+      file: '/nonexistent/file.txt',
+      description: 'Test file',
+    }
+
+    await expect(client.executeOperation(operation, params)).rejects.toThrow('Failed to read file at /nonexistent/file.txt')
+  })
+
+  it('should handle multiple file uploads', async () => {
+    const mockFormData = new FormData()
+    const mockFileStream1 = { pipe: vi.fn() }
+    const mockFileStream2 = { pipe: vi.fn() }
+    const mockFormDataHeaders = { 'content-type': 'multipart/form-data; boundary=---123' }
+
+    vi.mocked(fs.createReadStream)
+      .mockReturnValueOnce(mockFileStream1 as any)
+      .mockReturnValueOnce(mockFileStream2 as any)
+    vi.mocked(FormData.prototype.append).mockImplementation(() => {})
+    vi.mocked(FormData.prototype.getHeaders).mockReturnValue(mockFormDataHeaders)
+
+    const operation: OpenAPIV3.OperationObject = {
+      operationId: 'uploadFile',
+      responses: {
+        '200': {
+          description: 'Files uploaded successfully',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  success: {
+                    type: 'boolean',
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      requestBody: {
+        content: {
+          'multipart/form-data': {
+            schema: {
+              type: 'object',
+              properties: {
+                file1: {
+                  type: 'string',
+                  format: 'binary',
+                },
+                file2: {
+                  type: 'string',
+                  format: 'binary',
+                },
+                description: {
+                  type: 'string',
+                },
+              },
+            },
+          },
+        },
+      },
+    }
+
+    const params = {
+      file1: '/path/to/test1.txt',
+      file2: '/path/to/test2.txt',
+      description: 'Test files',
+    }
+
+    mockApiInstance.uploadFile.mockResolvedValue({
+      data: { success: true },
+      status: 200,
+      headers: {},
+    })
+
+    await client.executeOperation(operation as OpenAPIV3.OperationObject & { method: string; path: string }, params)
+
+    expect(fs.createReadStream).toHaveBeenCalledWith('/path/to/test1.txt')
+    expect(fs.createReadStream).toHaveBeenCalledWith('/path/to/test2.txt')
+    expect(FormData.prototype.append).toHaveBeenCalledWith('file1', mockFileStream1)
+    expect(FormData.prototype.append).toHaveBeenCalledWith('file2', mockFileStream2)
+    expect(FormData.prototype.append).toHaveBeenCalledWith('description', 'Test files')
+    expect(mockApiInstance.uploadFile).toHaveBeenCalledWith({}, expect.any(FormData), { headers: mockFormDataHeaders })
+  })
+})

package/src/openapi-mcp-server/client/__tests__/http-client.integration.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { HttpClient } from '../http-client'
+import type express from 'express'
+//@ts-ignore
+import { createPetstoreServer } from '../../../examples/petstore-server.cjs'
+import type { OpenAPIV3 } from 'openapi-types'
+import axios from 'axios'
+
+interface Pet {
+  id: number
+  name: string
+  species: string
+  age: number
+  status: 'available' | 'pending' | 'sold'
+}
+
+describe('HttpClient Integration Tests', () => {
+  const PORT = 3456
+  const BASE_URL = `http://localhost:${PORT}`
+  let server: ReturnType<typeof express>
+  let openApiSpec: OpenAPIV3.Document
+  let client: HttpClient
+
+  beforeAll(async () => {
+    // Start the petstore server
+    server = createPetstoreServer(PORT) as unknown as express.Express
+
+    // Fetch the OpenAPI spec from the server
+    const response = await axios.get(`${BASE_URL}/openapi.json`)
+    openApiSpec = response.data
+
+    // Create HTTP client
+    client = new HttpClient(
+      {
+        baseUrl: BASE_URL,
+        headers: {
+          Accept: 'application/json',
+        },
+      },
+      openApiSpec,
+    )
+  })
+
+  afterAll(() => {
+    //@ts-expect-error
+    server.close()
+  })
+
+  it('should list all pets', async () => {
+    const operation = openApiSpec.paths['/pets']?.get
+    if (!operation) throw new Error('Operation not found')
+
+    const response = await client.executeOperation<Pet[]>(operation as OpenAPIV3.OperationObject & { method: string; path: string })
+
+    expect(response.status).toBe(200)
+    expect(Array.isArray(response.data)).toBe(true)
+    expect(response.data.length).toBeGreaterThan(0)
+    expect(response.data[0]).toHaveProperty('name')
+    expect(response.data[0]).toHaveProperty('species')
+    expect(response.data[0]).toHaveProperty('status')
+  })
+
+  it('should filter pets by status', async () => {
+    const operation = openApiSpec.paths['/pets']?.get as OpenAPIV3.OperationObject & { method: string; path: string }
+    if (!operation) throw new Error('Operation not found')
+
+    const response = await client.executeOperation<Pet[]>(operation, { status: 'available' })
+
+    expect(response.status).toBe(200)
+    expect(Array.isArray(response.data)).toBe(true)
+    response.data.forEach((pet: Pet) => {
+      expect(pet.status).toBe('available')
+    })
+  })
+
+  it('should get a specific pet by ID', async () => {
+    const operation = openApiSpec.paths['/pets/{id}']?.get as OpenAPIV3.OperationObject & { method: string; path: string }
+    if (!operation) throw new Error('Operation not found')
+
+    const response = await client.executeOperation<Pet>(operation, { id: 1 })
+
+    expect(response.status).toBe(200)
+    expect(response.data).toHaveProperty('id', 1)
+    expect(response.data).toHaveProperty('name')
+    expect(response.data).toHaveProperty('species')
+  })
+
+  it('should create a new pet', async () => {
+    const operation = openApiSpec.paths['/pets']?.post as OpenAPIV3.OperationObject & { method: string; path: string }
+    if (!operation) throw new Error('Operation not found')
+
+    const newPet = {
+      name: 'TestPet',
+      species: 'Dog',
+      age: 2,
+    }
+
+    const response = await client.executeOperation<Pet>(operation as OpenAPIV3.OperationObject & { method: string; path: string }, newPet)
+
+    expect(response.status).toBe(201)
+    expect(response.data).toMatchObject({
+      ...newPet,
+      status: 'available',
+    })
+    expect(response.data.id).toBeDefined()
+  })
+
+  it("should update a pet's status", async () => {
+    const operation = openApiSpec.paths['/pets/{id}']?.put
+    if (!operation) throw new Error('Operation not found')
+
+    const response = await client.executeOperation<Pet>(operation as OpenAPIV3.OperationObject & { method: string; path: string }, {
+      id: 1,
+      status: 'sold',
+    })
+
+    expect(response.status).toBe(200)
+    expect(response.data).toHaveProperty('id', 1)
+    expect(response.data).toHaveProperty('status', 'sold')
+  })
+
+  it('should delete a pet', async () => {
+    // First create a pet to delete
+    const createOperation = openApiSpec.paths['/pets']?.post
+    if (!createOperation) throw new Error('Operation not found')
+
+    const createResponse = await client.executeOperation<Pet>(
+      createOperation as OpenAPIV3.OperationObject & { method: string; path: string },
+      {
+        name: 'ToDelete',
+        species: 'Cat',
+        age: 3,
+      },
+    )
+    const petId = createResponse.data.id
+
+    // Then delete it
+    const deleteOperation = openApiSpec.paths['/pets/{id}']?.delete
+    if (!deleteOperation) throw new Error('Operation not found')
+
+    const deleteResponse = await client.executeOperation(deleteOperation as OpenAPIV3.OperationObject & { method: string; path: string }, {
+      id: petId,
+    })
+
+    expect(deleteResponse.status).toBe(204)
+
+    // Verify the pet is deleted
+    const getOperation = openApiSpec.paths['/pets/{id}']?.get
+    if (!getOperation) throw new Error('Operation not found')
+
+    try {
+      await client.executeOperation(getOperation as OpenAPIV3.OperationObject & { method: string; path: string }, { id: petId })
+      throw new Error('Should not reach here')
+    } catch (error: any) {
+      expect(error.message).toContain('404')
+    }
+  })
+
+  it('should handle errors appropriately', async () => {
+    const operation = openApiSpec.paths['/pets/{id}']?.get as OpenAPIV3.OperationObject & { method: string; path: string }
+    if (!operation) throw new Error('Operation not found')
+
+    try {
+      await client.executeOperation(
+        operation as OpenAPIV3.OperationObject & { method: string; path: string },
+        { id: 99999 }, // Non-existent ID
+      )
+      throw new Error('Should not reach here')
+    } catch (error: any) {
+      expect(error.message).toContain('404')
+    }
+  })
+})