firecrawl-mcp 3.6.1 → 3.7.0

package/dist/src/index.test.js

@@ -1,225 +0,0 @@
-import FirecrawlApp from '@mendable/firecrawl-js';
-import { describe, expect, jest, test, beforeEach, afterEach, } from '@jest/globals';
-import { mock } from 'jest-mock-extended';
-// Mock FirecrawlApp
-jest.mock('@mendable/firecrawl-js');
-describe('FireCrawl Tool Tests', () => {
-    let mockClient;
-    let requestHandler;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockClient = mock();
-        // Set up mock implementations
-        const mockInstance = new FirecrawlApp({ apiKey: 'test' });
-        Object.assign(mockInstance, mockClient);
-        // Create request handler
-        requestHandler = async (request) => {
-            const { name, arguments: args } = request.params;
-            if (!args) {
-                throw new Error('No arguments provided');
-            }
-            return handleRequest(name, args, mockClient);
-        };
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    // Test scrape functionality
-    test('should handle scrape request', async () => {
-        const url = 'https://example.com';
-        const options = { formats: ['markdown'] };
-        const mockResponse = {
-            success: true,
-            markdown: '# Test Content',
-            html: undefined,
-            rawHtml: undefined,
-            url: 'https://example.com',
-            actions: undefined,
-        };
-        mockClient.scrapeUrl.mockResolvedValueOnce(mockResponse);
-        const response = await requestHandler({
-            method: 'call_tool',
-            params: {
-                name: 'firecrawl_scrape',
-                arguments: { url, ...options },
-            },
-        });
-        expect(response).toEqual({
-            content: [{ type: 'text', text: '# Test Content' }],
-            isError: false,
-        });
-        expect(mockClient.scrapeUrl).toHaveBeenCalledWith(url, {
-            formats: ['markdown'],
-            url,
-        });
-    });
-    // Test batch scrape functionality
-    test('should handle batch scrape request', async () => {
-        const urls = ['https://example.com'];
-        const options = { formats: ['markdown'] };
-        mockClient.asyncBatchScrapeUrls.mockResolvedValueOnce({
-            success: true,
-            id: 'test-batch-id',
-        });
-        const response = await requestHandler({
-            method: 'call_tool',
-            params: {
-                name: 'firecrawl_batch_scrape',
-                arguments: { urls, options },
-            },
-        });
-        expect(response.content[0].text).toContain('Batch operation queued with ID: batch_');
-        expect(mockClient.asyncBatchScrapeUrls).toHaveBeenCalledWith(urls, options);
-    });
-    // Test search functionality
-    test('should handle search request', async () => {
-        const query = 'test query';
-        const scrapeOptions = { formats: ['markdown'] };
-        const mockSearchResponse = {
-            success: true,
-            data: [
-                {
-                    url: 'https://example.com',
-                    title: 'Test Page',
-                    description: 'Test Description',
-                    markdown: '# Test Content',
-                    actions: undefined,
-                },
-            ],
-        };
-        mockClient.search.mockResolvedValueOnce(mockSearchResponse);
-        const response = await requestHandler({
-            method: 'call_tool',
-            params: {
-                name: 'firecrawl_search',
-                arguments: { query, scrapeOptions },
-            },
-        });
-        expect(response.isError).toBe(false);
-        expect(response.content[0].text).toContain('Test Page');
-        expect(mockClient.search).toHaveBeenCalledWith(query, scrapeOptions);
-    });
-    // Test crawl functionality
-    test('should handle crawl request', async () => {
-        const url = 'https://example.com';
-        const options = { maxDepth: 2 };
-        mockClient.asyncCrawlUrl.mockResolvedValueOnce({
-            success: true,
-            id: 'test-crawl-id',
-        });
-        const response = await requestHandler({
-            method: 'call_tool',
-            params: {
-                name: 'firecrawl_crawl',
-                arguments: { url, ...options },
-            },
-        });
-        expect(response.isError).toBe(false);
-        expect(response.content[0].text).toContain('test-crawl-id');
-        expect(mockClient.asyncCrawlUrl).toHaveBeenCalledWith(url, {
-            maxDepth: 2,
-            url,
-        });
-    });
-    // Test error handling
-    test('should handle API errors', async () => {
-        const url = 'https://example.com';
-        mockClient.scrapeUrl.mockRejectedValueOnce(new Error('API Error'));
-        const response = await requestHandler({
-            method: 'call_tool',
-            params: {
-                name: 'firecrawl_scrape',
-                arguments: { url },
-            },
-        });
-        expect(response.isError).toBe(true);
-        expect(response.content[0].text).toContain('API Error');
-    });
-    // Test rate limiting
-    test('should handle rate limits', async () => {
-        const url = 'https://example.com';
-        // Mock rate limit error
-        mockClient.scrapeUrl.mockRejectedValueOnce(new Error('rate limit exceeded'));
-        const response = await requestHandler({
-            method: 'call_tool',
-            params: {
-                name: 'firecrawl_scrape',
-                arguments: { url },
-            },
-        });
-        expect(response.isError).toBe(true);
-        expect(response.content[0].text).toContain('rate limit exceeded');
-    });
-});
-// Helper function to simulate request handling
-async function handleRequest(name, args, client) {
-    try {
-        switch (name) {
-            case 'firecrawl_scrape': {
-                const response = await client.scrapeUrl(args.url, args);
-                if (!response.success) {
-                    throw new Error(response.error || 'Scraping failed');
-                }
-                return {
-                    content: [
-                        { type: 'text', text: response.markdown || 'No content available' },
-                    ],
-                    isError: false,
-                };
-            }
-            case 'firecrawl_batch_scrape': {
-                const response = await client.asyncBatchScrapeUrls(args.urls, args.options);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Batch operation queued with ID: batch_1. Use firecrawl_check_batch_status to check progress.`,
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            case 'firecrawl_search': {
-                const response = await client.search(args.query, args.scrapeOptions);
-                if (!response.success) {
-                    throw new Error(response.error || 'Search failed');
-                }
-                const results = response.data
-                    .map((result) => `URL: ${result.url}\nTitle: ${result.title || 'No title'}\nDescription: ${result.description || 'No description'}\n${result.markdown ? `\nContent:\n${result.markdown}` : ''}`)
-                    .join('\n\n');
-                return {
-                    content: [{ type: 'text', text: results }],
-                    isError: false,
-                };
-            }
-            case 'firecrawl_crawl': {
-                const response = await client.asyncCrawlUrl(args.url, args);
-                if (!response.success) {
-                    throw new Error(response.error);
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Started crawl for ${args.url} with job ID: ${response.id}`,
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: error instanceof Error ? error.message : String(error),
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/versioned-server.js

@@ -1,203 +0,0 @@
-#!/usr/bin/env node
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import express from 'express';
-import dotenv from 'dotenv';
-import { createV1Server } from './server-v1.js';
-import { createV2Server } from './server-v2.js';
-dotenv.config();
-export async function runVersionedSSECloudServer() {
-    const transports = {};
-    const app = express();
-    // Health check endpoint
-    app.get('/health', (req, res) => {
-        res.status(200).json({
-            status: 'OK',
-            versions: ['v1', 'v2'],
-            endpoints: {
-                v1: {
-                    sse: '/{apiKey}/sse',
-                    messages: '/{apiKey}/messages'
-                },
-                v2: {
-                    sse: '/{apiKey}/v2/sse',
-                    messages: '/{apiKey}/v2/messages'
-                }
-            }
-        });
-    });
-    // Create server instances
-    const v1Server = createV1Server();
-    const v2Server = createV2Server();
-    // V1 SSE endpoint (legacy)
-    app.get('/:apiKey/sse', async (req, res) => {
-        const apiKey = req.params.apiKey;
-        const transport = new SSEServerTransport(`/${apiKey}/messages`, res);
-        console.log(`[V1] New SSE connection for API key: ${apiKey}`);
-        const compositeKey = `${apiKey}-${transport.sessionId}`;
-        transports[compositeKey] = { transport, version: 'v1' };
-        res.on('close', () => {
-            console.log(`[V1] SSE connection closed for: ${compositeKey}`);
-            delete transports[compositeKey];
-        });
-        await v1Server.connect(transport);
-    });
-    // V1 SSE HEAD for quick availability checks
-    app.head('/:apiKey/sse', (req, res) => {
-        res.status(200).end();
-    });
-    // V2 SSE endpoint (new)
-    app.get('/:apiKey/v2/sse', async (req, res) => {
-        const apiKey = req.params.apiKey;
-        const transport = new SSEServerTransport(`/${apiKey}/v2/messages`, res);
-        console.log(`[V2] New SSE connection for API key: ${apiKey}`);
-        const compositeKey = `${apiKey}-${transport.sessionId}`;
-        transports[compositeKey] = { transport, version: 'v2' };
-        res.on('close', () => {
-            console.log(`[V2] SSE connection closed for: ${compositeKey}`);
-            delete transports[compositeKey];
-        });
-        await v2Server.connect(transport);
-    });
-    // V2 SSE HEAD for quick availability checks
-    app.head('/:apiKey/v2/sse', (req, res) => {
-        res.status(200).end();
-    });
-    // V1 message endpoint (legacy)
-    app.post('/:apiKey/messages', express.json(), async (req, res) => {
-        const apiKey = req.params.apiKey;
-        const body = req.body;
-        // Enrich the body with API key metadata
-        const enrichedBody = {
-            ...body,
-        };
-        if (enrichedBody && enrichedBody.params && !enrichedBody.params._meta) {
-            enrichedBody.params._meta = { apiKey };
-        }
-        else if (enrichedBody &&
-            enrichedBody.params &&
-            enrichedBody.params._meta) {
-            enrichedBody.params._meta.apiKey = apiKey;
-        }
-        console.log(`[V1] Message received for API key: ${apiKey}`);
-        // Prefer explicit sessionId from query, then common header names
-        const rawSessionId = req.query.sessionId ||
-            req.headers['mcp-session-id'] ||
-            req.headers['x-mcp-session-id'] ||
-            '';
-        let compositeKey = `${apiKey}-${rawSessionId}`;
-        let versionedTransport = transports[compositeKey];
-        // Fallback: if not found, and there is exactly one active V1 transport for this apiKey, use it
-        if (!versionedTransport) {
-            const candidates = Object.entries(transports).filter(([key, vt]) => vt.version === 'v1' && key.startsWith(`${apiKey}-`));
-            if (candidates.length === 1) {
-                const [fallbackKey, vt] = candidates[0];
-                console.warn(`[V1] sessionId not provided or not found. Falling back to single active transport: ${fallbackKey}`);
-                compositeKey = fallbackKey;
-                versionedTransport = vt;
-            }
-        }
-        if (versionedTransport && versionedTransport.version === 'v1') {
-            await versionedTransport.transport.handlePostMessage(req, res, enrichedBody);
-        }
-        else {
-            console.error(`[V1] No transport found for sessionId: ${compositeKey}`);
-            res.status(400).json({
-                error: 'No V1 transport found for sessionId',
-                sessionId: compositeKey,
-                availableTransports: Object.keys(transports)
-            });
-        }
-    });
-    // V2 message endpoint (new)
-    app.post('/:apiKey/v2/messages', express.json(), async (req, res) => {
-        const apiKey = req.params.apiKey;
-        const body = req.body;
-        // Enrich the body with API key metadata
-        const enrichedBody = {
-            ...body,
-        };
-        if (enrichedBody && enrichedBody.params && !enrichedBody.params._meta) {
-            enrichedBody.params._meta = { apiKey };
-        }
-        else if (enrichedBody &&
-            enrichedBody.params &&
-            enrichedBody.params._meta) {
-            enrichedBody.params._meta.apiKey = apiKey;
-        }
-        console.log(`[V2] Message received for API key: ${apiKey}`);
-        const sessionId = req.query.sessionId;
-        const compositeKey = `${apiKey}-${sessionId}`;
-        const versionedTransport = transports[compositeKey];
-        if (versionedTransport && versionedTransport.version === 'v2') {
-            await versionedTransport.transport.handlePostMessage(req, res, enrichedBody);
-        }
-        else {
-            console.error(`[V2] No transport found for sessionId: ${compositeKey}`);
-            res.status(400).json({
-                error: 'No V2 transport found for sessionId',
-                sessionId: compositeKey,
-                availableTransports: Object.keys(transports)
-            });
-        }
-    });
-    // Catch-all for unsupported endpoints
-    app.use((req, res) => {
-        res.status(404).json({
-            error: 'Endpoint not found',
-            supportedEndpoints: {
-                health: '/health',
-                v1: {
-                    sse: '/:apiKey/sse',
-                    messages: '/:apiKey/messages'
-                },
-                v2: {
-                    sse: '/:apiKey/v2/sse',
-                    messages: '/:apiKey/v2/messages'
-                }
-            }
-        });
-    });
-    const PORT = process.env.PORT || 3000;
-    const server = app.listen(PORT, () => {
-        console.log(`🚀 Versioned MCP SSE Server listening on http://localhost:${PORT}`);
-        console.log('📋 Available endpoints:');
-        console.log(`   Health: http://localhost:${PORT}/health`);
-        console.log(`   V1 SSE: http://localhost:${PORT}/{apiKey}/sse`);
-        console.log(`   V1 Messages: http://localhost:${PORT}/{apiKey}/messages`);
-        console.log(`   V2 SSE: http://localhost:${PORT}/{apiKey}/v2/sse`);
-        console.log(`   V2 Messages: http://localhost:${PORT}/{apiKey}/v2/messages`);
-        console.log('');
-        console.log('🔧 Versions:');
-        console.log('   V1: Firecrawl JS 1.29.3 (legacy tools + deep research + llms.txt)');
-        console.log('   V2: Firecrawl JS 3.1.0 (modern API + JSON extraction)');
-    });
-    server.on('error', (error) => {
-        console.error('❌ Server error:', error);
-        if (error.code === 'EADDRINUSE') {
-            console.error(`❌ Port ${PORT} is already in use. Please use a different port.`);
-        }
-        process.exit(1);
-    });
-    // Graceful shutdown
-    process.on('SIGINT', () => {
-        console.log('\n🛑 Shutting down server...');
-        console.log(`📊 Active connections: ${Object.keys(transports).length}`);
-        // Close all transports
-        for (const [key, versionedTransport] of Object.entries(transports)) {
-            try {
-                console.log(`🔌 Closing transport: ${key} (${versionedTransport.version})`);
-                // Note: SSEServerTransport doesn't have a close method, connections will close naturally
-                delete transports[key];
-            }
-            catch (error) {
-                console.error(`❌ Error closing transport ${key}:`, error);
-            }
-        }
-        console.log('✅ Server shutdown complete');
-        process.exit(0);
-    });
-}
-// Start the server if this file is run directly
-// if (import.meta.url === `file://${process.argv[1]}`) {
-//   runVersionedSSECloudServer().catch(console.error);
-// }