@jshookmcp/jshook 0.1.2

package/dist/modules/hook/AIHookGeneratorTemplates.js

@@ -0,0 +1,158 @@
+export function generatePropertyHookTemplate(request, hookId) {
+    const { target, behavior, condition } = request;
+    const objectPath = target.object || 'window';
+    const propertyName = target.property || target.name || 'unknownProperty';
+    const code = `
+(function() {
+  const targetObject = ${objectPath};
+  const propName = '${propertyName}';
+
+  if (!targetObject) {
+    console.warn('[${hookId}] Object not found: ${objectPath}');
+    return;
+  }
+
+  const descriptor = Object.getOwnPropertyDescriptor(targetObject, propName)
+    || (Object.getPrototypeOf(targetObject)
+        ? Object.getOwnPropertyDescriptor(Object.getPrototypeOf(targetObject), propName)
+        : undefined);
+
+  let currentValue = descriptor ? descriptor.value : targetObject[propName];
+  const originalGet = descriptor && descriptor.get ? descriptor.get : null;
+  const originalSet = descriptor && descriptor.set ? descriptor.set : null;
+  let callCount = 0;
+
+  Object.defineProperty(targetObject, propName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      callCount++;
+      const value = originalGet ? originalGet.call(this) : currentValue;
+
+      const hookData = {
+        hookId: '${hookId}',
+        type: 'property-get',
+        object: '${objectPath}',
+        property: propName,
+        callCount,
+        timestamp: Date.now(),
+        ${behavior.captureReturn ? 'value: value,' : ''}
+        ${behavior.captureStack ? 'stack: new Error().stack,' : ''}
+      };
+
+      ${behavior.logToConsole ? `console.log('[${hookId}] Property get:', hookData);` : ''}
+
+      if (!window.__aiHooks) window.__aiHooks = {};
+      if (!window.__aiHooks['${hookId}']) window.__aiHooks['${hookId}'] = [];
+      window.__aiHooks['${hookId}'].push(hookData);
+
+      return value;
+    },
+    set(newValue) {
+      callCount++;
+
+      ${condition?.argFilter
+        ? `
+      const args = [newValue];
+      const argFilterPassed = (function() {
+        try { return ${condition.argFilter}; } catch(e) { return true; }
+      })();
+      if (!argFilterPassed) {
+        if (originalSet) originalSet.call(this, newValue); else currentValue = newValue;
+        return;
+      }
+      `
+        : ''}
+
+      const hookData = {
+        hookId: '${hookId}',
+        type: 'property-set',
+        object: '${objectPath}',
+        property: propName,
+        callCount,
+        timestamp: Date.now(),
+        ${behavior.captureArgs ? 'newValue: newValue,' : ''}
+        ${behavior.captureStack ? 'stack: new Error().stack,' : ''}
+      };
+
+      ${behavior.logToConsole ? `console.log('[${hookId}] Property set:', hookData);` : ''}
+
+      if (!window.__aiHooks) window.__aiHooks = {};
+      if (!window.__aiHooks['${hookId}']) window.__aiHooks['${hookId}'] = [];
+      window.__aiHooks['${hookId}'].push(hookData);
+
+      if (!${behavior.blockExecution ? 'true' : 'false'}) {
+        if (originalSet) originalSet.call(this, newValue); else currentValue = newValue;
+      }
+    },
+  });
+
+  console.log('[${hookId}] Property hook installed for: ${objectPath}.${propertyName}');
+})();
+`;
+    const explanation = `Property hook: ${objectPath}.${propertyName} (get + set intercepted via Object.defineProperty)`;
+    return { code, explanation };
+}
+export function generateEventHookTemplate(request, hookId) {
+    const { target, behavior, condition } = request;
+    const eventType = target.name || target.property || '';
+    const maxCalls = condition?.maxCalls || 'Infinity';
+    const code = `
+(function() {
+  const originalAddEventListener = EventTarget.prototype.addEventListener;
+  let callCount = 0;
+
+  EventTarget.prototype.addEventListener = function(type, listener, options) {
+    ${eventType
+        ? `if (type !== '${eventType}') {
+      return originalAddEventListener.call(this, type, listener, options);
+    }`
+        : ''}
+
+    const wrappedListener = function(event) {
+      callCount++;
+      const maxCalls = ${maxCalls};
+
+      if (callCount <= maxCalls) {
+        const hookData = {
+          hookId: '${hookId}',
+          type: 'event',
+          eventType: type,
+          callCount,
+          timestamp: Date.now(),
+          ${behavior.captureArgs
+        ? `event: {
+            type: event.type,
+            target: event.target ? (event.target.tagName || String(event.target)) : null,
+            detail: event.detail != null ? event.detail : null,
+          },`
+        : ''}
+          ${behavior.captureStack ? 'stack: new Error().stack,' : ''}
+        };
+
+        ${behavior.logToConsole ? `console.log('[${hookId}] Event fired:', hookData);` : ''}
+
+        if (!window.__aiHooks) window.__aiHooks = {};
+        if (!window.__aiHooks['${hookId}']) window.__aiHooks['${hookId}'] = [];
+        window.__aiHooks['${hookId}'].push(hookData);
+      }
+
+      ${behavior.blockExecution
+        ? `// Execution blocked`
+        : `if (typeof listener === 'function') {
+        listener.call(this, event);
+      } else if (listener && typeof listener.handleEvent === 'function') {
+        listener.handleEvent(event);
+      }`}
+    };
+
+    return originalAddEventListener.call(this, type, wrappedListener, options);
+  };
+
+  console.log('[${hookId}] Event hook installed for: ${eventType || 'all events'}');
+})();
+`;
+    const explanation = `Event hook: ${eventType ? `"${eventType}" events` : 'all events'} via EventTarget.prototype.addEventListener override`;
+    return { code, explanation };
+}
+//# sourceMappingURL=AIHookGeneratorTemplates.js.map

package/dist/modules/hook/AIHookGeneratorTemplates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIHookGeneratorTemplates.js","sourceRoot":"","sources":["../../../src/modules/hook/AIHookGeneratorTemplates.ts"],"names":[],"mappings":"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"}

package/dist/modules/hook/HookGenerator.d.ts

@@ -0,0 +1,5 @@
+import type { HookOptions } from '../../types/index.js';
+import { generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, getInjectionInstructions, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain } from '../hook/HookGeneratorBuilders.js';
+export { generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, getInjectionInstructions, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain, };
+export declare function generateHookScript(target: string, type: HookOptions['type'], action: string, customCode?: string, condition?: HookOptions['condition'], performance?: boolean): string;
+//# sourceMappingURL=HookGenerator.d.ts.map

package/dist/modules/hook/HookGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HookGenerator.d.ts","sourceRoot":"","sources":["../../../src/modules/hook/HookGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,GAClB,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,EACpC,WAAW,UAAQ,GAClB,MAAM,CAqBR"}

package/dist/modules/hook/HookGenerator.js

@@ -0,0 +1,25 @@
+import { generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, getInjectionInstructions, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain, } from '../hook/HookGeneratorBuilders.js';
+export { generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, getInjectionInstructions, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain, };
+export function generateHookScript(target, type, action, customCode, condition, performance = false) {
+    switch (type) {
+        case 'function':
+            return generateFunctionHook(target, action, customCode, condition, performance);
+        case 'xhr':
+            return generateXHRHook(action, customCode, condition, performance);
+        case 'fetch':
+            return generateFetchHook(action, customCode, condition, performance);
+        case 'websocket':
+            return generateWebSocketHook(action, customCode, condition, performance);
+        case 'localstorage':
+            return generateLocalStorageHook(action, customCode, condition, performance);
+        case 'cookie':
+            return generateCookieHook(action, customCode, condition, performance);
+        case 'eval':
+            return generateEvalHook(action, customCode, condition, performance);
+        case 'object-method':
+            return generateObjectMethodHook(target, action, customCode, condition, performance);
+        default:
+            throw new Error(`Unsupported hook type: ${type}`);
+    }
+}
+//# sourceMappingURL=HookGenerator.js.map

package/dist/modules/hook/HookGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HookGenerator.js","sourceRoot":"","sources":["../../../src/modules/hook/HookGenerator.ts"],"names":[],"mappings":"AACA,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,GAClB,CAAC;AAEF,MAAM,UAAU,kBAAkB,CAChC,MAAc,EACd,IAAyB,EACzB,MAAc,EACd,UAAmB,EACnB,SAAoC,EACpC,WAAW,GAAG,KAAK;IAEnB,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,UAAU;YACb,OAAO,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;QAClF,KAAK,KAAK;YACR,OAAO,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;QACrE,KAAK,OAAO;YACV,OAAO,iBAAiB,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;QACvE,KAAK,WAAW;YACd,OAAO,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;QAC3E,KAAK,cAAc;YACjB,OAAO,wBAAwB,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;QAC9E,KAAK,QAAQ;YACX,OAAO,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;QACxE,KAAK,MAAM;YACT,OAAO,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;QACtE,KAAK,eAAe;YAClB,OAAO,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;QACtF;YACE,MAAM,IAAI,KAAK,CAAC,0BAA0B,IAAI,EAAE,CAAC,CAAC;IACtD,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,2 @@
+export { generateAntiDebugBypass, generateCookieHook, generateEvalHook, generateFetchHook, generateFunctionHook, generateHookChain, generateHookTemplate, generateLocalStorageHook, generateObjectMethodHook, generateWebSocketHook, generateXHRHook, getInjectionInstructions, } from '../hook/HookGeneratorBuilders.core.generators.js';
+//# sourceMappingURL=HookGeneratorBuilders.core.d.ts.map

package/dist/modules/hook/HookGeneratorBuilders.core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HookGeneratorBuilders.core.d.ts","sourceRoot":"","sources":["../../../src/modules/hook/HookGeneratorBuilders.core.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EACjB,oBAAoB,EACpB,wBAAwB,EACxB,wBAAwB,EACxB,qBAAqB,EACrB,eAAe,EACf,wBAAwB,GACzB,MAAM,qDAAqD,CAAC"}

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

@@ -0,0 +1,3 @@
+import type { HookResult } from '../../types/index.js';
+export declare function generateHookChain(hooks: HookResult[]): string;
+//# sourceMappingURL=HookGeneratorBuilders.core.generators.compose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HookGeneratorBuilders.core.generators.compose.d.ts","sourceRoot":"","sources":["../../../src/modules/hook/HookGeneratorBuilders.core.generators.compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,CAQ7D"}

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

@@ -0,0 +1,10 @@
+export function generateHookChain(hooks) {
+    const scripts = hooks.map((h) => h.script).join('\n\n');
+    return `
+
+${scripts}
+
+console.log('[Hook Chain] All ${hooks.length} hooks initialized');
+`.trim();
+}
+//# sourceMappingURL=HookGeneratorBuilders.core.generators.compose.js.map

package/dist/modules/hook/HookGeneratorBuilders.core.generators.compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HookGeneratorBuilders.core.generators.compose.js","sourceRoot":"","sources":["../../../src/modules/hook/HookGeneratorBuilders.core.generators.compose.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,iBAAiB,CAAC,KAAmB;IACnD,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACxD,OAAO;;EAEP,OAAO;;gCAEuB,KAAK,CAAC,MAAM;CAC3C,CAAC,IAAI,EAAE,CAAC;AACT,CAAC"}

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

@@ -0,0 +1,5 @@
+export { generateAntiDebugBypass, generateEvalHook, generateFunctionHook, generateHookTemplate, generateObjectMethodHook, } from '../hook/HookGeneratorBuilders.core.generators.runtime.js';
+export { generateFetchHook, generateWebSocketHook, generateXHRHook, } from '../hook/HookGeneratorBuilders.core.generators.network.js';
+export { generateCookieHook, generateLocalStorageHook, getInjectionInstructions, } from '../hook/HookGeneratorBuilders.core.generators.storage.js';
+export { generateHookChain } from '../hook/HookGeneratorBuilders.core.generators.compose.js';
+//# sourceMappingURL=HookGeneratorBuilders.core.generators.d.ts.map

package/dist/modules/hook/HookGeneratorBuilders.core.generators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HookGeneratorBuilders.core.generators.d.ts","sourceRoot":"","sources":["../../../src/modules/hook/HookGeneratorBuilders.core.generators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,GACzB,MAAM,6DAA6D,CAAC;AAErE,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,GAChB,MAAM,6DAA6D,CAAC;AAErE,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,6DAA6D,CAAC;AAErE,OAAO,EAAE,iBAAiB,EAAE,MAAM,6DAA6D,CAAC"}

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

@@ -0,0 +1,5 @@
+export { generateAntiDebugBypass, generateEvalHook, generateFunctionHook, generateHookTemplate, generateObjectMethodHook, } from '../hook/HookGeneratorBuilders.core.generators.runtime.js';
+export { generateFetchHook, generateWebSocketHook, generateXHRHook, } from '../hook/HookGeneratorBuilders.core.generators.network.js';
+export { generateCookieHook, generateLocalStorageHook, getInjectionInstructions, } from '../hook/HookGeneratorBuilders.core.generators.storage.js';
+export { generateHookChain } from '../hook/HookGeneratorBuilders.core.generators.compose.js';
+//# sourceMappingURL=HookGeneratorBuilders.core.generators.js.map

package/dist/modules/hook/HookGeneratorBuilders.core.generators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HookGeneratorBuilders.core.generators.js","sourceRoot":"","sources":["../../../src/modules/hook/HookGeneratorBuilders.core.generators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,GACzB,MAAM,6DAA6D,CAAC;AAErE,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,GAChB,MAAM,6DAA6D,CAAC;AAErE,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,6DAA6D,CAAC;AAErE,OAAO,EAAE,iBAAiB,EAAE,MAAM,6DAA6D,CAAC"}

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

@@ -0,0 +1,5 @@
+import type { HookOptions } from '../../types/index.js';
+export declare function generateXHRHook(action: string, customCode?: string, _condition?: HookOptions['condition'], _performance?: boolean): string;
+export declare function generateFetchHook(action: string, customCode?: string, _condition?: HookOptions['condition'], _performance?: boolean): string;
+export declare function generateWebSocketHook(action: string, customCode?: string, _condition?: HookOptions['condition'], _performance?: boolean): string;
+//# sourceMappingURL=HookGeneratorBuilders.core.generators.network.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HookGeneratorBuilders.core.generators.network.d.ts","sourceRoot":"","sources":["../../../src/modules/hook/HookGeneratorBuilders.core.generators.network.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,EACrC,YAAY,UAAQ,GACnB,MAAM,CAgHR;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,EACrC,YAAY,UAAQ,GACnB,MAAM,CAiGR;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,EACrC,YAAY,UAAQ,GACnB,MAAM,CA4GR"}

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

@@ -0,0 +1,321 @@
+export function generateXHRHook(action, customCode, _condition, _performance = false) {
+    return `
+(function() {
+'use strict';
+
+const XHR = XMLHttpRequest.prototype;
+const originalOpen = XHR.open;
+const originalSend = XHR.send;
+const originalSetRequestHeader = XHR.setRequestHeader;
+
+XHR.open = function(method, url, async, user, password) {
+  this._hookData = {
+    method: method,
+    url: url,
+    async: async !== false,
+    timestamp: Date.now(),
+    headers: {},
+    stackTrace: new Error().stack
+  };
+
+  console.log('[XHR Hook] open:', {
+    method: method,
+    url: url,
+    async: async !== false
+  });
+
+  ${action === 'block' ? 'return;' : ''}
+
+  return originalOpen.apply(this, arguments);
+};
+
+XHR.setRequestHeader = function(header, value) {
+  if (this._hookData) {
+    this._hookData.headers[header] = value;
+    console.log('[XHR Hook] setRequestHeader:', { header, value });
+  }
+
+  return originalSetRequestHeader.apply(this, arguments);
+};
+
+XHR.send = function(data) {
+  const xhr = this;
+
+  if (xhr._hookData) {
+    xhr._hookData.requestData = data;
+    xhr._hookData.sendTime = Date.now();
+
+    console.log('[XHR Hook] send:', {
+      url: xhr._hookData.url,
+      method: xhr._hookData.method,
+      headers: xhr._hookData.headers,
+      data: data
+    });
+  }
+
+  const originalOnReadyStateChange = xhr.onreadystatechange;
+
+  xhr.onreadystatechange = function() {
+    if (xhr.readyState === 4) {
+      const responseTime = Date.now() - (xhr._hookData?.sendTime || 0);
+
+      console.log('[XHR Hook] response:', {
+        url: xhr._hookData?.url,
+        status: xhr.status,
+        statusText: xhr.statusText,
+        responseTime: responseTime + 'ms',
+        responseHeaders: xhr.getAllResponseHeaders(),
+        responseType: xhr.responseType,
+        responseURL: xhr.responseURL
+      });
+
+      try {
+        if (xhr.responseType === '' || xhr.responseType === 'text') {
+          console.log('[XHR Hook] responseText:', xhr.responseText?.substring(0, 500));
+        } else if (xhr.responseType === 'json') {
+          console.log('[XHR Hook] responseJSON:', xhr.response);
+        } else {
+          console.log('[XHR Hook] response:', typeof xhr.response);
+        }
+      } catch (e) {
+        console.warn('[XHR Hook] Failed to log response:', e);
+      }
+    }
+
+    if (originalOnReadyStateChange) {
+      return originalOnReadyStateChange.apply(this, arguments);
+    }
+  };
+
+  const originalAddEventListener = xhr.addEventListener;
+  xhr.addEventListener = function(event, listener, ...args) {
+    if (event === 'load' || event === 'error' || event === 'abort') {
+      const wrappedListener = function(e) {
+        console.log(\`[XHR Hook] event '\${event}':\`, {
+          url: xhr._hookData?.url,
+          status: xhr.status
+        });
+        return listener.apply(this, arguments);
+      };
+      return originalAddEventListener.call(this, event, wrappedListener, ...args);
+    }
+    return originalAddEventListener.apply(this, arguments);
+  };
+
+  ${customCode || ''}
+
+  return originalSend.apply(this, arguments);
+};
+
+console.log('[Hook] XHR hooked successfully');
+})();
+`.trim();
+}
+export function generateFetchHook(action, customCode, _condition, _performance = false) {
+    return `
+(function() {
+'use strict';
+
+const originalFetch = window.fetch;
+
+window.fetch = new Proxy(originalFetch, {
+  apply: function(target, thisArg, args) {
+    const [resource, config] = args;
+
+    let url, method, headers, body;
+
+    if (resource instanceof Request) {
+      url = resource.url;
+      method = resource.method;
+      headers = Object.fromEntries(resource.headers.entries());
+      body = resource.body;
+    } else {
+      url = resource;
+      method = config?.method || 'GET';
+      headers = config?.headers || {};
+      body = config?.body;
+    }
+
+    const hookContext = {
+      url: url,
+      method: method,
+      headers: headers,
+      body: body,
+      timestamp: Date.now(),
+      stackTrace: new Error().stack.split('\\n').slice(2, 5).join('\\n')
+    };
+
+    console.log('[Fetch Hook] request:', hookContext);
+
+    ${action === 'block' ? 'return Promise.reject(new Error("Fetch blocked by hook"));' : ''}
+    ${customCode || ''}
+
+    const startTime = performance.now();
+
+    return Reflect.apply(target, thisArg, args)
+      .then(async response => {
+        const endTime = performance.now();
+        const duration = (endTime - startTime).toFixed(2);
+
+        const clonedResponse = response.clone();
+
+        const responseInfo = {
+          url: url,
+          status: response.status,
+          statusText: response.statusText,
+          ok: response.ok,
+          redirected: response.redirected,
+          type: response.type,
+          headers: Object.fromEntries(response.headers.entries()),
+          duration: duration + 'ms'
+        };
+
+        console.log('[Fetch Hook] response:', responseInfo);
+
+        try {
+          const contentType = response.headers.get('content-type') || '';
+
+          if (contentType.includes('application/json')) {
+            const json = await clonedResponse.json();
+            console.log('[Fetch Hook] responseJSON:', json);
+          } else if (contentType.includes('text/')) {
+            const text = await clonedResponse.text();
+            console.log('[Fetch Hook] responseText:', text.substring(0, 500));
+          } else {
+            console.log('[Fetch Hook] response type:', contentType);
+          }
+        } catch (e) {
+          console.warn('[Fetch Hook] Failed to parse response:', e.message);
+        }
+
+        return response;
+      })
+      .catch(error => {
+        const endTime = performance.now();
+        const duration = (endTime - startTime).toFixed(2);
+
+        console.error('[Fetch Hook] error:', {
+          url: url,
+          error: error.message,
+          duration: duration + 'ms'
+        });
+
+        throw error;
+      });
+  }
+});
+
+console.log('[Fetch Hook] Successfully hooked window.fetch');
+})();
+`.trim();
+}
+export function generateWebSocketHook(action, customCode, _condition, _performance = false) {
+    return `
+(function() {
+'use strict';
+
+const OriginalWebSocket = window.WebSocket;
+let wsCounter = 0;
+
+window.WebSocket = function(url, protocols) {
+  const wsId = ++wsCounter;
+  const connectTime = Date.now();
+
+  console.log(\`[WebSocket Hook #\${wsId}] connecting:\`, {
+    url: url,
+    protocols: protocols,
+    timestamp: new Date().toISOString()
+  });
+
+  ${action === 'block' ? 'throw new Error("WebSocket blocked by hook");' : ''}
+
+  const ws = new OriginalWebSocket(url, protocols);
+
+  const originalSend = ws.send;
+  ws.send = function(data) {
+    const dataInfo = {
+      wsId: wsId,
+      url: url,
+      timestamp: new Date().toISOString(),
+      dataType: typeof data,
+      size: data?.length || data?.byteLength || data?.size || 0
+    };
+
+    if (typeof data === 'string') {
+      dataInfo.content = data.length > 500 ? data.substring(0, 500) + '...' : data;
+    } else if (data instanceof ArrayBuffer) {
+      dataInfo.content = \`ArrayBuffer(\${data.byteLength} bytes)\`;
+    } else if (data instanceof Blob) {
+      dataInfo.content = \`Blob(\${data.size} bytes, \${data.type})\`;
+    }
+
+    console.log(\`[WebSocket Hook #\${wsId}] send:\`, dataInfo);
+
+    ${customCode || ''}
+
+    return originalSend.apply(this, arguments);
+  };
+
+  ws.addEventListener('open', function(event) {
+    const duration = Date.now() - connectTime;
+    console.log(\`[WebSocket Hook #\${wsId}] open:\`, {
+      url: url,
+      readyState: ws.readyState,
+      protocol: ws.protocol,
+      extensions: ws.extensions,
+      duration: duration + 'ms'
+    });
+  });
+
+  ws.addEventListener('message', function(event) {
+    const messageInfo = {
+      wsId: wsId,
+      url: url,
+      timestamp: new Date().toISOString(),
+      dataType: typeof event.data
+    };
+
+    if (typeof event.data === 'string') {
+      messageInfo.content = event.data.length > 500 ? event.data.substring(0, 500) + '...' : event.data;
+    } else if (event.data instanceof ArrayBuffer) {
+      messageInfo.content = \`ArrayBuffer(\${event.data.byteLength} bytes)\`;
+    } else if (event.data instanceof Blob) {
+      messageInfo.content = \`Blob(\${event.data.size} bytes, \${event.data.type})\`;
+    }
+
+    console.log(\`[WebSocket Hook #\${wsId}] message:\`, messageInfo);
+  });
+
+  ws.addEventListener('error', function(event) {
+    console.error(\`[WebSocket Hook #\${wsId}] error:\`, {
+      url: url,
+      readyState: ws.readyState,
+      timestamp: new Date().toISOString()
+    });
+  });
+
+  ws.addEventListener('close', function(event) {
+    const duration = Date.now() - connectTime;
+    console.log(\`[WebSocket Hook #\${wsId}] close:\`, {
+      url: url,
+      code: event.code,
+      reason: event.reason,
+      wasClean: event.wasClean,
+      duration: duration + 'ms',
+      timestamp: new Date().toISOString()
+    });
+  });
+
+  return ws;
+};
+
+window.WebSocket.CONNECTING = OriginalWebSocket.CONNECTING;
+window.WebSocket.OPEN = OriginalWebSocket.OPEN;
+window.WebSocket.CLOSING = OriginalWebSocket.CLOSING;
+window.WebSocket.CLOSED = OriginalWebSocket.CLOSED;
+
+console.log('[WebSocket Hook] Successfully hooked window.WebSocket');
+})();
+`.trim();
+}
+//# sourceMappingURL=HookGeneratorBuilders.core.generators.network.js.map

package/dist/modules/hook/HookGeneratorBuilders.core.generators.network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HookGeneratorBuilders.core.generators.network.js","sourceRoot":"","sources":["../../../src/modules/hook/HookGeneratorBuilders.core.generators.network.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,eAAe,CAC7B,MAAc,EACd,UAAmB,EACnB,UAAqC,EACrC,YAAY,GAAG,KAAK;IAEpB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;IAyBL,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8EnC,UAAU,IAAI,EAAE;;;;;;;CAOnB,CAAC,IAAI,EAAE,CAAC;AACT,CAAC;AAED,MAAM,UAAU,iBAAiB,CAC/B,MAAc,EACd,UAAmB,EACnB,UAAqC,EACrC,YAAY,GAAG,KAAK;IAEpB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmCH,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,4DAA4D,CAAC,CAAC,CAAC,EAAE;MACtF,UAAU,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DrB,CAAC,IAAI,EAAE,CAAC;AACT,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,MAAc,EACd,UAAmB,EACnB,UAAqC,EACrC,YAAY,GAAG,KAAK;IAEpB,OAAO;;;;;;;;;;;;;;;;;IAiBL,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,+CAA+C,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;MAwBvE,UAAU,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiErB,CAAC,IAAI,EAAE,CAAC;AACT,CAAC"}

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

@@ -0,0 +1,7 @@
+import type { HookOptions } from '../../types/index.js';
+export declare function generateFunctionHook(target: string, action: string, customCode?: string, condition?: HookOptions['condition'], performance?: boolean): string;
+export declare function generateEvalHook(action: string, customCode?: string, _condition?: HookOptions['condition'], _performance?: boolean): string;
+export declare function generateObjectMethodHook(target: string, action: string, customCode?: string, _condition?: HookOptions['condition'], _performance?: boolean): string;
+export declare function generateAntiDebugBypass(): string;
+export declare function generateHookTemplate(targetName: string, targetType: 'function' | 'property' | 'prototype'): string;
+//# sourceMappingURL=HookGeneratorBuilders.core.generators.runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HookGeneratorBuilders.core.generators.runtime.d.ts","sourceRoot":"","sources":["../../../src/modules/hook/HookGeneratorBuilders.core.generators.runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,EACpC,WAAW,UAAQ,GAClB,MAAM,CAiFR;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,EACrC,YAAY,UAAQ,GACnB,MAAM,CAoGR;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,EACrC,YAAY,UAAQ,GACnB,MAAM,CA2GR;AAED,wBAAgB,uBAAuB,IAAI,MAAM,CA+EhD;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,UAAU,GAAG,UAAU,GAAG,WAAW,GAChD,MAAM,CA+ER"}