bluera-knowledge 0.14.0 → 0.14.1

package/tests/integration/mcp.test.ts

@@ -1,250 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
-import { spawn } from 'node:child_process';
-import { rm, mkdtemp, writeFile, mkdir } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import * as readline from 'node:readline';
-
-/**
- * MCP Server Integration Tests
- *
- * Tests that the MCP server actually starts and accepts JSON-RPC messages.
- * Unlike unit tests that mock runMCPServer, these tests spawn a real
- * MCP server process and communicate via stdin/stdout.
- */
-describe('MCP Integration', () => {
-  let tempDir: string;
-  let testFilesDir: string;
-
-  beforeAll(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'mcp-test-'));
-    testFilesDir = join(tempDir, 'files');
-    await mkdir(testFilesDir, { recursive: true });
-    await writeFile(
-      join(testFilesDir, 'test.md'),
-      '# Test Document\n\nContent for MCP integration testing.'
-    );
-  }, 30000);
-
-  afterAll(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  interface JSONRPCResponse {
-    jsonrpc: string;
-    id: number;
-    result?: unknown;
-    error?: { code: number; message: string };
-  }
-
-  interface MCPClient {
-    proc: ChildProcess;
-    sendRequest: (method: string, params?: Record<string, unknown>) => Promise<JSONRPCResponse>;
-    close: () => void;
-  }
-
-  /**
-   * Start the MCP server and return a client with message helpers
-   */
-  function startMCPServer(): MCPClient {
-    const proc = spawn('node', ['dist/mcp/server.js'], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: {
-        ...process.env,
-        PROJECT_ROOT: tempDir,
-        DATA_DIR: join(tempDir, 'data'),
-        CONFIG_PATH: join(tempDir, 'config.json'),
-      },
-    });
-
-    // Set up a single readline interface for the entire process lifetime
-    const rl = readline.createInterface({ input: proc.stdout! });
-    const pendingRequests = new Map<
-      number,
-      { resolve: (r: JSONRPCResponse) => void; reject: (e: Error) => void }
-    >();
-    let requestId = 0;
-
-    rl.on('line', (line: string) => {
-      try {
-        const response = JSON.parse(line) as JSONRPCResponse;
-        const pending = pendingRequests.get(response.id);
-        if (pending !== undefined) {
-          pendingRequests.delete(response.id);
-          pending.resolve(response);
-        }
-      } catch {
-        // Ignore non-JSON lines (like log output)
-      }
-    });
-
-    return {
-      proc,
-      sendRequest: (
-        method: string,
-        params: Record<string, unknown> = {}
-      ): Promise<JSONRPCResponse> => {
-        return new Promise((resolve, reject) => {
-          if (proc.stdin === null) {
-            reject(new Error('Process stdin not available'));
-            return;
-          }
-
-          const id = ++requestId;
-          const timeout = setTimeout(() => {
-            pendingRequests.delete(id);
-            reject(new Error(`Timeout waiting for response to ${method}`));
-          }, 30000);
-
-          pendingRequests.set(id, {
-            resolve: (r) => {
-              clearTimeout(timeout);
-              resolve(r);
-            },
-            reject: (e) => {
-              clearTimeout(timeout);
-              reject(e);
-            },
-          });
-
-          const request = JSON.stringify({
-            jsonrpc: '2.0',
-            id,
-            method,
-            params,
-          });
-
-          proc.stdin.write(request + '\n');
-        });
-      },
-      close: (): void => {
-        rl.close();
-        proc.kill('SIGTERM');
-      },
-    };
-  }
-
-  /**
-   * Wait for process to be ready
-   */
-  async function waitForReady(client: MCPClient, timeoutMs = 10000): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error('Timeout waiting for MCP server to start'));
-      }, timeoutMs);
-
-      // MCP servers typically become ready quickly
-      // Give it a moment to initialize
-      setTimeout(() => {
-        clearTimeout(timeout);
-        resolve();
-      }, 1000);
-
-      client.proc.on('error', (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
-
-      client.proc.on('exit', (code) => {
-        clearTimeout(timeout);
-        if (code !== 0 && code !== null) {
-          reject(new Error(`MCP server exited with code ${code}`));
-        }
-      });
-    });
-  }
-
-  let mcpClient: MCPClient | null = null;
-
-  afterEach(async () => {
-    // Clean up MCP client if still running
-    if (mcpClient !== null) {
-      mcpClient.close();
-      await new Promise<void>((resolve) => {
-        if (mcpClient !== null) {
-          mcpClient.proc.on('exit', () => resolve());
-          setTimeout(() => {
-            if (mcpClient !== null) {
-              mcpClient.proc.kill('SIGKILL');
-            }
-            resolve();
-          }, 2000);
-        } else {
-          resolve();
-        }
-      });
-      mcpClient = null;
-    }
-  });
-
-  it('starts, lists tools, and handles tool execution', async () => {
-    mcpClient = startMCPServer();
-    await waitForReady(mcpClient);
-
-    // 1. Initialize
-    const initResponse = await mcpClient.sendRequest('initialize', {
-      protocolVersion: '2024-11-05',
-      capabilities: {},
-      clientInfo: { name: 'test-client', version: '1.0.0' },
-    });
-
-    expect(initResponse.jsonrpc).toBe('2.0');
-    expect(initResponse.error).toBeUndefined();
-    expect(initResponse.result).toBeDefined();
-
-    const initResult = initResponse.result as {
-      protocolVersion: string;
-      serverInfo: { name: string; version: string };
-      capabilities: { tools: Record<string, unknown> };
-    };
-    expect(initResult.serverInfo.name).toBe('bluera-knowledge');
-    expect(initResult.capabilities.tools).toBeDefined();
-
-    // 2. List tools
-    const toolsResponse = await mcpClient.sendRequest('tools/list', {});
-
-    expect(toolsResponse.error).toBeUndefined();
-    expect(toolsResponse.result).toBeDefined();
-
-    const toolsResult = toolsResponse.result as {
-      tools: Array<{ name: string; description: string }>;
-    };
-    expect(Array.isArray(toolsResult.tools)).toBe(true);
-
-    const toolNames = toolsResult.tools.map((t) => t.name);
-    expect(toolNames).toContain('search');
-    expect(toolNames).toContain('get_full_context');
-    expect(toolNames).toContain('execute');
-
-    // 3. Call search tool
-    const searchResponse = await mcpClient.sendRequest('tools/call', {
-      name: 'search',
-      arguments: {
-        query: 'test query',
-        limit: 5,
-      },
-    });
-
-    expect(searchResponse.error).toBeUndefined();
-    expect(searchResponse.result).toBeDefined();
-
-    const searchResult = searchResponse.result as {
-      content: Array<{ type: string; text: string }>;
-    };
-    expect(Array.isArray(searchResult.content)).toBe(true);
-
-    // 4. Call execute with help command
-    const helpResponse = await mcpClient.sendRequest('tools/call', {
-      name: 'execute',
-      arguments: {
-        command: 'help',
-      },
-    });
-
-    expect(helpResponse.error).toBeUndefined();
-    expect(helpResponse.result).toBeDefined();
-
-    const helpResult = helpResponse.result as { content: Array<{ type: string; text: string }> };
-    expect(helpResult.content[0]?.text).toContain('Available commands');
-  }, 120000);
-});

package/tests/integration/python-bridge.test.ts

@@ -1,193 +0,0 @@
-import { describe, it, expect, beforeAll, beforeEach, afterAll, afterEach } from 'vitest';
-import { PythonBridge } from '../../src/crawl/bridge.js';
-import { TestHTMLServer } from '../fixtures/test-server.js';
-
-describe('Python Bridge Integration Tests', () => {
-  let bridge: PythonBridge;
-  let server: TestHTMLServer;
-  let baseUrl: string;
-
-  beforeAll(async () => {
-    server = new TestHTMLServer();
-    baseUrl = await server.start();
-  }, 30000);
-
-  afterAll(async () => {
-    await server.stop();
-  });
-
-  beforeEach(async () => {
-    bridge = new PythonBridge();
-    await bridge.start();
-  }, 30000);
-
-  afterEach(async () => {
-    await bridge.stop();
-  });
-
-  describe('Process Lifecycle', () => {
-    it('spawns real Python process', async () => {
-      // Verify process exists by making a successful call
-      const result = await bridge.crawl(baseUrl);
-      expect(result.pages).toBeDefined();
-      expect(result.pages.length).toBeGreaterThan(0);
-    }, 30000);
-
-    it('stop() waits for process to actually exit', async () => {
-      // Make a request to ensure process is running
-      await bridge.crawl(baseUrl);
-
-      // Stop should wait for process exit
-      await bridge.stop();
-
-      // After stop() resolves, the process should be fully terminated
-      // Calling stop() again should be a no-op (process already null)
-      await bridge.stop(); // Should not hang or error
-    }, 30000);
-
-    it('can create new bridge after stopping', async () => {
-      // Stop the current bridge
-      await bridge.stop();
-
-      // Create and start a new bridge
-      const newBridge = new PythonBridge();
-      await newBridge.start();
-
-      try {
-        // Verify the new bridge works
-        const result = await newBridge.crawl(`${baseUrl}/about`);
-        expect(result.pages).toBeDefined();
-        expect(result.pages[0].content).toContain('About');
-      } finally {
-        await newBridge.stop();
-      }
-    }, 30000);
-  });
-
-  describe('Real crawl4ai Responses', () => {
-    it('validates simple crawl response format', async () => {
-      // Use test server (local HTTP, fast)
-      const result = await bridge.crawl(`${baseUrl}/page1`);
-
-      // Verify response structure matches schema
-      expect(result.pages).toBeDefined();
-      expect(result.pages).toBeInstanceOf(Array);
-      expect(result.pages.length).toBeGreaterThan(0);
-
-      const page = result.pages[0];
-      expect(page.url).toBeDefined();
-      expect(page.title).toBeDefined();
-      expect(page.content).toBeDefined();
-      expect(page.links).toBeInstanceOf(Array);
-      expect(page.crawledAt).toBeDefined();
-    }, 30000);
-
-    it('validates link format from real crawl4ai (CRITICAL: catches the bug!)', async () => {
-      const result = await bridge.crawl(baseUrl);
-
-      expect(result.pages).toBeDefined();
-      expect(result.pages.length).toBeGreaterThan(0);
-
-      const links = result.pages[0].links;
-      expect(links).toBeInstanceOf(Array);
-
-      // This is the CRITICAL test that would have caught the original bug!
-      // If crawl4ai returns link objects instead of strings, this will fail
-      links.forEach((link: string) => {
-        // Links should be strings after Zod validation
-        expect(typeof link).toBe('string');
-
-        // Should not be "[object Object]"
-        expect(link).not.toBe('[object Object]');
-      });
-    }, 30000);
-
-    it('validates headless fetch response format', async () => {
-      const result = await bridge.fetchHeadless(`${baseUrl}/js-rendered`);
-
-      // Verify response structure
-      expect(result.html).toBeDefined();
-      expect(typeof result.html).toBe('string');
-      expect(result.markdown).toBeDefined();
-      expect(typeof result.markdown).toBe('string');
-      expect(result.links).toBeInstanceOf(Array);
-
-      // Verify links are either strings or objects with href property
-      result.links.forEach((link: string | { href: string }) => {
-        if (typeof link === 'object') {
-          expect(link).toHaveProperty('href');
-          expect(typeof link.href).toBe('string');
-        } else {
-          expect(typeof link).toBe('string');
-        }
-      });
-    }, 60000); // Headless mode takes longer
-
-    it('extracts markdown content correctly', async () => {
-      const result = await bridge.crawl(`${baseUrl}/page2`);
-
-      expect(result.pages[0].content).toContain('Page 2');
-      expect(result.pages[0].content).toContain('This is page 2');
-    }, 30000);
-  });
-
-  describe('Response Validation', () => {
-    it('handles timeout correctly with real process', async () => {
-      // Test timeout mechanism with very short timeout
-      await expect(
-        bridge.crawl(baseUrl, 1) // 1ms timeout
-      ).rejects.toThrow('timeout');
-    }, 30000);
-
-    it('validates response has required fields', async () => {
-      const result = await bridge.crawl(`${baseUrl}/leaf`);
-
-      // Zod validation ensures these exist
-      expect(result).toHaveProperty('pages');
-      expect(result.pages[0]).toHaveProperty('url');
-      expect(result.pages[0]).toHaveProperty('title');
-      expect(result.pages[0]).toHaveProperty('content');
-      expect(result.pages[0]).toHaveProperty('links');
-      expect(result.pages[0]).toHaveProperty('crawledAt');
-    }, 30000);
-  });
-
-  describe('Error Handling', () => {
-    it('handles invalid URLs gracefully', async () => {
-      // Python worker should handle invalid URLs and return error
-      await expect(bridge.crawl('not-a-valid-url')).rejects.toThrow();
-    }, 30000);
-
-    it('handles 404 pages', async () => {
-      // Should not throw, but might return empty or error
-      const result = await bridge.crawl(`${baseUrl}/nonexistent`);
-
-      // Should complete with response
-      expect(result.pages).toBeDefined();
-    }, 30000);
-  });
-
-  describe('Content Variations', () => {
-    it('handles pages with multiple links', async () => {
-      const result = await bridge.crawl(`${baseUrl}/many-links`);
-
-      expect(result.pages[0].links.length).toBeGreaterThan(5);
-    }, 30000);
-
-    it('handles pages with no links', async () => {
-      const result = await bridge.crawl(`${baseUrl}/leaf`);
-
-      expect(result.pages[0].links).toBeDefined();
-      expect(result.pages[0].links).toBeInstanceOf(Array);
-      // May be empty or contain base URL
-    }, 30000);
-
-    it('handles special characters in content', async () => {
-      const result = await bridge.crawl(`${baseUrl}/special-chars`);
-
-      // Content should be properly decoded
-      expect(result.pages[0].content).toBeDefined();
-      expect(result.pages[0].title).toContain('Special');
-    }, 30000);
-  });
-});