@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/modules/browser/TabRegistry.edge-cases.test.js

@@ -0,0 +1,456 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: loggerState,
+}));
+import { TabRegistry } from '../../../src/modules/browser/TabRegistry.js';
+describe('TabRegistry — additional coverage', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('registerPage — re-registration after clear', () => {
+        it('re-creates entry when tabsById was cleared but WeakMap reference remains', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const firstId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://example.com/a',
+                title: 'A',
+            });
+            registry.clear();
+            const secondId = registry.registerPage(page, {
+                index: 1,
+                url: 'https://example.com/b',
+                title: 'B',
+            });
+            expect(secondId).toBe(firstId);
+            const tab = registry.getTabById(firstId);
+            expect(tab).not.toBeNull();
+            expect(tab.index).toBe(1);
+            expect(tab.url).toBe('https://example.com/b');
+            expect(tab.stale).toBe(false);
+        });
+    });
+    describe('bindAlias', () => {
+        it('returns false when binding to a non-existent pageId', () => {
+            const registry = new TabRegistry();
+            const result = registry.bindAlias('missing', 'non-existent-id');
+            expect(result).toBe(false);
+        });
+        it('returns true when binding to a valid pageId', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://example.com',
+                title: 'Test',
+            });
+            const result = registry.bindAlias('main', pageId);
+            expect(result).toBe(true);
+        });
+        it('overwrites existing alias binding', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            const id1 = registry.registerPage(page1, {
+                index: 0,
+                url: 'https://a.com',
+                title: 'A',
+            });
+            const id2 = registry.registerPage(page2, {
+                index: 1,
+                url: 'https://b.com',
+                title: 'B',
+            });
+            registry.bindAlias('primary', id1);
+            registry.bindAlias('primary', id2);
+            expect(registry.resolveAlias('primary')).toBe(id2);
+        });
+    });
+    describe('bindAliasByIndex', () => {
+        it('returns null when no page matches the index', () => {
+            const registry = new TabRegistry();
+            const result = registry.bindAliasByIndex('notfound', 99);
+            expect(result).toBeNull();
+        });
+        it('skips stale pages when binding by index', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            registry.reconcilePages([page1, page2], [
+                { index: 0, url: 'https://a.com', title: 'A' },
+                { index: 1, url: 'https://b.com', title: 'B' },
+            ]);
+            registry.reconcilePages([page1], [{ index: 0, url: 'https://a.com', title: 'A' }]);
+            const result = registry.bindAliasByIndex('staleAlias', 1);
+            expect(result).toBeNull();
+        });
+    });
+    describe('unbindAlias', () => {
+        it('returns true when removing existing alias', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://example.com',
+                title: 'Test',
+            });
+            registry.bindAlias('test', pageId);
+            expect(registry.unbindAlias('test')).toBe(true);
+        });
+        it('returns false when removing non-existent alias', () => {
+            const registry = new TabRegistry();
+            expect(registry.unbindAlias('nonexistent')).toBe(false);
+        });
+    });
+    describe('resolveAlias', () => {
+        it('returns null for unknown alias', () => {
+            const registry = new TabRegistry();
+            expect(registry.resolveAlias('unknown')).toBeNull();
+        });
+        it('returns null when aliased page is stale', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://example.com',
+                title: 'Test',
+            });
+            registry.bindAlias('myAlias', pageId);
+            registry.reconcilePages([], []);
+            expect(registry.resolveAlias('myAlias')).toBeNull();
+        });
+    });
+    describe('getPageById', () => {
+        it('returns null for non-existent pageId', () => {
+            const registry = new TabRegistry();
+            expect(registry.getPageById('fake-id')).toBeNull();
+        });
+        it('returns null for stale page', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://example.com',
+                title: 'Test',
+            });
+            registry.reconcilePages([], []);
+            expect(registry.getPageById(pageId)).toBeNull();
+        });
+        it('returns page for valid non-stale entry', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://example.com',
+                title: 'Test',
+            });
+            expect(registry.getPageById(pageId)).toBe(page);
+        });
+    });
+    describe('getTabById', () => {
+        it('returns null for non-existent pageId', () => {
+            const registry = new TabRegistry();
+            expect(registry.getTabById('nonexistent')).toBeNull();
+        });
+        it('returns tab with aliases', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://example.com',
+                title: 'Test',
+            });
+            registry.bindAlias('a1', pageId);
+            registry.bindAlias('a2', pageId);
+            const tab = registry.getTabById(pageId);
+            expect(tab.aliases).toContain('a1');
+            expect(tab.aliases).toContain('a2');
+        });
+    });
+    describe('getTabByIndex', () => {
+        it('returns null when no tab has the given index', () => {
+            const registry = new TabRegistry();
+            expect(registry.getTabByIndex(99)).toBeNull();
+        });
+        it('returns the correct tab by index', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            registry.registerPage(page1, { index: 0, url: 'https://a.com', title: 'A' });
+            const id2 = registry.registerPage(page2, { index: 1, url: 'https://b.com', title: 'B' });
+            const tab = registry.getTabByIndex(1);
+            expect(tab.pageId).toBe(id2);
+            expect(tab.url).toBe('https://b.com');
+        });
+        it('skips stale tabs', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            registry.registerPage(page, { index: 5, url: 'https://test.com', title: 'Test' });
+            registry.reconcilePages([], []);
+            expect(registry.getTabByIndex(5)).toBeNull();
+        });
+    });
+    describe('findTab', () => {
+        it('returns null when no tab matches predicate', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            registry.registerPage(page, { index: 0, url: 'https://a.com', title: 'A' });
+            const result = registry.findTab((tab) => tab.url === 'https://nonexistent.com');
+            expect(result).toBeNull();
+        });
+        it('finds tab matching URL predicate', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            registry.registerPage(page1, { index: 0, url: 'https://a.com', title: 'A' });
+            const id2 = registry.registerPage(page2, { index: 1, url: 'https://b.com', title: 'B' });
+            const result = registry.findTab((tab) => tab.url === 'https://b.com');
+            expect(result.pageId).toBe(id2);
+        });
+    });
+    describe('setCurrentPageId', () => {
+        it('rejects non-existent pageId', () => {
+            const registry = new TabRegistry();
+            expect(registry.setCurrentPageId('fake')).toBe(false);
+        });
+        it('rejects stale pageId', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://test.com',
+                title: 'Test',
+            });
+            registry.reconcilePages([], []);
+            expect(registry.setCurrentPageId(pageId)).toBe(false);
+        });
+    });
+    describe('setCurrentByIndex', () => {
+        it('returns null when index does not exist', () => {
+            const registry = new TabRegistry();
+            const result = registry.setCurrentByIndex(99);
+            expect(result).toBeNull();
+            expect(registry.getCurrentPageId()).toBeNull();
+        });
+        it('sets current page and returns tab descriptor', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 3,
+                url: 'https://test.com',
+                title: 'Test',
+            });
+            const result = registry.setCurrentByIndex(3);
+            expect(result.pageId).toBe(pageId);
+            expect(registry.getCurrentPageId()).toBe(pageId);
+        });
+    });
+    describe('getCurrentPage', () => {
+        it('returns null when no current page', () => {
+            const registry = new TabRegistry();
+            expect(registry.getCurrentPage()).toBeNull();
+        });
+        it('returns page when current is set', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://test.com',
+                title: 'Test',
+            });
+            registry.setCurrentPageId(pageId);
+            expect(registry.getCurrentPage()).toBe(page);
+        });
+    });
+    describe('getCurrentTabInfo', () => {
+        it('returns null values when no current page', () => {
+            const registry = new TabRegistry();
+            const info = registry.getCurrentTabInfo('chrome');
+            expect(info.driver).toBe('chrome');
+            expect(info.currentPageId).toBeNull();
+            expect(info.currentIndex).toBeNull();
+            expect(info.url).toBeNull();
+            expect(info.title).toBeNull();
+            expect(info.aliases).toEqual([]);
+            expect(info.staleAliases).toEqual([]);
+        });
+        it('returns current page info when set', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 2,
+                url: 'https://current.com',
+                title: 'Current',
+            });
+            registry.setCurrentPageId(pageId);
+            const info = registry.getCurrentTabInfo('camoufox');
+            expect(info.driver).toBe('camoufox');
+            expect(info.currentPageId).toBe(pageId);
+            expect(info.currentIndex).toBe(2);
+            expect(info.url).toBe('https://current.com');
+            expect(info.title).toBe('Current');
+        });
+        it('reports stale current page as null', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://test.com',
+                title: 'Test',
+            });
+            registry.setCurrentPageId(pageId);
+            registry.reconcilePages([], []);
+            const info = registry.getCurrentTabInfo('chrome');
+            expect(info.currentPageId).toBeNull();
+        });
+    });
+    describe('getContextMeta', () => {
+        it('returns all nulls when no current page', () => {
+            const registry = new TabRegistry();
+            const meta = registry.getContextMeta();
+            expect(meta.url).toBeNull();
+            expect(meta.title).toBeNull();
+            expect(meta.tabIndex).toBeNull();
+            expect(meta.pageId).toBeNull();
+        });
+        it('returns values when current page is set', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 5,
+                url: 'https://meta.com',
+                title: 'Meta',
+            });
+            registry.setCurrentPageId(pageId);
+            const meta = registry.getContextMeta();
+            expect(meta.url).toBe('https://meta.com');
+            expect(meta.title).toBe('Meta');
+            expect(meta.tabIndex).toBe(5);
+            expect(meta.pageId).toBe(pageId);
+        });
+        it('returns nulls when current page is stale', () => {
+            const registry = new TabRegistry();
+            const page = {};
+            const pageId = registry.registerPage(page, {
+                index: 0,
+                url: 'https://stale.com',
+                title: 'Stale',
+            });
+            registry.setCurrentPageId(pageId);
+            registry.reconcilePages([], []);
+            const meta = registry.getContextMeta();
+            expect(meta.pageId).toBeNull();
+        });
+    });
+    describe('listTabs', () => {
+        it('returns empty array when no pages registered', () => {
+            const registry = new TabRegistry();
+            expect(registry.listTabs()).toEqual([]);
+        });
+        it('excludes stale tabs', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            registry.registerPage(page1, { index: 0, url: 'https://a.com', title: 'A' });
+            registry.registerPage(page2, { index: 1, url: 'https://b.com', title: 'B' });
+            registry.reconcilePages([page1], [{ index: 0, url: 'https://a.com', title: 'A' }]);
+            const tabs = registry.listTabs();
+            expect(tabs).toHaveLength(1);
+            expect(tabs[0].url).toBe('https://a.com');
+        });
+        it('sorts tabs by index', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            const page3 = {};
+            registry.registerPage(page3, { index: 2, url: 'https://c.com', title: 'C' });
+            registry.registerPage(page1, { index: 0, url: 'https://a.com', title: 'A' });
+            registry.registerPage(page2, { index: 1, url: 'https://b.com', title: 'B' });
+            const tabs = registry.listTabs();
+            expect(tabs[0].index).toBe(0);
+            expect(tabs[1].index).toBe(1);
+            expect(tabs[2].index).toBe(2);
+        });
+    });
+    describe('listAllTabs', () => {
+        it('includes stale tabs', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            registry.registerPage(page1, { index: 0, url: 'https://a.com', title: 'A' });
+            registry.registerPage(page2, { index: 1, url: 'https://b.com', title: 'B' });
+            registry.reconcilePages([page1], [{ index: 0, url: 'https://a.com', title: 'A' }]);
+            const allTabs = registry.listAllTabs();
+            expect(allTabs).toHaveLength(2);
+            const staleTabs = allTabs.filter((t) => t.stale);
+            expect(staleTabs).toHaveLength(1);
+            expect(staleTabs[0].url).toBe('https://b.com');
+        });
+        it('sorts by index', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            registry.registerPage(page2, { index: 5, url: 'https://b.com', title: 'B' });
+            registry.registerPage(page1, { index: 2, url: 'https://a.com', title: 'A' });
+            const tabs = registry.listAllTabs();
+            expect(tabs[0].index).toBe(2);
+            expect(tabs[1].index).toBe(5);
+        });
+    });
+    describe('reconcilePages', () => {
+        it('handles pages array with fewer meta entries (uses defaults)', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            const tabs = registry.reconcilePages([page1, page2], [{ index: 0, url: 'https://a.com', title: 'A' }]);
+            expect(tabs).toHaveLength(2);
+            expect(tabs[1].index).toBe(1);
+        });
+        it('does not re-mark already stale pages', () => {
+            const registry = new TabRegistry();
+            const page1 = {};
+            const page2 = {};
+            registry.reconcilePages([page1, page2], [
+                { index: 0, url: 'https://a.com', title: 'A' },
+                { index: 1, url: 'https://b.com', title: 'B' },
+            ]);
+            registry.reconcilePages([page1], [{ index: 0, url: 'https://a.com', title: 'A' }]);
+            loggerState.debug.mockClear();
+            registry.reconcilePages([page1], [{ index: 0, url: 'https://a.com', title: 'A' }]);
+            const staleLogCalls = loggerState.debug.mock.calls.filter((args) => typeof args[0] === 'string' && args[0].includes('marked stale'));
+            expect(staleLogCalls).toHaveLength(0);
+        });
+    });
+    describe('sharedContext', () => {
+        it('setSharedContext and getSharedContext work correctly', () => {
+            const registry = new TabRegistry();
+            registry.setSharedContext('key1', 'value1');
+            registry.setSharedContext('key2', { nested: true });
+            expect(registry.getSharedContext('key1')).toEqual({ value: 'value1', found: true });
+            expect(registry.getSharedContext('key2')).toEqual({
+                value: { nested: true },
+                found: true,
+            });
+            expect(registry.getSharedContext('missing')).toEqual({ value: null, found: false });
+        });
+        it('getSharedContextMap returns all entries', () => {
+            const registry = new TabRegistry();
+            registry.setSharedContext('a', 1);
+            registry.setSharedContext('b', 2);
+            const map = registry.getSharedContextMap();
+            expect(map).toEqual({ a: 1, b: 2 });
+        });
+        it('overwriting shared context value', () => {
+            const registry = new TabRegistry();
+            registry.setSharedContext('key', 'old');
+            registry.setSharedContext('key', 'new');
+            expect(registry.getSharedContext('key')).toEqual({ value: 'new', found: true });
+        });
+    });
+});

package/dist/tests/modules/browser/TabRegistry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/modules/browser/TabRegistry.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: loggerState,
+}));
+import { TabRegistry } from '../../../src/modules/browser/TabRegistry.js';
+describe('TabRegistry', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns a stable page id for the same page handle and updates metadata', () => {
+        const registry = new TabRegistry();
+        const page = {};
+        const firstId = registry.registerPage(page, {
+            index: 0,
+            url: 'https://example.com/one',
+            title: 'One',
+        });
+        const secondId = registry.registerPage(page, {
+            index: 3,
+            url: 'https://example.com/updated',
+            title: 'Updated',
+        });
+        expect(secondId).toBe(firstId);
+        expect(registry.getTabById(firstId)?.index).toBe(3);
+        expect(registry.getTabById(firstId)?.url).toBe('https://example.com/updated');
+    });
+    it('reconciles pages, marks missing entries stale and clears stale current page', () => {
+        const registry = new TabRegistry();
+        const pageA = {};
+        const pageB = {};
+        const pageAId = registry.registerPage(pageA, {
+            index: 0,
+            url: 'https://example.com/a',
+            title: 'A',
+        });
+        const pageBId = registry.registerPage(pageB, {
+            index: 1,
+            url: 'https://example.com/b',
+            title: 'B',
+        });
+        registry.bindAlias('secondary', pageBId);
+        registry.setCurrentPageId(pageBId);
+        const tabs = registry.reconcilePages([pageA], [{ index: 0, url: 'https://example.com/a2', title: 'A2' }]);
+        expect(tabs).toHaveLength(1);
+        expect(tabs[0]?.pageId).toBe(pageAId);
+        expect(registry.getTabById(pageBId)?.stale).toBe(true);
+        expect(registry.resolveAlias('secondary')).toBeNull();
+        expect(registry.getCurrentPageId()).toBeNull();
+    });
+    it('binds aliases by index and reports stale aliases in current tab info', () => {
+        const registry = new TabRegistry();
+        const pageA = {};
+        const pageB = {};
+        registry.reconcilePages([pageA, pageB], [
+            { index: 0, url: 'https://example.com/a', title: 'A' },
+            { index: 1, url: 'https://example.com/b', title: 'B' },
+        ]);
+        const boundPageId = registry.bindAliasByIndex('active', 1);
+        expect(boundPageId).toBeTruthy();
+        expect(registry.setCurrentByIndex(1)?.pageId).toBe(boundPageId);
+        registry.reconcilePages([pageA], [{ index: 0, url: 'https://example.com/a', title: 'A' }]);
+        const info = registry.getCurrentTabInfo('chrome');
+        expect(info.currentPageId).toBeNull();
+        expect(info.aliases).toContainEqual({
+            alias: 'active',
+            pageId: boundPageId,
+            index: 1,
+            stale: true,
+        });
+        expect(info.staleAliases).toContain('active');
+    });
+    it('stores shared context and clears all registry state on reset', () => {
+        const registry = new TabRegistry();
+        const page = {};
+        const pageId = registry.registerPage(page, {
+            index: 0,
+            url: 'https://example.com',
+            title: 'Example',
+        });
+        registry.bindAlias('main', pageId);
+        registry.setCurrentPageId(pageId);
+        registry.setSharedContext('token', 'abc');
+        expect(registry.getSharedContext('token')).toEqual({ value: 'abc', found: true });
+        expect(registry.getSharedContextMap()).toEqual({ token: 'abc' });
+        registry.clear();
+        expect(registry.listAllTabs()).toEqual([]);
+        expect(registry.getCurrentPageId()).toBeNull();
+        expect(registry.getSharedContext('token')).toEqual({ value: null, found: false });
+    });
+});

package/dist/tests/modules/captcha/CaptchaDetector.coverage.test.d.ts

@@ -0,0 +1 @@
+export {};