firecrawl-mcp 1.3.0

package/dist/src/index.test.js

@@ -0,0 +1,225 @@
+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/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "firecrawl-mcp",
+  "version": "1.3.0",
+  "description": "MCP server for FireCrawl web scraping integration. Supports both cloud and self-hosted instances. Features include web scraping, batch processing, structured data extraction, and LLM-powered content analysis.",
+  "type": "module",
+  "bin": "dist/src/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "start": "node dist/src/index.js",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "format": "prettier --write .",
+    "prepare": "npm run build",
+    "publish": "npm run build && npm publish"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@mendable/firecrawl-js": "^1.16.0",
+    "@modelcontextprotocol/sdk": "^1.4.1",
+    "dotenv": "^16.4.7",
+    "p-queue": "^8.0.1"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.10.5",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "jest": "^29.7.0",
+    "jest-mock-extended": "^4.0.0-beta1",
+    "prettier": "^3.1.1",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "firecrawl",
+    "web-scraping",
+    "crawler",
+    "content-extraction"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mendableai/firecrawl-mcp-server.git"
+  },
+  "author": "vrknetha",
+  "bugs": {
+    "url": "https://github.com/mendableai/firecrawl-mcp-server/issues"
+  },
+  "homepage": "https://github.com/mendableai/firecrawl-mcp-server#readme"
+}