@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/modules/hook/AIHookGeneratorTemplates.test.js

@@ -0,0 +1,82 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { generateEventHookTemplate, generatePropertyHookTemplate, } from '../../../src/modules/hook/AIHookGeneratorTemplates.js';
+describe('AIHookGeneratorTemplates', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('builds property hook templates with explicit captures and filters', () => {
+        const result = generatePropertyHookTemplate({
+            target: { object: 'window.appState', property: 'token' },
+            behavior: {
+                captureArgs: true,
+                captureReturn: true,
+                captureStack: true,
+                logToConsole: true,
+                blockExecution: true,
+            },
+            condition: {
+                argFilter: 'args[0] !== null',
+            },
+        }, 'hook-token');
+        expect(result.explanation).toBe('Property hook: window.appState.token (get + set intercepted via Object.defineProperty)');
+        expect(result.code).toContain('const targetObject = window.appState;');
+        expect(result.code).toContain("const propName = 'token';");
+        expect(result.code).toContain('value: value,');
+        expect(result.code).toContain('newValue: newValue,');
+        expect(result.code).toContain('stack: new Error().stack,');
+        expect(result.code).toContain("console.log('[hook-token] Property get:', hookData);");
+        expect(result.code).toContain("console.log('[hook-token] Property set:', hookData);");
+        expect(result.code).toContain('const args = [newValue];');
+        expect(result.code).toContain('try { return args[0] !== null; } catch(e) { return true; }');
+        expect(result.code).toContain('if (!true) {');
+        expect(result.code).toContain("window.__aiHooks['hook-token'].push(hookData);");
+    });
+    it('falls back to default property targets and omits optional captures when disabled', () => {
+        const result = generatePropertyHookTemplate({
+            target: {},
+            behavior: {},
+        }, 'hook-default');
+        expect(result.explanation).toBe('Property hook: window.unknownProperty (get + set intercepted via Object.defineProperty)');
+        expect(result.code).toContain('const targetObject = window;');
+        expect(result.code).toContain("const propName = 'unknownProperty';");
+        expect(result.code).toContain('if (!false) {');
+        expect(result.code).not.toContain('value: value,');
+        expect(result.code).not.toContain('newValue: newValue,');
+        expect(result.code).not.toContain('stack: new Error().stack,');
+    });
+    it('builds scoped event hook templates with listener forwarding', () => {
+        const result = generateEventHookTemplate({
+            target: { name: 'submit' },
+            behavior: {
+                captureArgs: true,
+                captureStack: true,
+                logToConsole: true,
+                blockExecution: false,
+            },
+            condition: {
+                maxCalls: 3,
+            },
+        }, 'hook-submit');
+        expect(result.explanation).toBe('Event hook: "submit" events via EventTarget.prototype.addEventListener override');
+        expect(result.code).toContain("if (type !== 'submit') {");
+        expect(result.code).toContain('const maxCalls = 3;');
+        expect(result.code).toContain('event: {');
+        expect(result.code).toContain('stack: new Error().stack,');
+        expect(result.code).toContain("console.log('[hook-submit] Event fired:', hookData);");
+        expect(result.code).toContain("if (typeof listener === 'function') {");
+        expect(result.code).toContain('listener.handleEvent(event);');
+    });
+    it('supports unfiltered event hooks that block downstream listener execution', () => {
+        const result = generateEventHookTemplate({
+            target: {},
+            behavior: {
+                blockExecution: true,
+            },
+        }, 'hook-all-events');
+        expect(result.explanation).toBe('Event hook: all events via EventTarget.prototype.addEventListener override');
+        expect(result.code).not.toContain('if (type !==');
+        expect(result.code).toContain('const maxCalls = Infinity;');
+        expect(result.code).toContain('// Execution blocked');
+        expect(result.code).not.toContain('listener.call(this, event);');
+    });
+});

package/dist/tests/modules/hook/HookGenerator.generateHookScript.test.d.ts

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

package/dist/tests/modules/hook/HookGenerator.generateHookScript.test.js

@@ -0,0 +1,233 @@
+import { describe, expect, it } from 'vitest';
+import { generateHookScript, generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain, getInjectionInstructions, } from '../../../src/modules/hook/HookGenerator.js';
+describe('HookGenerator — generateHookScript dispatch', () => {
+    it('dispatches xhr type to generateXHRHook', () => {
+        const script = generateHookScript('*', 'xhr', 'log');
+        expect(script).toContain('[XHR Hook]');
+    });
+    it('dispatches fetch type to generateFetchHook', () => {
+        const script = generateHookScript('*', 'fetch', 'log');
+        expect(script).toContain('[Fetch Hook]');
+    });
+    it('dispatches websocket type to generateWebSocketHook', () => {
+        const script = generateHookScript('*', 'websocket', 'log');
+        expect(script).toContain('[WebSocket Hook]');
+    });
+    it('dispatches localstorage type to generateLocalStorageHook', () => {
+        const script = generateHookScript('*', 'localstorage', 'log');
+        expect(script).toContain('[Storage Hook]');
+    });
+    it('dispatches cookie type to generateCookieHook', () => {
+        const script = generateHookScript('*', 'cookie', 'log');
+        expect(script).toContain('[Cookie Hook]');
+    });
+    it('dispatches eval type to generateEvalHook', () => {
+        const script = generateHookScript('*', 'eval', 'log');
+        expect(script).toContain('[Eval Hook]');
+    });
+    it('dispatches object-method type to generateObjectMethodHook', () => {
+        const script = generateHookScript('console.log', 'object-method', 'log');
+        expect(script).toContain('[Object Hook]');
+    });
+    it('throws for unknown hook type', () => {
+        expect(() => generateHookScript('x', 'not-real', 'log')).toThrow('Unsupported hook type');
+    });
+    it('passes customCode to function hook', () => {
+        const script = generateHookScript('window.alert', 'function', 'modify', 'args[0] = "intercepted";');
+        expect(script).toContain('args[0] = "intercepted";');
+    });
+    it('passes condition to function hook', () => {
+        const script = generateHookScript('window.alert', 'function', 'log', undefined, { maxCalls: 5 });
+        expect(script).toContain('const maxCalls = 5;');
+    });
+    it('passes performance flag to function hook', () => {
+        const script = generateHookScript('window.alert', 'function', 'log', undefined, undefined, true);
+        expect(script).toContain('performance.now()');
+    });
+});
+describe('HookGenerator — generateFunctionHook', () => {
+    it('generates basic log hook without conditions', () => {
+        const script = generateFunctionHook('document.getElementById', 'log');
+        expect(script).toContain('const originalFunction = document.getElementById');
+        expect(script).toContain("type: 'function'");
+    });
+    it('generates block action hook', () => {
+        const script = generateFunctionHook('window.alert', 'block');
+        expect(script).toContain('window.alert');
+    });
+    it('includes custom code in modify action', () => {
+        const script = generateFunctionHook('window.fetch', 'modify', 'return "modified";');
+        expect(script).toContain('return "modified";');
+    });
+    it('handles condition with minInterval', () => {
+        const script = generateFunctionHook('fn', 'log', undefined, { minInterval: 500 });
+        expect(script).toContain('const minInterval = 500;');
+    });
+    it('handles condition with maxCalls only', () => {
+        const script = generateFunctionHook('fn', 'log', undefined, { maxCalls: 10 });
+        expect(script).toContain('const maxCalls = 10;');
+    });
+    it('includes performance timing when enabled', () => {
+        const script = generateFunctionHook('fn', 'log', undefined, undefined, true);
+        expect(script).toContain('const startTime = performance.now();');
+    });
+});
+describe('HookGenerator — generateXHRHook', () => {
+    it('generates XHR hook script', () => {
+        const script = generateXHRHook('log');
+        expect(script).toContain('[XHR Hook]');
+        expect(script).toContain('XMLHttpRequest');
+    });
+    it('includes custom code', () => {
+        const script = generateXHRHook('modify', 'url = "/changed";');
+        expect(script).toContain('url = "/changed";');
+    });
+    it('includes performance timing', () => {
+        const script = generateXHRHook('log', undefined, undefined, true);
+        expect(script).toContain('[Hook] XHR hooked successfully');
+    });
+});
+describe('HookGenerator — generateFetchHook', () => {
+    it('generates Fetch hook script', () => {
+        const script = generateFetchHook('log');
+        expect(script).toContain('[Fetch Hook]');
+        expect(script).toContain('fetch');
+    });
+    it('includes custom code', () => {
+        const script = generateFetchHook('modify', 'input = "/api/v2";');
+        expect(script).toContain('input = "/api/v2";');
+    });
+});
+describe('HookGenerator — generateWebSocketHook', () => {
+    it('generates WebSocket hook script', () => {
+        const script = generateWebSocketHook('log');
+        expect(script).toContain('[WebSocket Hook]');
+        expect(script).toContain('WebSocket');
+    });
+});
+describe('HookGenerator — generateLocalStorageHook', () => {
+    it('generates localStorage/sessionStorage hook script', () => {
+        const script = generateLocalStorageHook('log');
+        expect(script).toContain('[Storage Hook]');
+        expect(script).toContain('Storage.prototype');
+    });
+});
+describe('HookGenerator — generateCookieHook', () => {
+    it('generates cookie hook script', () => {
+        const script = generateCookieHook('log');
+        expect(script).toContain('[Cookie Hook]');
+        expect(script).toContain('cookie');
+    });
+});
+describe('HookGenerator — generateEvalHook', () => {
+    it('generates eval hook script', () => {
+        const script = generateEvalHook('log');
+        expect(script).toContain('[Eval Hook]');
+        expect(script).toContain('eval');
+    });
+    it('includes custom code', () => {
+        const script = generateEvalHook('modify', 'code = code.replace("bad", "good");');
+        expect(script).toContain('code = code.replace("bad", "good");');
+    });
+});
+describe('HookGenerator — generateObjectMethodHook', () => {
+    it('generates object method hook splitting target', () => {
+        const script = generateObjectMethodHook('console.log', 'log');
+        expect(script).toContain('[Object Hook]');
+        expect(script).toContain("'log'");
+    });
+    it('handles deeply nested target paths', () => {
+        const script = generateObjectMethodHook('window.document.cookie', 'log');
+        expect(script).toContain('[Object Hook]');
+    });
+});
+describe('HookGenerator — generateAntiDebugBypass', () => {
+    it('generates anti-debug bypass script', () => {
+        const script = generateAntiDebugBypass();
+        expect(typeof script).toBe('string');
+        expect(script.length).toBeGreaterThan(0);
+    });
+});
+describe('HookGenerator — generateHookTemplate', () => {
+    it('generates a function hook template', () => {
+        const script = generateHookTemplate('myHook', 'function');
+        expect(script).toContain('myHook');
+        expect(script).toContain('const original = myHook');
+        expect(script).toContain('[Hook] Successfully hooked: myHook');
+    });
+    it('generates a property hook template', () => {
+        const script = generateHookTemplate('window.location.href', 'property');
+        expect(script).toContain('defineProperty');
+        expect(script).toContain('[Hook] Successfully hooked property');
+    });
+    it('generates a prototype hook template', () => {
+        const script = generateHookTemplate('MyClass', 'prototype');
+        expect(script).toContain('const original = MyClass');
+        expect(script).toContain('prototype');
+        expect(script).toContain('[Hook] Successfully hooked prototype: MyClass');
+    });
+});
+describe('HookGenerator — generateHookChain', () => {
+    it('concatenates multiple hook scripts', () => {
+        const chain = generateHookChain([
+            { hookId: 'hook-1', script: 'var a = 1;', instructions: 'First hook' },
+            { hookId: 'hook-2', script: 'var b = 2;', instructions: 'Second hook' },
+            { hookId: 'hook-3', script: 'var c = 3;', instructions: 'Third hook' },
+        ]);
+        expect(chain).toContain('var a = 1;');
+        expect(chain).toContain('var b = 2;');
+        expect(chain).toContain('var c = 3;');
+        expect(chain).toContain('All 3 hooks initialized');
+    });
+    it('handles single hook', () => {
+        const chain = generateHookChain([
+            { hookId: 'solo', script: 'solo();', instructions: 'Only one' },
+        ]);
+        expect(chain).toContain('solo();');
+        expect(chain).toContain('All 1 hooks initialized');
+    });
+    it('handles empty array', () => {
+        const chain = generateHookChain([]);
+        expect(chain).toContain('All 0 hooks initialized');
+    });
+});
+describe('HookGenerator — getInjectionInstructions', () => {
+    it('returns instructions for each supported hook type', () => {
+        const types = [
+            'function',
+            'xhr',
+            'fetch',
+            'websocket',
+            'localstorage',
+            'cookie',
+            'eval',
+            'object-method',
+        ];
+        for (const type of types) {
+            const instructions = getInjectionInstructions(type);
+            expect(typeof instructions).toBe('string');
+            expect(instructions.length).toBeGreaterThan(0);
+        }
+    });
+    it('mentions page_evaluate in instructions', () => {
+        const instructions = getInjectionInstructions('function');
+        expect(instructions).toContain('page_evaluate');
+    });
+});
+describe('HookGenerator — re-exports are available', () => {
+    it('all exported functions are defined', () => {
+        expect(typeof generateFunctionHook).toBe('function');
+        expect(typeof generateXHRHook).toBe('function');
+        expect(typeof generateFetchHook).toBe('function');
+        expect(typeof generateWebSocketHook).toBe('function');
+        expect(typeof generateLocalStorageHook).toBe('function');
+        expect(typeof generateCookieHook).toBe('function');
+        expect(typeof generateEvalHook).toBe('function');
+        expect(typeof generateObjectMethodHook).toBe('function');
+        expect(typeof generateAntiDebugBypass).toBe('function');
+        expect(typeof generateHookTemplate).toBe('function');
+        expect(typeof generateHookChain).toBe('function');
+        expect(typeof getInjectionInstructions).toBe('function');
+        expect(typeof generateHookScript).toBe('function');
+    });
+});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.compose.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.compose.test.js

@@ -0,0 +1,21 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { generateHookChain } from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.compose.js';
+describe('HookGeneratorBuilders.core.generators.compose', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('concatenates hook scripts and announces the final initialization count', () => {
+        const chain = generateHookChain([
+            { hookId: 'a', script: 'console.log("a");', instructions: 'one' },
+            { hookId: 'b', script: 'console.log("b");', instructions: 'two' },
+        ]);
+        expect(chain).toContain('console.log("a");');
+        expect(chain).toContain('console.log("b");');
+        expect(chain.indexOf('console.log("a");')).toBeLessThan(chain.indexOf('console.log("b");'));
+        expect(chain).toContain('All 2 hooks initialized');
+    });
+    it('still returns a summary message when no hooks are provided', () => {
+        const chain = generateHookChain([]);
+        expect(chain).toBe("console.log('[Hook Chain] All 0 hooks initialized');");
+    });
+});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.network.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.network.test.js

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { generateFetchHook, generateWebSocketHook, generateXHRHook, } from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.network.js';
+describe('HookGeneratorBuilders.core.generators.network', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('generates XHR hooks that wrap open, headers, send and response instrumentation', () => {
+        const script = generateXHRHook('log', 'window.__xhrPatched = true;');
+        expect(script).toContain('const XHR = XMLHttpRequest.prototype;');
+        expect(script).toContain('XHR.open = function(method, url, async, user, password)');
+        expect(script).toContain('XHR.setRequestHeader = function(header, value)');
+        expect(script).toContain('XHR.send = function(data)');
+        expect(script).toContain("console.log('[XHR Hook] open:', {");
+        expect(script).toContain("console.log('[XHR Hook] setRequestHeader:', { header, value });");
+        expect(script).toContain("console.log('[XHR Hook] send:', {");
+        expect(script).toContain('if (xhr.readyState === 4) {');
+        expect(script).toContain("console.log('[XHR Hook] responseText:', xhr.responseText?.substring(0, 500));");
+        expect(script).toContain("console.log('[XHR Hook] responseJSON:', xhr.response);");
+        expect(script).toContain("if (event === 'load' || event === 'error' || event === 'abort') {");
+        expect(script).toContain('window.__xhrPatched = true;');
+    });
+    it('supports blocking XHR open calls', () => {
+        const script = generateXHRHook('block');
+        expect(script).toContain('return;');
+        expect(script).toContain("console.log('[Hook] XHR hooked successfully');");
+    });
+    it('generates fetch hooks with request inspection and response parsing branches', () => {
+        const script = generateFetchHook('log', 'window.__fetchPatched = true;');
+        expect(script).toContain('window.fetch = new Proxy(originalFetch');
+        expect(script).toContain('if (resource instanceof Request) {');
+        expect(script).toContain("method = config?.method || 'GET';");
+        expect(script).toContain("console.log('[Fetch Hook] request:', hookContext);");
+        expect(script).toContain('window.__fetchPatched = true;');
+        expect(script).toContain('const startTime = performance.now();');
+        expect(script).toContain('const clonedResponse = response.clone();');
+        expect(script).toContain("if (contentType.includes('application/json')) {");
+        expect(script).toContain("} else if (contentType.includes('text/')) {");
+        expect(script).toContain("console.error('[Fetch Hook] error:', {");
+    });
+    it('supports blocking fetch requests', () => {
+        const script = generateFetchHook('block');
+        expect(script).toContain('return Promise.reject(new Error("Fetch blocked by hook"));');
+    });
+    it('generates websocket hooks that mirror static constants and wrap send and events', () => {
+        const script = generateWebSocketHook('log', 'window.__wsPatched = true;');
+        expect(script).toContain('const OriginalWebSocket = window.WebSocket;');
+        expect(script).toContain('[WebSocket Hook #${wsId}] connecting:');
+        expect(script).toContain('ws.send = function(data)');
+        expect(script).toContain('[WebSocket Hook #${wsId}] send:');
+        expect(script).toContain("ws.addEventListener('message', function(event)");
+        expect(script).toContain("ws.addEventListener('close', function(event)");
+        expect(script).toContain('window.WebSocket.CONNECTING = OriginalWebSocket.CONNECTING;');
+        expect(script).toContain('window.__wsPatched = true;');
+    });
+    it('supports blocking websocket construction', () => {
+        const script = generateWebSocketHook('block');
+        expect(script).toContain('throw new Error("WebSocket blocked by hook");');
+    });
+});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.runtime.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.runtime.test.js

@@ -0,0 +1,66 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { generateAntiDebugBypass, generateEvalHook, generateFunctionHook, generateHookTemplate, generateObjectMethodHook, } from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.runtime.js';
+describe('HookGeneratorBuilders.core.generators.runtime', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('generates function hooks with condition, performance and modify branches', () => {
+        const script = generateFunctionHook('window.fetch', 'modify', 'args[0] = "/patched";', { maxCalls: 2, minInterval: 25 }, true);
+        expect(script).toContain('const originalFunction = window.fetch;');
+        expect(script).toContain('const maxCalls = 2;');
+        expect(script).toContain('const minInterval = 25;');
+        expect(script).toContain('const startTime = performance.now();');
+        expect(script).toContain('const endTime = performance.now();');
+        expect(script).toContain('args[0] = "/patched";');
+        expect(script).toContain("console.log('[Hook] Function result:', result);");
+        expect(script).not.toContain('return undefined;');
+    });
+    it('supports blocking function hooks without optional condition or performance code', () => {
+        const script = generateFunctionHook('window.alert', 'block');
+        expect(script).toContain('const originalFunction = window.alert;');
+        expect(script).toContain('return undefined;');
+        expect(script).not.toContain('let callCount = 0;');
+        expect(script).not.toContain('const startTime = performance.now();');
+    });
+    it('generates eval hooks that wrap eval, Function and timer string handlers', () => {
+        const script = generateEvalHook('block', 'window.__patched = true;');
+        expect(script).toContain('window.eval = function(code)');
+        expect(script).toContain('window.Function = function(...args)');
+        expect(script).toContain('window.setTimeout = function(handler, timeout, ...args)');
+        expect(script).toContain('window.setInterval = function(handler, timeout, ...args)');
+        expect(script).toContain('window.__patched = true;');
+        expect(script).toContain('return undefined;');
+        expect(script).toContain('return function() {};');
+        expect(script).toContain('return 0;');
+    });
+    it('generates object method hooks for both methods and accessors', () => {
+        const script = generateObjectMethodHook('window.localStorage.getItem', 'block', 'args[0] = "token";');
+        expect(script).toContain("const targetObject = getObjectByPath('window.localStorage');");
+        expect(script).toContain("const methodName = 'getItem';");
+        expect(script).toContain('targetObject[methodName] = function(...args)');
+        expect(script).toContain('Object.defineProperty(targetObject, methodName, {');
+        expect(script).toContain('Object.setPrototypeOf(targetObject[methodName], originalMethod);');
+        expect(script).toContain('return undefined;');
+        expect(script).toContain('args[0] = "token";');
+    });
+    it('generates anti-debug bypasses for debugger stripping, timing and devtools probes', () => {
+        const script = generateAntiDebugBypass();
+        expect(script).toContain("code.replace(/debugger\\s*;?/g, '')");
+        expect(script).toContain("lastArg.replace(/debugger\\s*;?/g, '')");
+        expect(script).toContain("Object.defineProperty(window, 'outerHeight'");
+        expect(script).toContain("Object.defineProperty(window, 'outerWidth'");
+        expect(script).toContain('Date.now = function()');
+        expect(script).toContain("return 'function () { [native code] }';");
+        expect(script).toContain("Object.defineProperty(window, 'devtools'");
+    });
+    it('generates hook templates for function, property and prototype targets', () => {
+        const functionTemplate = generateHookTemplate('window.fetch', 'function');
+        const propertyTemplate = generateHookTemplate('document.cookie', 'property');
+        const prototypeTemplate = generateHookTemplate('window.WebSocket', 'prototype');
+        expect(functionTemplate).toContain('const original = window.fetch;');
+        expect(propertyTemplate).toContain("Object.getOwnPropertyDescriptor(document, 'cookie')");
+        expect(propertyTemplate).toContain("Object.defineProperty(document, 'cookie', {");
+        expect(prototypeTemplate).toContain('const methodNames = Object.getOwnPropertyNames(original.prototype);');
+        expect(prototypeTemplate).toContain('window.WebSocket.prototype = original.prototype;');
+    });
+});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.storage.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.storage.test.js

@@ -0,0 +1,43 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { generateCookieHook, generateLocalStorageHook, getInjectionInstructions, } from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.storage.js';
+describe('HookGeneratorBuilders.core.generators.storage', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('generates storage hooks for mutators and readers', () => {
+        const script = generateLocalStorageHook('log', 'window.__storagePatched = true;');
+        expect(script).toContain('const originalSetItem = Storage.prototype.setItem;');
+        expect(script).toContain('Storage.prototype.setItem = function(key, value)');
+        expect(script).toContain('Storage.prototype.getItem = function(key)');
+        expect(script).toContain('Storage.prototype.removeItem = function(key)');
+        expect(script).toContain('Storage.prototype.clear = function()');
+        expect(script).toContain('[Storage Hook] ${storageType}.setItem:');
+        expect(script).toContain('[Storage Hook] ${storageType}.getItem:');
+        expect(script).toContain('[Storage Hook] ${storageType}.removeItem:');
+        expect(script).toContain('[Storage Hook] ${storageType}.clear:');
+        expect(script).toContain('window.__storagePatched = true;');
+    });
+    it('supports blocking storage writes', () => {
+        const script = generateLocalStorageHook('block');
+        expect(script).toContain('return;');
+        expect(script).toContain('return originalSetItem.apply(this, arguments);');
+    });
+    it('generates cookie hooks with getter, setter and parsing helpers', () => {
+        const script = generateCookieHook('log', 'window.__cookiePatched = true;');
+        expect(script).toContain("Object.getOwnPropertyDescriptor(Document.prototype, 'cookie')");
+        expect(script).toContain("Object.getOwnPropertyDescriptor(HTMLDocument.prototype, 'cookie')");
+        expect(script).toContain('function parseCookie(cookieString)');
+        expect(script).toContain("Object.defineProperty(document, 'cookie'");
+        expect(script).toContain("console.log('[Cookie Hook] get:', {");
+        expect(script).toContain("console.log('[Cookie Hook] set:', {");
+        expect(script).toContain('window.__cookiePatched = true;');
+    });
+    it('supports blocking cookie writes', () => {
+        const script = generateCookieHook('block');
+        expect(script).toContain('return;');
+    });
+    it('returns injection instructions that mention the selected hook type', () => {
+        const instructions = getInjectionInstructions('cookie');
+        expect(instructions).toBe('This hook script monitors cookie operations. Inject it into the target page via page_evaluate or console_execute to activate.');
+    });
+});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import * as generators from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.js';
+import * as compose from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.compose.js';
+import * as network from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.network.js';
+import * as runtime from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.runtime.js';
+import * as storage from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.storage.js';
+describe('HookGeneratorBuilders.core.generators.ts', () => {
+    it('aggregates runtime, network, storage and compose generator helpers', () => {
+        expect(generators.generateFunctionHook).toBe(runtime.generateFunctionHook);
+        expect(generators.generateEvalHook).toBe(runtime.generateEvalHook);
+        expect(generators.generateObjectMethodHook).toBe(runtime.generateObjectMethodHook);
+        expect(generators.generateAntiDebugBypass).toBe(runtime.generateAntiDebugBypass);
+        expect(generators.generateHookTemplate).toBe(runtime.generateHookTemplate);
+        expect(generators.generateXHRHook).toBe(network.generateXHRHook);
+        expect(generators.generateFetchHook).toBe(network.generateFetchHook);
+        expect(generators.generateWebSocketHook).toBe(network.generateWebSocketHook);
+        expect(generators.generateCookieHook).toBe(storage.generateCookieHook);
+        expect(generators.generateLocalStorageHook).toBe(storage.generateLocalStorageHook);
+        expect(generators.getInjectionInstructions).toBe(storage.getInjectionInstructions);
+        expect(generators.generateHookChain).toBe(compose.generateHookChain);
+    });
+});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import * as core from '../../../src/modules/hook/HookGeneratorBuilders.core.js';
+import * as generators from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.js';
+const asMap = (value) => value;
+describe('HookGeneratorBuilders.core.ts', () => {
+    it('re-exports the aggregated generator surface', () => {
+        const exportKeys = [
+            'generateAntiDebugBypass',
+            'generateCookieHook',
+            'generateEvalHook',
+            'generateFetchHook',
+            'generateFunctionHook',
+            'generateHookChain',
+            'generateHookTemplate',
+            'generateLocalStorageHook',
+            'generateObjectMethodHook',
+            'generateWebSocketHook',
+            'generateXHRHook',
+            'getInjectionInstructions',
+        ];
+        for (const key of exportKeys) {
+            expect(asMap(core)[key]).toBe(asMap(generators)[key]);
+        }
+    });
+});

package/dist/tests/modules/hook/HookGeneratorBuilders.reexports.test.d.ts

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