@lmcc-dev/mult-fetch-mcp-server 1.2.0 → 1.3.0

package/dist/tests/test-direct-client.js

@@ -24,7 +24,8 @@ async function testDirectClient() {
             method: 'fetch_html',
             params: {
                 url: 'https://example.com',
-                debug: true
+                debug: true,
+                startCursor: 0
             }
         },
         {
@@ -32,7 +33,8 @@ async function testDirectClient() {
             method: 'fetch_json',
             params: {
                 url: 'https://jsonplaceholder.typicode.com/todos/1',
-                debug: true
+                debug: true,
+                startCursor: 0
             }
         },
         {
@@ -40,7 +42,8 @@ async function testDirectClient() {
             method: 'fetch_txt',
             params: {
                 url: 'https://example.com',
-                debug: true
+                debug: true,
+                startCursor: 0
             }
         },
         {
@@ -48,7 +51,28 @@ async function testDirectClient() {
             method: 'fetch_markdown',
             params: {
                 url: 'https://example.com',
-                debug: true
+                debug: true,
+                startCursor: 0
+            }
+        },
+        {
+            name: 'HTML 转纯文本测试',
+            method: 'fetch_plaintext',
+            params: {
+                url: 'https://example.com',
+                debug: true,
+                startCursor: 0
+            }
+        },
+        {
+            name: '分块测试 - 第一个分块',
+            method: 'fetch_html',
+            params: {
+                url: 'https://example.com',
+                debug: true,
+                contentSizeLimit: 2000,
+                enableContentSplitting: true,
+                startCursor: 0
             }
         },
         {
@@ -57,10 +81,14 @@ async function testDirectClient() {
             params: {
                 url: 'https://this-domain-does-not-exist-123456789.com',
                 debug: true,
-                timeout: 5000
+                timeout: 5000,
+                startCursor: 0
             }
         }
     ];
+    // 获取分块ID和字节位置，用于第二个分块测试
+    let chunkId = null;
+    let fetchedBytes = 0;
     // 依次执行每个测试用例
     for (const testCase of testCases) {
         console.log(`\n执行测试: ${testCase.name}`);
@@ -95,6 +123,86 @@ async function testDirectClient() {
         });
         // 输出结果
         console.log(`退出代码: ${result.code}`);
+        if (result.code === 0) {
+            console.log('测试成功!');
+            // 尝试解析JSON结果
+            try {
+                const jsonResult = JSON.parse(result.stdout);
+                console.log('结果类型:', typeof jsonResult);
+                if (typeof jsonResult === 'string') {
+                    console.log('内容长度:', jsonResult.length);
+                    console.log('内容预览:', jsonResult.substring(0, 200) + '...');
+                    // 如果是分块测试，获取分块ID和字节位置
+                    if (testCase.name === '分块测试 - 第一个分块') {
+                        const systemNoteMatch = jsonResult.match(/===\s*SYSTEM\s*NOTE\s*===.*?====================/s);
+                        if (systemNoteMatch) {
+                            console.log('检测到系统注释，表示有更多分块可用');
+                            const chunkIdMatch = systemNoteMatch[0].match(/chunkId:\s*"([^"]+)"/);
+                            const fetchedBytesMatch = systemNoteMatch[0].match(/fetchedBytes:\s*(\d+)/);
+                            if (chunkIdMatch && fetchedBytesMatch) {
+                                chunkId = chunkIdMatch[1];
+                                fetchedBytes = parseInt(fetchedBytesMatch[1]);
+                                console.log(`获取到 chunkId: ${chunkId}, fetchedBytes: ${fetchedBytes}`);
+                            }
+                        }
+                    }
+                }
+                else {
+                    console.log('结果:', JSON.stringify(jsonResult, null, 2));
+                }
+            }
+            catch (error) {
+                console.log('原始输出:');
+                console.log(result.stdout);
+            }
+        }
+        else {
+            console.error('测试失败!');
+            console.error('错误输出:');
+            console.error(result.stderr);
+        }
+    }
+    // 如果有分块ID，测试获取第二个分块
+    if (chunkId && fetchedBytes > 0) {
+        console.log(`\n执行测试: 分块测试 - 第二个分块`);
+        const clientPath = path.resolve(rootDir, 'dist/src/client.js');
+        const secondChunkParams = {
+            url: 'https://example.com',
+            debug: true,
+            contentSizeLimit: 2000,
+            enableContentSplitting: true,
+            chunkId: chunkId,
+            startCursor: fetchedBytes
+        };
+        const args = [
+            clientPath,
+            'fetch_html',
+            JSON.stringify(secondChunkParams)
+        ];
+        console.log(`运行命令: node ${args.join(' ')}`);
+        // 执行命令
+        const result = await new Promise((resolve) => {
+            const childProcess = spawn('node', args, {
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            childProcess.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            childProcess.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            childProcess.on('close', (code) => {
+                resolve({
+                    code: code || 0,
+                    stdout,
+                    stderr
+                });
+            });
+        });
+        // 输出结果
+        console.log(`退出代码: ${result.code}`);
         if (result.code === 0) {
             console.log('测试成功!');
             // 尝试解析JSON结果

package/dist/tests/test-mcp-methods.js

@@ -10,6 +10,8 @@ import { fileURLToPath } from 'url';
 // 获取当前文件的目录路径 (Get the directory path of the current file)
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+// 获取项目根目录 (Get the project root directory)
+const rootDir = process.cwd();
 /**
  * 测试 MCP 方法 (Test MCP methods)
  * 测试 resources/list 和 prompts/list 方法 (Test resources/list and prompts/list methods)
@@ -17,7 +19,7 @@ const __dirname = path.dirname(__filename);
 async function testMcpMethods() {
     console.log('开始测试 MCP 方法...\n');
     // 创建服务器进程 (Create server process)
-    const serverPath = path.resolve(path.dirname(__dirname), 'index.js');
+    const serverPath = path.resolve(rootDir, 'dist/index.js');
     console.log(`使用服务器路径: ${serverPath}`);
     // 创建客户端传输层 (Create client transport layer)
     const transport = new StdioClientTransport({
@@ -97,6 +99,70 @@ async function testMcpMethods() {
         catch (error) {
             console.error('prompts/get 测试失败:', error);
         }
+        // 测试 HTML 转纯文本功能 (Test HTML to plaintext conversion)
+        console.log('测试 HTML 转纯文本功能...');
+        try {
+            const plaintextResult = await client.callTool({
+                name: 'fetch_plaintext',
+                arguments: {
+                    url: 'https://example.com',
+                    debug: true,
+                    startCursor: 0
+                }
+            });
+            if (plaintextResult.isError) {
+                console.error('获取纯文本失败:', plaintextResult.content[0].text);
+            }
+            else {
+                console.log(`获取纯文本成功，内容长度: ${plaintextResult.content[0].text.length} 字节`);
+                console.log(`纯文本内容预览: ${plaintextResult.content[0].text.substring(0, 100)}...`);
+            }
+            console.log('HTML 转纯文本测试成功!\n');
+        }
+        catch (error) {
+            console.error('HTML 转纯文本测试失败:', error);
+        }
+        // 测试分块功能 (Test chunking functionality)
+        console.log('测试分块功能...');
+        try {
+            const chunkResult = await client.callTool({
+                name: 'fetch_html',
+                arguments: {
+                    url: 'https://example.com',
+                    debug: true,
+                    contentSizeLimit: 2000, // 设置较小的内容大小限制来触发分块
+                    startCursor: 0,
+                    enableContentSplitting: true
+                }
+            });
+            if (chunkResult.isError) {
+                console.error('分块测试失败:', chunkResult.content[0].text);
+            }
+            else {
+                console.log(`第一个分块获取成功，内容长度: ${chunkResult.content[0].text.length} 字节`);
+                // 检查是否有更多分块
+                const systemNoteMatch = chunkResult.content[0].text.match(/===\s*SYSTEM\s*NOTE\s*===.*?====================/s);
+                if (systemNoteMatch) {
+                    console.log('检测到系统注释，表示有更多分块可用');
+                    console.log(systemNoteMatch[0]);
+                    // 提取 chunkId 和 fetchedBytes
+                    const chunkIdMatch = systemNoteMatch[0].match(/chunkId:\s*"([^"]+)"/);
+                    const fetchedBytesMatch = systemNoteMatch[0].match(/fetchedBytes:\s*(\d+)/);
+                    if (chunkIdMatch && fetchedBytesMatch) {
+                        const chunkId = chunkIdMatch[1];
+                        const fetchedBytes = parseInt(fetchedBytesMatch[1]);
+                        console.log(`获取到 chunkId: ${chunkId}, fetchedBytes: ${fetchedBytes}`);
+                    }
+                }
+                else {
+                    console.log('没有检测到更多分块');
+                }
+            }
+            console.log('分块功能测试成功!\n');
+        }
+        catch (error) {
+            console.error('分块功能测试失败:', error);
+        }
     }
     catch (error) {
         console.error('测试过程中发生错误:', error);

package/dist/tests/test-mcp.js

@@ -69,7 +69,8 @@ async function testMCP() {
                 name: 'fetch_html',
                 arguments: {
                     url: 'https://example.com',
-                    debug: true
+                    debug: true,
+                    startCursor: 0
                 }
             });
             if (htmlResult.isError) {
@@ -86,7 +87,8 @@ async function testMCP() {
                 name: 'fetch_json',
                 arguments: {
                     url: 'https://jsonplaceholder.typicode.com/todos/1',
-                    debug: true
+                    debug: true,
+                    startCursor: 0
                 }
             });
             if (jsonResult.isError) {
@@ -95,6 +97,83 @@ async function testMCP() {
             else {
                 console.log(`获取 JSON 成功，内容: ${jsonResult.content[0].text}`);
             }
+            // 测试 fetch_plaintext 方法
+            console.log('\n测试 fetch_plaintext 方法...');
+            const plaintextResult = await client.callTool({
+                name: 'fetch_plaintext',
+                arguments: {
+                    url: 'https://example.com',
+                    debug: true,
+                    startCursor: 0
+                }
+            });
+            if (plaintextResult.isError) {
+                console.error('获取纯文本失败:', plaintextResult.content[0].text);
+            }
+            else {
+                console.log(`获取纯文本成功，内容长度: ${plaintextResult.content[0].text.length} 字节`);
+                console.log(`纯文本内容预览: ${plaintextResult.content[0].text.substring(0, 100)}...`);
+            }
+            console.log('');
+            // 测试分块获取功能
+            console.log('\n测试分块获取功能...');
+            // 设置较小的 contentSizeLimit 触发分块
+            const chunkTestResult = await client.callTool({
+                name: 'fetch_html',
+                arguments: {
+                    url: 'https://example.com',
+                    debug: true,
+                    contentSizeLimit: 2000, // 设置较小的内容大小限制来触发分块
+                    startCursor: 0,
+                    enableContentSplitting: true
+                }
+            });
+            if (chunkTestResult.isError) {
+                console.error('分块测试失败:', chunkTestResult.content[0].text);
+            }
+            else {
+                console.log('第一个分块获取成功:');
+                console.log(`内容长度: ${chunkTestResult.content[0].text.length} 字节`);
+                console.log(`内容预览: ${chunkTestResult.content[0].text.substring(0, 100)}...`);
+                // 检查是否包含系统注释，表示有更多分块
+                const systemNoteMatch = chunkTestResult.content[0].text.match(/===\s*SYSTEM\s*NOTE\s*===.*?====================/s);
+                if (systemNoteMatch) {
+                    console.log('检测到系统注释，表示有更多分块可用');
+                    console.log(systemNoteMatch[0]);
+                    // 提取 chunkId 和 fetchedBytes
+                    const chunkIdMatch = systemNoteMatch[0].match(/chunkId:\s*"([^"]+)"/);
+                    const fetchedBytesMatch = systemNoteMatch[0].match(/fetchedBytes:\s*(\d+)/);
+                    if (chunkIdMatch && fetchedBytesMatch) {
+                        const chunkId = chunkIdMatch[1];
+                        const fetchedBytes = parseInt(fetchedBytesMatch[1]);
+                        console.log(`获取到 chunkId: ${chunkId}, fetchedBytes: ${fetchedBytes}`);
+                        // 获取下一个分块
+                        console.log('\n获取下一个分块...');
+                        const nextChunkResult = await client.callTool({
+                            name: 'fetch_html',
+                            arguments: {
+                                url: 'https://example.com',
+                                debug: true,
+                                chunkId: chunkId,
+                                startCursor: fetchedBytes,
+                                contentSizeLimit: 2000,
+                                enableContentSplitting: true
+                            }
+                        });
+                        if (nextChunkResult.isError) {
+                            console.error('获取下一个分块失败:', nextChunkResult.content[0].text);
+                        }
+                        else {
+                            console.log('下一个分块获取成功:');
+                            console.log(`内容长度: ${nextChunkResult.content[0].text.length} 字节`);
+                            console.log(`内容预览: ${nextChunkResult.content[0].text.substring(0, 100)}...`);
+                        }
+                    }
+                }
+                else {
+                    console.log('没有检测到更多分块，内容可能小于设置的限制或分块功能未正确工作');
+                }
+            }
             // 关闭浏览器实例（如果有的话）
             console.log('\n关闭浏览器实例...');
             await client.callTool({
@@ -103,7 +182,8 @@ async function testMCP() {
                     url: 'about:blank',
                     debug: true,
                     useBrowser: true,
-                    closeBrowser: true
+                    closeBrowser: true,
+                    startCursor: 0
                 }
             });
             console.log('\n所有测试完成!');

package/dist/tests/test-mini4k.js

@@ -65,7 +65,8 @@ async function testMini4k() {
                     debug: true,
                     timeout: 30000,
                     waitForTimeout: 3000,
-                    scrollToBottom: false // 禁用滚动到底部
+                    scrollToBottom: false, // 禁用滚动到底部
+                    startCursor: 0
                 }
             });
             console.log(`标准模式结果 - 是否错误: ${standardResult.isError}`);
@@ -86,7 +87,8 @@ async function testMini4k() {
                     useBrowser: true,
                     timeout: 30000,
                     waitForTimeout: 3000,
-                    scrollToBottom: false // 禁用滚动到底部
+                    scrollToBottom: false, // 禁用滚动到底部
+                    startCursor: 0
                 }
             });
             console.log(`浏览器模式结果 - 是否错误: ${browserResult.isError}`);
@@ -97,6 +99,90 @@ async function testMini4k() {
             else if (browserResult.isError) {
                 console.log(`浏览器模式错误: ${browserResult.content[0].text}`);
             }
+            // 测试 HTML 转纯文本功能
+            console.log('\n测试 HTML 转纯文本功能...');
+            const plaintextResult = await client.callTool({
+                name: 'fetch_plaintext',
+                arguments: {
+                    url: 'https://mini4k.com',
+                    debug: true,
+                    useBrowser: true, // 使用浏览器模式，因为标准模式可能会失败
+                    timeout: 30000,
+                    waitForTimeout: 3000,
+                    startCursor: 0
+                }
+            });
+            console.log(`纯文本结果 - 是否错误: ${plaintextResult.isError}`);
+            if (!plaintextResult.isError && plaintextResult.content && plaintextResult.content[0]) {
+                console.log(`纯文本内容长度: ${plaintextResult.content[0].text.length} 字节`);
+                console.log(`纯文本内容预览: ${plaintextResult.content[0].text.substring(0, 200)}...`);
+            }
+            else if (plaintextResult.isError) {
+                console.log(`纯文本错误: ${plaintextResult.content[0].text}`);
+            }
+            // 测试分块功能
+            console.log('\n测试分块功能...');
+            const chunkResult = await client.callTool({
+                name: 'fetch_html',
+                arguments: {
+                    url: 'https://mini4k.com',
+                    debug: true,
+                    useBrowser: true,
+                    timeout: 30000,
+                    waitForTimeout: 3000,
+                    contentSizeLimit: 3000, // 设置较小的内容大小限制来触发分块
+                    startCursor: 0,
+                    enableContentSplitting: true
+                }
+            });
+            console.log(`分块结果 - 是否错误: ${chunkResult.isError}`);
+            if (!chunkResult.isError && chunkResult.content && chunkResult.content[0]) {
+                console.log(`第一个分块内容长度: ${chunkResult.content[0].text.length} 字节`);
+                console.log(`第一个分块内容预览: ${chunkResult.content[0].text.substring(0, 100)}...`);
+                // 检查是否有更多分块
+                const systemNoteMatch = chunkResult.content[0].text.match(/===\s*SYSTEM\s*NOTE\s*===.*?====================/s);
+                if (systemNoteMatch) {
+                    console.log('检测到系统注释，表示有更多分块可用');
+                    console.log(systemNoteMatch[0]);
+                    // 提取 chunkId 和 fetchedBytes
+                    const chunkIdMatch = systemNoteMatch[0].match(/chunkId:\s*"([^"]+)"/);
+                    const fetchedBytesMatch = systemNoteMatch[0].match(/fetchedBytes:\s*(\d+)/);
+                    if (chunkIdMatch && fetchedBytesMatch) {
+                        const chunkId = chunkIdMatch[1];
+                        const fetchedBytes = parseInt(fetchedBytesMatch[1]);
+                        console.log(`获取到 chunkId: ${chunkId}, fetchedBytes: ${fetchedBytes}`);
+                        // 获取第二个分块
+                        console.log('\n获取第二个分块...');
+                        const secondChunkResult = await client.callTool({
+                            name: 'fetch_html',
+                            arguments: {
+                                url: 'https://mini4k.com',
+                                debug: true,
+                                useBrowser: true,
+                                timeout: 30000,
+                                chunkId: chunkId,
+                                startCursor: fetchedBytes,
+                                contentSizeLimit: 3000,
+                                enableContentSplitting: true
+                            }
+                        });
+                        console.log(`第二个分块结果 - 是否错误: ${secondChunkResult.isError}`);
+                        if (!secondChunkResult.isError && secondChunkResult.content && secondChunkResult.content[0]) {
+                            console.log(`第二个分块内容长度: ${secondChunkResult.content[0].text.length} 字节`);
+                            console.log(`第二个分块内容预览: ${secondChunkResult.content[0].text.substring(0, 100)}...`);
+                        }
+                        else if (secondChunkResult.isError) {
+                            console.log(`第二个分块错误: ${secondChunkResult.content[0].text}`);
+                        }
+                    }
+                }
+                else {
+                    console.log('没有检测到更多分块');
+                }
+            }
+            else if (chunkResult.isError) {
+                console.log(`分块错误: ${chunkResult.content[0].text}`);
+            }
             // 关闭浏览器实例
             console.log('\n关闭浏览器实例...');
             await client.callTool({
@@ -105,7 +191,8 @@ async function testMini4k() {
                     url: 'about:blank',
                     debug: true,
                     useBrowser: true,
-                    closeBrowser: true
+                    closeBrowser: true,
+                    startCursor: 0
                 }
             });
             console.log('\n所有测试完成!');

package/dist/tests/utils/ChunkManager.test.js

@@ -0,0 +1,163 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { ChunkManager } from '../../src/lib/utils/ChunkManager.js';
+// 模拟logger
+vi.mock('../../src/lib/logger.js', () => ({
+    log: vi.fn(),
+    COMPONENTS: {
+        CHUNK_MANAGER: 'chunk-manager'
+    }
+}));
+// 模拟uuid 
+vi.mock('uuid', () => ({
+    v4: vi.fn().mockReturnValue('test-uuid')
+}));
+describe('ChunkManager 测试 (ChunkManager Tests)', () => {
+    beforeEach(() => {
+        // 清理mocks
+        vi.clearAllMocks();
+        // 重置ChunkManager的静态属性
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['chunks'] = new Map();
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['expirations'] = new Map();
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['sizeInfo'] = new Map();
+    });
+    test('storeChunks应正确存储分块内容和大小信息 (storeChunks should correctly store chunked content and size information)', () => {
+        // 测试数据
+        const chunks = ['chunk1', 'chunk2', 'chunk3'];
+        const totalBytes = 1000;
+        // Mock Buffer.byteLength 以返回固定的字节大小
+        const originalByteLength = Buffer.byteLength;
+        global.Buffer.byteLength = vi.fn()
+            .mockReturnValueOnce(200) // chunk1
+            .mockReturnValueOnce(300) // chunk2
+            .mockReturnValueOnce(500); // chunk3
+        // 调用测试方法
+        const chunkId = ChunkManager.storeChunks(chunks, totalBytes);
+        // 恢复原始函数
+        global.Buffer.byteLength = originalByteLength;
+        // 验证返回的chunkId
+        expect(chunkId).toBe('test-uuid');
+        // 验证内容被正确存储
+        // @ts-ignore - 访问私有属性用于测试
+        expect(ChunkManager['chunks'].get(chunkId)).toEqual(chunks);
+        // 验证大小信息被正确存储
+        // @ts-ignore - 访问私有属性用于测试
+        expect(ChunkManager['sizeInfo'].get(chunkId)).toEqual({
+            totalBytes: 1000,
+            fetchedBytes: [200, 300, 500]
+        });
+        // 验证过期时间被设置
+        // @ts-ignore - 访问私有属性用于测试
+        expect(ChunkManager['expirations'].has(chunkId)).toBe(true);
+    });
+    test('getChunkBySize应返回正确的分块内容和大小信息 (getChunkBySize should return correct chunk content and size information)', () => {
+        // 准备测试数据
+        const chunks = ['chunk1', 'chunk2', 'chunk3'];
+        const chunkId = 'test-chunk-id';
+        const fetchedBytes = [100, 200, 300];
+        const totalBytes = 600;
+        // 手动设置内部状态
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['chunks'].set(chunkId, chunks);
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['sizeInfo'].set(chunkId, { totalBytes, fetchedBytes });
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['expirations'].set(chunkId, Date.now() + 60000); // 设置为未过期
+        // 使用startCursor=0获取从头开始的内容
+        const resultStart = ChunkManager.getChunkBySize(chunkId, 0, 200);
+        // 验证从头开始的结果
+        expect(resultStart).not.toBeNull();
+        expect(resultStart?.content).toBe('chunk1chunk2');
+        expect(resultStart?.fetchedBytes).toBe(300);
+        expect(resultStart?.remainingBytes).toBe(300);
+        expect(resultStart?.isLastChunk).toBe(false);
+        expect(resultStart?.totalBytes).toBe(600);
+        // 使用startCursor=300获取从中间开始的内容
+        const resultMiddle = ChunkManager.getChunkBySize(chunkId, 300, 300);
+        // 验证从中间开始的结果
+        expect(resultMiddle).not.toBeNull();
+        expect(resultMiddle?.content).toBe('chunk3');
+        expect(resultMiddle?.fetchedBytes).toBe(600);
+        expect(resultMiddle?.remainingBytes).toBe(0);
+        expect(resultMiddle?.isLastChunk).toBe(true);
+        expect(resultMiddle?.totalBytes).toBe(600);
+    });
+    test('getChunkBySize应处理无效chunkId和startCursor (getChunkBySize should handle invalid chunkId and startCursor)', () => {
+        // 无效的chunkId
+        expect(ChunkManager.getChunkBySize('non-existent-id', 0)).toBeNull();
+        // 准备测试数据
+        const chunks = ['chunk1', 'chunk2', 'chunk3'];
+        const chunkId = 'test-chunk-id';
+        const fetchedBytes = [100, 200, 300];
+        const totalBytes = 600;
+        // 设置内部状态
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['chunks'].set(chunkId, chunks);
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['sizeInfo'].set(chunkId, { totalBytes, fetchedBytes });
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['expirations'].set(chunkId, Date.now() + 60000); // 设置为未过期
+        // 无效的startCursor - 负数
+        expect(ChunkManager.getChunkBySize(chunkId, -1)).toBeNull();
+        // 无效的startCursor - 超出总字节数
+        expect(ChunkManager.getChunkBySize(chunkId, 700)).toBeNull();
+    });
+    test('getSizeInfo应返回正确的大小信息 (getSizeInfo should return correct size information)', () => {
+        // 准备测试数据
+        const chunkId = 'test-chunk-id';
+        const fetchedBytes = [100, 200, 300];
+        const totalBytes = 600;
+        // 设置内部状态
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['sizeInfo'].set(chunkId, { totalBytes, fetchedBytes });
+        // 获取大小信息
+        const sizeInfo = ChunkManager.getSizeInfo(chunkId);
+        // 验证结果
+        expect(sizeInfo).not.toBeNull();
+        expect(sizeInfo?.totalBytes).toBe(600);
+        expect(sizeInfo?.fetchedBytes).toEqual([100, 200, 300]);
+        // 测试无效的chunkId
+        expect(ChunkManager.getSizeInfo('non-existent-id')).toBeNull();
+    });
+    test('cleanupExpiredChunks应清理过期的分块和大小信息 (cleanupExpiredChunks should clean up expired chunks and size information)', () => {
+        // 准备测试数据：过期的分块
+        const expiredChunkId = 'expired-chunk-id';
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['chunks'].set(expiredChunkId, ['expired-chunk']);
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['sizeInfo'].set(expiredChunkId, { totalBytes: 100, fetchedBytes: [100] });
+        // @ts-ignore - 设置为过期时间（过去的时间）
+        ChunkManager['expirations'].set(expiredChunkId, Date.now() - 1000);
+        // 准备测试数据：未过期的分块
+        const validChunkId = 'valid-chunk-id';
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['chunks'].set(validChunkId, ['valid-chunk']);
+        // @ts-ignore - 访问私有属性用于测试
+        ChunkManager['sizeInfo'].set(validChunkId, { totalBytes: 200, fetchedBytes: [200] });
+        // @ts-ignore - 设置为未过期时间（未来的时间）
+        ChunkManager['expirations'].set(validChunkId, Date.now() + 60000);
+        // 执行清理
+        // @ts-ignore - 访问私有方法用于测试
+        ChunkManager['cleanupExpiredChunks']();
+        // 验证结果：过期的分块应该被删除，未过期的分块仍然存在
+        // @ts-ignore - 访问私有属性用于测试
+        expect(ChunkManager['chunks'].has(expiredChunkId)).toBe(false);
+        // @ts-ignore - 访问私有属性用于测试
+        expect(ChunkManager['sizeInfo'].has(expiredChunkId)).toBe(false);
+        // @ts-ignore - 访问私有属性用于测试
+        expect(ChunkManager['expirations'].has(expiredChunkId)).toBe(false);
+        // @ts-ignore - 访问私有属性用于测试
+        expect(ChunkManager['chunks'].has(validChunkId)).toBe(true);
+        // @ts-ignore - 访问私有属性用于测试
+        expect(ChunkManager['sizeInfo'].has(validChunkId)).toBe(true);
+        // @ts-ignore - 访问私有属性用于测试
+        expect(ChunkManager['expirations'].has(validChunkId)).toBe(true);
+    });
+});