@cosmocoder/mcp-web-docs 2.0.11 → 2.0.12

package/build/index.test.js

@@ -1,65 +1,102 @@
+import { setImmediate as nextTurn } from 'node:timers/promises';
 import { isValidPublicUrl } from './config.js';
-import { validateToolArgs, AddDocumentationArgsSchema, SearchDocumentationArgsSchema, SetTagsArgsSchema, detectPromptInjection, wrapExternalContent, addInjectionWarnings, sanitizeErrorMessage, } from './util/security.js';
+import { validateToolArgs, AddDocumentationArgsSchema, SearchDocumentationArgsSchema, SetTagsArgsSchema, detectPromptInjection, wrapExternalContent, addInjectionWarnings, sanitizeErrorMessage, SessionExpiredError, } from './util/security.js';
 import { generateDocId } from './util/docs.js';
 import { IndexingStatusTracker } from './indexing/status.js';
-import { IndexingQueueManager } from './indexing/queue-manager.js';
+const { mockCrawlerAbort, mockCrawlerCrawl, mockClearSession, mockFetchFavicon, mockNotification, mockProcessorProcess, mockRunLatest, mockStoreAddDocument, mockStoreGetDocument, requestHandlers, } = vi.hoisted(() => ({
+    mockCrawlerAbort: vi.fn(),
+    mockCrawlerCrawl: vi.fn().mockImplementation(async function* () {
+        yield { url: 'https://example.com', path: '/', content: '<h1>Test</h1>', title: 'Test' };
+    }),
+    mockClearSession: vi.fn().mockResolvedValue(undefined),
+    mockFetchFavicon: vi.fn().mockResolvedValue('https://example.com/favicon.ico'),
+    mockNotification: vi.fn().mockResolvedValue(undefined),
+    mockProcessorProcess: vi.fn().mockResolvedValue({
+        metadata: { url: 'https://example.com', title: 'Test', lastIndexed: new Date() },
+        chunks: [],
+    }),
+    mockRunLatest: vi.fn(),
+    mockStoreAddDocument: vi.fn().mockResolvedValue(undefined),
+    mockStoreGetDocument: vi.fn().mockResolvedValue(null),
+    requestHandlers: [],
+}));
+mockRunLatest.mockImplementation(async (_url, operation) => {
+    const completion = Promise.resolve().then(() => operation(new AbortController().signal));
+    return { completion, replacedExisting: false };
+});
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
-    McpServer: vi.fn().mockImplementation(() => ({
-        server: {
-            setRequestHandler: vi.fn(),
-            notification: vi.fn().mockResolvedValue(undefined),
-            onerror: null,
-        },
-        connect: vi.fn().mockResolvedValue(undefined),
-    })),
+    McpServer: vi.fn().mockImplementation(function () {
+        return {
+            server: {
+                setRequestHandler: vi.fn((_schema, handler) => {
+                    requestHandlers.push(handler);
+                }),
+                notification: mockNotification,
+                onerror: null,
+            },
+            connect: vi.fn().mockResolvedValue(undefined),
+        };
+    }),
 }));
 vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
     StdioServerTransport: vi.fn(),
 }));
 vi.mock('./storage/storage.js', () => ({
-    DocumentStore: vi.fn().mockImplementation(() => ({
-        initialize: vi.fn().mockResolvedValue(undefined),
-        listDocuments: vi.fn().mockResolvedValue([]),
-        getDocument: vi.fn().mockResolvedValue(null),
-        searchByText: vi.fn().mockResolvedValue([]),
-        addDocument: vi.fn().mockResolvedValue(undefined),
-        deleteDocument: vi.fn().mockResolvedValue(undefined),
-        setTags: vi.fn().mockResolvedValue(undefined),
-        listAllTags: vi.fn().mockResolvedValue([]),
-    })),
+    DocumentStore: vi.fn().mockImplementation(function () {
+        return {
+            initialize: vi.fn().mockResolvedValue(undefined),
+            listDocuments: vi.fn().mockResolvedValue([]),
+            getDocument: mockStoreGetDocument,
+            searchByText: vi.fn().mockResolvedValue([]),
+            addDocument: mockStoreAddDocument,
+            deleteDocument: vi.fn().mockResolvedValue(undefined),
+            setTags: vi.fn().mockResolvedValue(undefined),
+            listAllTags: vi.fn().mockResolvedValue([]),
+        };
+    }),
+}));
+vi.mock('./indexing/queue-manager.js', () => ({
+    IndexingQueueManager: function () {
+        return {
+            runLatest: mockRunLatest,
+        };
+    },
 }));
 vi.mock('./embeddings/fastembed.js', () => ({
-    FastEmbeddings: vi.fn().mockImplementation(() => ({
-        dimensions: 384,
-        embed: vi.fn().mockResolvedValue(new Array(384).fill(0)),
-    })),
+    FastEmbeddings: vi.fn().mockImplementation(function () {
+        return {
+            dimensions: 384,
+            embed: vi.fn().mockResolvedValue(new Array(384).fill(0)),
+        };
+    }),
 }));
 vi.mock('./processor/processor.js', () => ({
-    WebDocumentProcessor: vi.fn().mockImplementation(() => ({
-        process: vi.fn().mockResolvedValue({
-            metadata: { url: 'https://example.com', title: 'Test', lastIndexed: new Date() },
-            chunks: [],
-        }),
-    })),
+    WebDocumentProcessor: vi.fn().mockImplementation(function () {
+        return {
+            process: mockProcessorProcess,
+        };
+    }),
 }));
 vi.mock('./crawler/docs-crawler.js', () => ({
-    DocsCrawler: vi.fn().mockImplementation(() => ({
-        crawl: vi.fn().mockImplementation(async function* () {
-            yield { url: 'https://example.com', path: '/', content: '<h1>Test</h1>', title: 'Test' };
-        }),
-        abort: vi.fn(),
-        setStorageState: vi.fn(),
-    })),
+    DocsCrawler: vi.fn().mockImplementation(function () {
+        return {
+            crawl: mockCrawlerCrawl,
+            abort: mockCrawlerAbort,
+            setStorageState: vi.fn(),
+        };
+    }),
 }));
 vi.mock('./crawler/auth.js', () => ({
-    AuthManager: vi.fn().mockImplementation(() => ({
-        initialize: vi.fn().mockResolvedValue(undefined),
-        hasSession: vi.fn().mockResolvedValue(false),
-        loadSession: vi.fn().mockResolvedValue(null),
-        clearSession: vi.fn().mockResolvedValue(undefined),
-        performInteractiveLogin: vi.fn().mockResolvedValue(undefined),
-        validateSession: vi.fn().mockResolvedValue({ isValid: true }),
-    })),
+    AuthManager: vi.fn().mockImplementation(function () {
+        return {
+            initialize: vi.fn().mockResolvedValue(undefined),
+            hasSession: vi.fn().mockResolvedValue(false),
+            loadSession: vi.fn().mockResolvedValue(null),
+            clearSession: mockClearSession,
+            performInteractiveLogin: vi.fn().mockResolvedValue(undefined),
+            validateSession: vi.fn().mockResolvedValue({ isValid: true }),
+        };
+    }),
 }));
 vi.mock('./config.js', () => ({
     loadConfig: vi.fn().mockResolvedValue({
@@ -75,7 +112,7 @@ vi.mock('./config.js', () => ({
     normalizeUrl: vi.fn().mockImplementation((url) => url.replace(/\/$/, '')),
 }));
 vi.mock('./util/favicon.js', () => ({
-    fetchFavicon: vi.fn().mockResolvedValue('https://example.com/favicon.ico'),
+    fetchFavicon: mockFetchFavicon,
 }));
 vi.mock('./util/docs.js', () => ({
     generateDocId: vi.fn().mockImplementation((url) => {
@@ -88,10 +125,390 @@ vi.mock('crawlee', () => ({
     Configuration: { getGlobalConfig: vi.fn().mockReturnValue({ set: vi.fn() }) },
     Dataset: { open: vi.fn().mockResolvedValue({ drop: vi.fn() }) },
 }));
+const processedPageWithChunk = {
+    metadata: { url: 'https://example.com', title: 'Test', lastIndexed: new Date() },
+    chunks: [
+        {
+            content: 'content',
+            url: 'https://example.com',
+            title: 'Test',
+            path: '/',
+            startLine: 1,
+            endLine: 1,
+            vector: [0],
+            metadata: { type: 'overview' },
+        },
+    ],
+};
 describe('WebDocsServer', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('operation lifecycle integration', () => {
+        let toolHandler;
+        beforeAll(async () => {
+            requestHandlers.length = 0;
+            await import('./index.js');
+            await nextTurn();
+            toolHandler = requestHandlers.at(-1);
+        });
+        it('does not start or notify a rejected operation before admitting its tokenless successor', async () => {
+            const startIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'startIndexing');
+            let successorCompletion;
+            mockRunLatest
+                .mockRejectedValueOnce(new Error('replacement cancellation timed out'))
+                .mockImplementationOnce(async (_url, operation) => {
+                successorCompletion = Promise.resolve().then(() => operation(new AbortController().signal));
+                return { completion: successorCompletion, replacedExisting: false };
+            });
+            try {
+                await expect(toolHandler({
+                    params: {
+                        name: 'add_documentation',
+                        arguments: { url: 'https://example.com', _meta: { progressToken: 'rejected-token' } },
+                    },
+                })).rejects.toThrow('replacement cancellation timed out');
+                expect(startIndexing).not.toHaveBeenCalled();
+                await toolHandler({ params: { name: 'add_documentation', arguments: { url: 'https://example.com' } } });
+                await successorCompletion;
+                expect(startIndexing).toHaveBeenCalledOnce();
+                expect(mockNotification.mock.calls.some(([notification]) => notification.params?.progressToken === 'rejected-token')).toBe(false);
+            }
+            finally {
+                await Promise.allSettled(successorCompletion ? [successorCompletion] : []);
+            }
+        });
+        it.each([
+            {
+                name: 'keeps successor progress state when an old terminal notification finishes late',
+                firstToken: 'same-token',
+                secondToken: 'same-token',
+            },
+            {
+                name: 'does not reuse an old progress token when its tokenless successor starts',
+                firstToken: 'old-token',
+                secondToken: undefined,
+            },
+        ])('$name', async ({ firstToken, secondToken }) => {
+            const startIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'startIndexing');
+            const firstStoreLookup = Promise.withResolvers();
+            const secondStoreLookup = Promise.withResolvers();
+            const oldTerminalNotification = Promise.withResolvers();
+            const oldTerminalStarted = Promise.withResolvers();
+            const successorProgressed = Promise.withResolvers();
+            const releaseSuccessorCrawl = Promise.withResolvers();
+            mockStoreGetDocument.mockReturnValueOnce(firstStoreLookup.promise).mockReturnValueOnce(secondStoreLookup.promise);
+            mockCrawlerCrawl.mockImplementationOnce(async function* () {
+                yield { url: 'https://example.com', path: '/', content: '<h1>Test</h1>', title: 'Test' };
+                successorProgressed.resolve();
+                await releaseSuccessorCrawl.promise;
+            });
+            mockNotification.mockImplementation(async (notification) => {
+                if (notification.params?.message?.startsWith('Cancelled -')) {
+                    oldTerminalStarted.resolve();
+                    await oldTerminalNotification.promise;
+                }
+            });
+            let active;
+            const completions = [];
+            const runLatest = async (_url, operation) => {
+                const previous = active;
+                if (previous) {
+                    previous.controller.abort();
+                    await previous.completion;
+                }
+                const controller = new AbortController();
+                const completion = Promise.resolve().then(() => operation(controller.signal));
+                completions.push(completion);
+                active = { controller, completion };
+                return { completion, replacedExisting: previous !== undefined };
+            };
+            mockRunLatest.mockImplementationOnce(runLatest).mockImplementationOnce(runLatest);
+            try {
+                await toolHandler({
+                    params: {
+                        name: 'add_documentation',
+                        arguments: { url: 'https://example.com', _meta: { progressToken: firstToken } },
+                    },
+                });
+                await nextTurn();
+                expect(startIndexing).toHaveBeenCalledOnce();
+                const replacementResponse = toolHandler({
+                    params: {
+                        name: 'add_documentation',
+                        arguments: secondToken ? { url: 'https://example.com', _meta: { progressToken: secondToken } } : { url: 'https://example.com' },
+                    },
+                });
+                await nextTurn();
+                firstStoreLookup.resolve();
+                await oldTerminalStarted.promise;
+                await replacementResponse;
+                await nextTurn();
+                expect(startIndexing).toHaveBeenCalledTimes(2);
+                const notificationsAtSuccessorBoundary = mockNotification.mock.calls.length;
+                oldTerminalNotification.resolve();
+                await nextTurn();
+                secondStoreLookup.resolve();
+                await successorProgressed.promise;
+                releaseSuccessorCrawl.resolve();
+                await active.completion;
+                if (secondToken) {
+                    const successorNotifications = mockNotification.mock.calls
+                        .slice(notificationsAtSuccessorBoundary)
+                        .map(([notification]) => notification.params);
+                    expect(successorNotifications).toEqual(expect.arrayContaining([
+                        expect.objectContaining({ progressToken: secondToken, message: expect.stringContaining('Finding subpages') }),
+                        expect.objectContaining({ progressToken: secondToken, message: expect.stringContaining('No content was extracted') }),
+                    ]));
+                }
+                else {
+                    expect(mockNotification.mock.calls
+                        .slice(notificationsAtSuccessorBoundary)
+                        .some(([notification]) => notification.params?.progressToken === firstToken)).toBe(false);
+                }
+            }
+            finally {
+                firstStoreLookup.resolve();
+                secondStoreLookup.resolve();
+                oldTerminalNotification.resolve();
+                releaseSuccessorCrawl.resolve();
+                await Promise.allSettled(completions);
+                mockNotification.mockResolvedValue(undefined);
+            }
+        });
+        it('reports cancellation when an aborted crawler rejects with an ordinary error', async () => {
+            const enteredCrawl = Promise.withResolvers();
+            const releaseCrawl = Promise.withResolvers();
+            mockCrawlerCrawl.mockImplementationOnce(async function* () {
+                yield* [];
+                enteredCrawl.resolve();
+                await releaseCrawl.promise;
+                throw new Error('crawler stopped');
+            });
+            const cancelIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'cancelIndexing');
+            const failIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'failIndexing');
+            const controller = new AbortController();
+            let completion;
+            mockRunLatest.mockImplementationOnce(async (_url, operation) => {
+                completion = Promise.resolve().then(() => operation(controller.signal));
+                return { completion, replacedExisting: false };
+            });
+            try {
+                await toolHandler({ params: { name: 'add_documentation', arguments: { url: 'https://example.com' } } });
+                await enteredCrawl.promise;
+                controller.abort();
+                releaseCrawl.resolve();
+                await completion;
+                expect(cancelIndexing).toHaveBeenCalledOnce();
+                expect(failIndexing).not.toHaveBeenCalled();
+            }
+            finally {
+                releaseCrawl.resolve();
+                await Promise.allSettled(completion ? [completion] : []);
+            }
+        });
+        it('cancels instead of failing when abort arrives while an expired session is being cleared', async () => {
+            const clearSession = Promise.withResolvers();
+            const clearSessionStarted = Promise.withResolvers();
+            const controller = new AbortController();
+            const cancelIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'cancelIndexing');
+            const failIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'failIndexing');
+            let completion;
+            mockCrawlerCrawl.mockImplementationOnce(async function* () {
+                yield* [];
+                throw new SessionExpiredError('session expired', 'https://example.com', 'https://example.com/login', {
+                    isLoginPage: true,
+                    confidence: 1,
+                    reasons: ['login page'],
+                });
+            });
+            mockClearSession.mockImplementationOnce(() => {
+                clearSessionStarted.resolve();
+                return clearSession.promise;
+            });
+            mockRunLatest.mockImplementationOnce(async (_url, operation) => {
+                completion = Promise.resolve().then(() => operation(controller.signal));
+                return { completion, replacedExisting: false };
+            });
+            try {
+                await toolHandler({
+                    params: {
+                        name: 'add_documentation',
+                        arguments: { url: 'https://example.com', _meta: { progressToken: 'expired-session-token' } },
+                    },
+                });
+                await clearSessionStarted.promise;
+                controller.abort();
+                clearSession.resolve();
+                await Promise.allSettled([completion]);
+                await nextTurn();
+                expect(cancelIndexing).toHaveBeenCalledOnce();
+                expect(failIndexing).not.toHaveBeenCalled();
+                expect(mockNotification.mock.calls.some(([notification]) => notification.params?.progressToken === 'expired-session-token' && notification.params?.message?.startsWith('Cancelled -'))).toBe(true);
+                expect(mockNotification.mock.calls.some(([notification]) => notification.params?.message?.includes('Authentication session has expired'))).toBe(false);
+            }
+            finally {
+                controller.abort();
+                clearSession.resolve();
+                await Promise.allSettled(completion ? [completion] : []);
+            }
+        });
+        it('cancels instead of completing an existing add after its document lookup resolves', async () => {
+            const lookup = Promise.withResolvers();
+            const lookupStarted = Promise.withResolvers();
+            const controller = new AbortController();
+            const cancelIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'cancelIndexing');
+            const completeIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'completeIndexing');
+            const failIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'failIndexing');
+            let completion;
+            mockStoreGetDocument.mockImplementationOnce(() => {
+                lookupStarted.resolve();
+                return lookup.promise;
+            });
+            mockRunLatest.mockImplementationOnce(async (_url, operation) => {
+                completion = Promise.resolve().then(() => operation(controller.signal));
+                return { completion, replacedExisting: false };
+            });
+            try {
+                await toolHandler({ params: { name: 'add_documentation', arguments: { url: 'https://example.com' } } });
+                await lookupStarted.promise;
+                controller.abort();
+                lookup.resolve({ url: 'https://example.com', title: 'Existing', lastIndexed: new Date() });
+                await completion;
+                expect(cancelIndexing).toHaveBeenCalledOnce();
+                expect(completeIndexing).not.toHaveBeenCalled();
+                expect(failIndexing).not.toHaveBeenCalled();
+                expect(mockCrawlerCrawl).not.toHaveBeenCalled();
+            }
+            finally {
+                lookup.resolve({ url: 'https://example.com', title: 'Existing', lastIndexed: new Date() });
+                await Promise.allSettled(completion ? [completion] : []);
+            }
+        });
+        it('does not store a document when cancellation arrives during favicon lookup', async () => {
+            const favicon = Promise.withResolvers();
+            const faviconStarted = Promise.withResolvers();
+            const controller = new AbortController();
+            const cancelIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'cancelIndexing');
+            const completeIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'completeIndexing');
+            const failIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'failIndexing');
+            let completion;
+            mockProcessorProcess.mockResolvedValueOnce(processedPageWithChunk);
+            mockFetchFavicon.mockImplementationOnce(() => {
+                faviconStarted.resolve();
+                return favicon.promise;
+            });
+            mockRunLatest.mockImplementationOnce(async (_url, operation) => {
+                completion = Promise.resolve().then(() => operation(controller.signal));
+                return { completion, replacedExisting: false };
+            });
+            try {
+                await toolHandler({ params: { name: 'add_documentation', arguments: { url: 'https://example.com' } } });
+                await faviconStarted.promise;
+                controller.abort();
+                favicon.resolve(null);
+                await completion;
+                expect(cancelIndexing).toHaveBeenCalledOnce();
+                expect(mockStoreAddDocument).not.toHaveBeenCalled();
+                expect(completeIndexing).not.toHaveBeenCalled();
+                expect(failIndexing).not.toHaveBeenCalled();
+            }
+            finally {
+                favicon.resolve(null);
+                await Promise.allSettled(completion ? [completion] : []);
+            }
+        });
+        it('does not complete when cancellation arrives during document storage', async () => {
+            const add = Promise.withResolvers();
+            const addStarted = Promise.withResolvers();
+            const controller = new AbortController();
+            const cancelIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'cancelIndexing');
+            const completeIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'completeIndexing');
+            const failIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'failIndexing');
+            let completion;
+            mockProcessorProcess.mockResolvedValueOnce(processedPageWithChunk);
+            mockStoreAddDocument.mockImplementationOnce(() => {
+                addStarted.resolve();
+                return add.promise;
+            });
+            mockRunLatest.mockImplementationOnce(async (_url, operation) => {
+                completion = Promise.resolve().then(() => operation(controller.signal));
+                return { completion, replacedExisting: false };
+            });
+            try {
+                await toolHandler({ params: { name: 'add_documentation', arguments: { url: 'https://example.com' } } });
+                await addStarted.promise;
+                controller.abort();
+                add.resolve();
+                await completion;
+                expect(cancelIndexing).toHaveBeenCalledOnce();
+                expect(mockStoreAddDocument).toHaveBeenCalledWith(expect.any(Object), { signal: controller.signal, tags: [] });
+                expect(completeIndexing).not.toHaveBeenCalled();
+                expect(failIndexing).not.toHaveBeenCalled();
+            }
+            finally {
+                add.resolve();
+                await Promise.allSettled(completion ? [completion] : []);
+            }
+        });
+        it('stops retrying a conflicted write when cancellation arrives during backoff', async () => {
+            const firstAttempt = Promise.withResolvers();
+            const controller = new AbortController();
+            const cancelIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'cancelIndexing');
+            const completeIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'completeIndexing');
+            let completion;
+            mockProcessorProcess.mockResolvedValueOnce(processedPageWithChunk);
+            mockStoreAddDocument.mockImplementationOnce(async () => {
+                firstAttempt.resolve();
+                throw new Error('Commit conflict');
+            });
+            mockRunLatest.mockImplementationOnce(async (_url, operation) => {
+                completion = Promise.resolve().then(() => operation(controller.signal));
+                return { completion, replacedExisting: false };
+            });
+            try {
+                await toolHandler({ params: { name: 'add_documentation', arguments: { url: 'https://example.com' } } });
+                await firstAttempt.promise;
+                await nextTurn();
+                controller.abort();
+                await completion;
+                expect(cancelIndexing).toHaveBeenCalledOnce();
+                expect(mockStoreAddDocument).toHaveBeenCalledOnce();
+                expect(completeIndexing).not.toHaveBeenCalled();
+            }
+            finally {
+                controller.abort();
+                await Promise.allSettled(completion ? [completion] : []);
+            }
+        });
+        it('starts reindex status inside runLatest and preserves the replacement message', async () => {
+            const url = 'https://example.com';
+            mockStoreGetDocument.mockResolvedValueOnce({
+                url,
+                title: 'Example Docs',
+                lastIndexed: new Date(),
+                requiresAuth: false,
+                tags: ['docs'],
+            });
+            const startIndexing = vi.spyOn(IndexingStatusTracker.prototype, 'startIndexing');
+            let completion;
+            mockRunLatest.mockImplementationOnce(async (_url, operation) => {
+                expect(startIndexing).not.toHaveBeenCalled();
+                completion = Promise.resolve().then(() => operation(new AbortController().signal));
+                await nextTurn();
+                expect(startIndexing).toHaveBeenCalledOnce();
+                return { completion, replacedExisting: true };
+            });
+            const response = (await toolHandler({ params: { name: 'reindex_documentation', arguments: { url } } }));
+            const payload = JSON.parse(response.content[0].text);
+            expect(payload.message).toContain('Previous operation was cancelled');
+            expect(mockRunLatest).toHaveBeenCalledOnce();
+            await completion;
+        });
+    });
     describe('URL Validation', () => {
         it('should validate public URLs', () => {
             const mockIsValidPublicUrl = isValidPublicUrl;
@@ -298,36 +715,6 @@ describe('WebDocsServer', () => {
             tracker.stop();
         });
     });
-    describe('IndexingQueueManager', () => {
-        it('should manage indexing operations', async () => {
-            const queue = new IndexingQueueManager();
-            expect(queue.isIndexing('https://example.com')).toBe(false);
-            const controller = await queue.startOperation('https://example.com');
-            expect(controller).toBeDefined();
-            // Need to register the operation for isIndexing to return true
-            const mockPromise = new Promise((resolve) => setTimeout(resolve, 100));
-            queue.registerOperation('https://example.com', controller, mockPromise);
-            expect(queue.isIndexing('https://example.com')).toBe(true);
-            queue.completeOperation('https://example.com');
-            expect(queue.isIndexing('https://example.com')).toBe(false);
-        });
-        it('should cancel existing operation when starting new one for same URL', async () => {
-            vi.useFakeTimers();
-            const queue = new IndexingQueueManager();
-            const controller1 = await queue.startOperation('https://example.com');
-            const mockPromise = new Promise((resolve) => setTimeout(resolve, 1000));
-            queue.registerOperation('https://example.com', controller1, mockPromise);
-            // Starting a new operation should cancel the previous one
-            const startPromise = queue.startOperation('https://example.com');
-            // Advance timers to resolve the mock promise
-            await vi.advanceTimersByTimeAsync(1100);
-            const controller2 = await startPromise;
-            expect(controller1.signal.aborted).toBe(true);
-            expect(controller2.signal.aborted).toBe(false);
-            queue.completeOperation('https://example.com');
-            vi.useRealTimers();
-        });
-    });
     describe('Error Handling', () => {
         it('should sanitize error messages', () => {
             const errorWithPassword = new Error('Connection failed: password=secret123');