@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/domains/hooks/manifest.d.ts

@@ -1,59 +0,0 @@
-import type { MCPServerContext, ToolHandlerDeps } from '../../domains/shared/registry.js';
-import { AIHookToolHandlers } from '../../domains/hooks/index.js';
-import type { ToolArgs } from '../../types.js';
-type H = AIHookToolHandlers;
-declare function ensure(ctx: MCPServerContext): H;
-declare const manifest: {
-    kind: "domain-manifest";
-    version: 1;
-    domain: "hooks";
-    depKey: "aiHookHandlers";
-    secondaryDepKeys: string[];
-    profiles: ("workflow" | "full")[];
-    ensure: typeof ensure;
-    registrations: {
-        tool: {
-            inputSchema: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: object;
-                } | undefined;
-                required?: string[] | undefined;
-            };
-            name: string;
-            description?: string | undefined;
-            outputSchema?: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: object;
-                } | undefined;
-                required?: string[] | undefined;
-            } | undefined;
-            annotations?: {
-                title?: string | undefined;
-                readOnlyHint?: boolean | undefined;
-                destructiveHint?: boolean | undefined;
-                idempotentHint?: boolean | undefined;
-                openWorldHint?: boolean | undefined;
-            } | undefined;
-            execution?: {
-                taskSupport?: "optional" | "required" | "forbidden" | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-                theme?: "light" | "dark" | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        };
-        domain: "hooks";
-        bind: (deps: ToolHandlerDeps) => (args: ToolArgs) => Promise<unknown>;
-    }[];
-};
-export default manifest;

package/dist/src/server/domains/hooks/manifest.js

@@ -1,41 +0,0 @@
-import { bindByDepKey, ensureBrowserCore, getDep, toolLookup, } from '../../domains/shared/registry.js';
-import { aiHookTools, hookPresetTools } from '../../domains/hooks/definitions.js';
-import { AIHookToolHandlers, HookPresetToolHandlers } from '../../domains/hooks/index.js';
-const DOMAIN = 'hooks';
-const DEP_KEY = 'aiHookHandlers';
-const DEP_KEY_PRESET = 'hookPresetHandlers';
-const t = toolLookup([...aiHookTools, ...hookPresetTools]);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-function ensure(ctx) {
-    ensureBrowserCore(ctx);
-    if (!ctx.aiHookHandlers) {
-        ctx.aiHookHandlers = new AIHookToolHandlers(ctx.pageController);
-    }
-    if (!ctx.hookPresetHandlers) {
-        ctx.hookPresetHandlers = new HookPresetToolHandlers(ctx.pageController);
-    }
-    return ctx.aiHookHandlers;
-}
-const manifest = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: DOMAIN,
-    depKey: DEP_KEY,
-    secondaryDepKeys: ['hookPresetHandlers'],
-    profiles: ['workflow', 'full'],
-    ensure,
-    registrations: [
-        { tool: t('ai_hook_inject'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookInject(a)) },
-        { tool: t('ai_hook_get_data'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookGetData(a)) },
-        { tool: t('ai_hook_list'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookList(a)) },
-        { tool: t('ai_hook_clear'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookClear(a)) },
-        { tool: t('ai_hook_toggle'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookToggle(a)) },
-        { tool: t('ai_hook_export'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookExport(a)) },
-        {
-            tool: t('hook_preset'),
-            domain: DOMAIN,
-            bind: (deps) => (args) => getDep(deps, DEP_KEY_PRESET).handleHookPreset(args),
-        },
-    ],
-};
-export default manifest;

package/dist/src/server/domains/hooks/preset-builder.d.ts

@@ -1,5 +0,0 @@
-export declare function buildHookCode(name: string, body: string, captureStack: boolean, logToConsole: boolean): string;
-export type PresetEntry = {
-    description: string;
-    buildCode: (captureStack: boolean, logToConsole: boolean) => string;
-};

package/dist/src/server/domains/hooks/preset-builder.js

@@ -1,15 +0,0 @@
-export function buildHookCode(name, body, captureStack, logToConsole) {
-    const stackCode = captureStack
-        ? `const __stack = new Error().stack?.split('\\n').slice(1,4).join(' | ') || '';`
-        : `const __stack = '';`;
-    const logFn = logToConsole ? `console.log(__msg + (__stack ? ' | Stack: ' + __stack : ''));` : ``;
-    return `
-(function() {
-  if (window.__hookPresets === undefined) window.__hookPresets = {};
-  if (window.__hookPresets['${name}']) return;
-  ${body.replace(/\{\{STACK_CODE\}\}/g, stackCode).replace(/\{\{LOG_FN\}\}/g, logFn)}
-  window.__hookPresets['${name}'] = true;
-  window.__aiHooks = window.__aiHooks || {};
-  window.__aiHooks['preset-${name}'] = window.__aiHooks['preset-${name}'] || [];
-})();`;
-}

package/dist/src/server/domains/hooks/preset-definitions.core.d.ts

@@ -1,2 +0,0 @@
-import type { PresetEntry } from '../../domains/hooks/preset-builder.js';
-export declare const CORE_PRESETS: Record<string, PresetEntry>;

package/dist/src/server/domains/hooks/preset-definitions.core.js

@@ -1,311 +0,0 @@
-import { buildHookCode } from '../../domains/hooks/preset-builder.js';
-export const CORE_PRESETS = {
-    eval: {
-        description: ' Hook eval() to capture dynamic code execution',
-        buildCode: (cs, lc) => buildHookCode('eval', `
-  const _orig = window.eval;
-  window.eval = function(code) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:eval] code=' + String(code).substring(0, 200);
-    {{LOG_FN}}
-    window.__aiHooks['preset-eval'].push({ code: String(code).substring(0, 500), stack: __stack, ts: Date.now() });
-    return _orig.call(this, code);
-  };`, cs, lc),
-    },
-    'function-constructor': {
-        description: ' Hook new Function() to capture dynamic function creation',
-        buildCode: (cs, lc) => buildHookCode('function-constructor', `
-  const _orig = Function;
-  window.Function = function(...args) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:Function] args=' + JSON.stringify(args).substring(0, 200);
-    {{LOG_FN}}
-    window.__aiHooks['preset-function-constructor'].push({ args: args.map(a => String(a).substring(0,200)), stack: __stack, ts: Date.now() });
-    return _orig(...args);
-  };
-  window.Function.prototype = _orig.prototype;`, cs, lc),
-    },
-    'atob-btoa': {
-        description: ' Hook atob/btoa to capture Base64 encode/decode operations',
-        buildCode: (cs, lc) => buildHookCode('atob-btoa', `
-  const _atob = window.atob.bind(window);
-  const _btoa = window.btoa.bind(window);
-  window.atob = function(s) {
-    {{STACK_CODE}}
-    const result = _atob(s);
-    const __msg = '[Hook:atob] in=' + String(s).substring(0,100) + ' out=' + result.substring(0,100);
-    {{LOG_FN}}
-    window.__aiHooks['preset-atob-btoa'].push({ fn:'atob', input: String(s).substring(0,200), output: result.substring(0,200), stack: __stack, ts: Date.now() });
-    return result;
-  };
-  window.btoa = function(s) {
-    {{STACK_CODE}}
-    const result = _btoa(s);
-    const __msg = '[Hook:btoa] in=' + String(s).substring(0,100) + ' out=' + result;
-    {{LOG_FN}}
-    window.__aiHooks['preset-atob-btoa'].push({ fn:'btoa', input: String(s).substring(0,200), output: result, stack: __stack, ts: Date.now() });
-    return result;
-  };`, cs, lc),
-    },
-    'crypto-subtle': {
-        description: ' Hook crypto.subtle.encrypt/decrypt to intercept WebCrypto operations',
-        buildCode: (cs, lc) => buildHookCode('crypto-subtle', `
-  if (window.crypto && window.crypto.subtle) {
-    const _enc = window.crypto.subtle.encrypt.bind(window.crypto.subtle);
-    const _dec = window.crypto.subtle.decrypt.bind(window.crypto.subtle);
-    window.crypto.subtle.encrypt = function(algo, key, data) {
-      {{STACK_CODE}}
-      const __msg = '[Hook:crypto.encrypt] algo=' + JSON.stringify(algo);
-      {{LOG_FN}}
-      window.__aiHooks['preset-crypto-subtle'].push({ fn:'encrypt', algo: JSON.stringify(algo), stack: __stack, ts: Date.now() });
-      return _enc(algo, key, data);
-    };
-    window.crypto.subtle.decrypt = function(algo, key, data) {
-      {{STACK_CODE}}
-      const __msg = '[Hook:crypto.decrypt] algo=' + JSON.stringify(algo);
-      {{LOG_FN}}
-      window.__aiHooks['preset-crypto-subtle'].push({ fn:'decrypt', algo: JSON.stringify(algo), stack: __stack, ts: Date.now() });
-      return _dec(algo, key, data);
-    };
-  }`, cs, lc),
-    },
-    'json-stringify': {
-        description: ' Hook JSON.stringify/parse to capture serialization activity',
-        buildCode: (cs, lc) => buildHookCode('json-stringify', `
-  const _stringify = JSON.stringify;
-  const _parse = JSON.parse;
-  JSON.stringify = function(v, r, s) {
-    {{STACK_CODE}}
-    const result = _stringify(v, r, s);
-    const __msg = '[Hook:JSON.stringify] out=' + (result||'').substring(0,100);
-    {{LOG_FN}}
-    window.__aiHooks['preset-json-stringify'].push({ fn:'stringify', output: (result||'').substring(0,300), stack: __stack, ts: Date.now() });
-    return result;
-  };
-  JSON.parse = function(text, r) {
-    {{STACK_CODE}}
-    const result = _parse(text, r);
-    const __msg = '[Hook:JSON.parse] in=' + String(text).substring(0,100);
-    {{LOG_FN}}
-    window.__aiHooks['preset-json-stringify'].push({ fn:'parse', input: String(text).substring(0,300), stack: __stack, ts: Date.now() });
-    return result;
-  };`, cs, lc),
-    },
-    'object-defineproperty': {
-        description: ' Hook Object.defineProperty to monitor property definitions',
-        buildCode: (cs, lc) => buildHookCode('object-defineproperty', `
-  const _define = Object.defineProperty;
-  Object.defineProperty = function(obj, prop, descriptor) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:Object.defineProperty] prop=' + String(prop);
-    {{LOG_FN}}
-    window.__aiHooks['preset-object-defineproperty'].push({ prop: String(prop), descriptor: JSON.stringify(descriptor||{}).substring(0,200), stack: __stack, ts: Date.now() });
-    return _define(obj, prop, descriptor);
-  };`, cs, lc),
-    },
-    settimeout: {
-        description: ' Hook setTimeout to capture timer callbacks and delays',
-        buildCode: (cs, lc) => buildHookCode('settimeout', `
-  const _orig = window.setTimeout;
-  window.setTimeout = function(fn, delay, ...args) {
-    {{STACK_CODE}}
-    const fnStr = typeof fn === 'string' ? fn : fn?.toString().substring(0,100);
-    const __msg = '[Hook:setTimeout] delay=' + delay + ' fn=' + fnStr;
-    {{LOG_FN}}
-    window.__aiHooks['preset-settimeout'].push({ delay, fn: fnStr, stack: __stack, ts: Date.now() });
-    return _orig(fn, delay, ...args);
-  };`, cs, lc),
-    },
-    setinterval: {
-        description: ' Hook setInterval to capture repeating timer callbacks',
-        buildCode: (cs, lc) => buildHookCode('setinterval', `
-  const _orig = window.setInterval;
-  window.setInterval = function(fn, delay, ...args) {
-    {{STACK_CODE}}
-    const fnStr = typeof fn === 'string' ? fn : fn?.toString().substring(0,100);
-    const __msg = '[Hook:setInterval] delay=' + delay + ' fn=' + fnStr;
-    {{LOG_FN}}
-    window.__aiHooks['preset-setinterval'].push({ delay, fn: fnStr, stack: __stack, ts: Date.now() });
-    return _orig(fn, delay, ...args);
-  };`, cs, lc),
-    },
-    addeventlistener: {
-        description: ' Hook addEventListener to trace event listener registrations',
-        buildCode: (cs, lc) => buildHookCode('addeventlistener', `
-  const _orig = EventTarget.prototype.addEventListener;
-  EventTarget.prototype.addEventListener = function(type, listener, options) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:addEventListener] type=' + type;
-    {{LOG_FN}}
-    window.__aiHooks['preset-addeventlistener'].push({ type, target: this?.tagName || String(this).substring(0,50), stack: __stack, ts: Date.now() });
-    return _orig.call(this, type, listener, options);
-  };`, cs, lc),
-    },
-    postmessage: {
-        description: ' Hook postMessage to capture cross-origin and iframe messages',
-        buildCode: (cs, lc) => buildHookCode('postmessage', `
-  const _orig = window.postMessage.bind(window);
-  window.postMessage = function(data, origin, transfer) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:postMessage] origin=' + origin + ' data=' + JSON.stringify(data).substring(0,100);
-    {{LOG_FN}}
-    window.__aiHooks['preset-postmessage'].push({ origin, data: JSON.stringify(data||{}).substring(0,300), stack: __stack, ts: Date.now() });
-    return _orig(data, origin, transfer);
-  };
-  window.addEventListener('message', function(e) {
-    window.__aiHooks['preset-postmessage'].push({ direction:'received', origin: e.origin, data: JSON.stringify(e.data||{}).substring(0,300), ts: Date.now() });
-  });`, cs, lc),
-    },
-    webassembly: {
-        description: ' Hook WebAssembly.instantiate/compile to detect WASM module loading',
-        buildCode: (cs, lc) => buildHookCode('webassembly', `
-  if (typeof WebAssembly !== 'undefined') {
-    const _inst = WebAssembly.instantiate;
-    WebAssembly.instantiate = function(bufferSource, importObject) {
-      {{STACK_CODE}}
-      const size = bufferSource?.byteLength || bufferSource?.length || 0;
-      const __msg = '[Hook:WebAssembly.instantiate] size=' + size;
-      {{LOG_FN}}
-      window.__aiHooks['preset-webassembly'].push({ fn:'instantiate', size, stack: __stack, ts: Date.now() });
-      return _inst(bufferSource, importObject);
-    };
-  }`, cs, lc),
-    },
-    proxy: {
-        description: ' Hook Proxy constructor to detect proxy-based anti-debugging',
-        buildCode: (cs, lc) => buildHookCode('proxy', `
-  const _Proxy = window.Proxy;
-  window.Proxy = function(target, handler) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:Proxy] target=' + String(target).substring(0,50);
-    {{LOG_FN}}
-    window.__aiHooks['preset-proxy'].push({ target: String(target).substring(0,100), handlerKeys: Object.keys(handler||{}), stack: __stack, ts: Date.now() });
-    return new _Proxy(target, handler);
-  };
-  window.Proxy.prototype = _Proxy.prototype;
-  window.Proxy.revocable = _Proxy.revocable;`, cs, lc),
-    },
-    reflect: {
-        description: ' Hook Reflect.apply to capture indirect function calls',
-        buildCode: (cs, lc) => buildHookCode('reflect', `
-  const _apply = Reflect.apply;
-  Reflect.apply = function(target, thisArg, args) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:Reflect.apply] fn=' + (target?.name || 'anonymous');
-    {{LOG_FN}}
-    window.__aiHooks['preset-reflect'].push({ fn: target?.name || 'anonymous', argsCount: (args||[]).length, stack: __stack, ts: Date.now() });
-    return _apply(target, thisArg, args);
-  };`, cs, lc),
-    },
-    'history-pushstate': {
-        description: ' Hook history.pushState/replaceState to trace SPA navigation',
-        buildCode: (cs, lc) => buildHookCode('history-pushstate', `
-  const _push = history.pushState.bind(history);
-  const _replace = history.replaceState.bind(history);
-  history.pushState = function(state, title, url) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:history.pushState] url=' + url;
-    {{LOG_FN}}
-    window.__aiHooks['preset-history-pushstate'].push({ fn:'pushState', url: String(url), state: JSON.stringify(state||{}).substring(0,100), stack: __stack, ts: Date.now() });
-    return _push(state, title, url);
-  };
-  history.replaceState = function(state, title, url) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:history.replaceState] url=' + url;
-    {{LOG_FN}}
-    window.__aiHooks['preset-history-pushstate'].push({ fn:'replaceState', url: String(url), state: JSON.stringify(state||{}).substring(0,100), stack: __stack, ts: Date.now() });
-    return _replace(state, title, url);
-  };`, cs, lc),
-    },
-    'location-href': {
-        description: ' Hook location.href setter to intercept URL redirects',
-        buildCode: (cs, lc) => buildHookCode('location-href', `
-  const _desc = Object.getOwnPropertyDescriptor(window.location, 'href') ||
-    Object.getOwnPropertyDescriptor(Location.prototype, 'href');
-  if (_desc && _desc.set) {
-    const _origSet = _desc.set;
-    Object.defineProperty(window.location, 'href', {
-      get: _desc.get,
-      set: function(url) {
-        {{STACK_CODE}}
-        const __msg = '[Hook:location.href] url=' + url;
-        {{LOG_FN}}
-        window.__aiHooks['preset-location-href'].push({ url: String(url), stack: __stack, ts: Date.now() });
-        return _origSet.call(this, url);
-      },
-      configurable: true,
-    });
-  }`, cs, lc),
-    },
-    'navigator-useragent': {
-        description: ' Hook navigator.userAgent getter to detect UA fingerprinting',
-        buildCode: (cs, lc) => buildHookCode('navigator-useragent', `
-  const _desc = Object.getOwnPropertyDescriptor(Navigator.prototype, 'userAgent');
-  if (_desc && _desc.get) {
-    const _origGet = _desc.get;
-    Object.defineProperty(Navigator.prototype, 'userAgent', {
-      get: function() {
-        {{STACK_CODE}}
-        const result = _origGet.call(this);
-        const __msg = '[Hook:navigator.userAgent] ua=' + result.substring(0,80);
-        {{LOG_FN}}
-        window.__aiHooks['preset-navigator-useragent'].push({ ua: result.substring(0,200), stack: __stack, ts: Date.now() });
-        return result;
-      },
-      configurable: true,
-    });
-  }`, cs, lc),
-    },
-    eventsource: {
-        description: ' Hook EventSource to capture SSE connections',
-        buildCode: (cs, lc) => buildHookCode('eventsource', `
-  if (typeof EventSource !== 'undefined') {
-    const _ES = EventSource;
-    window.EventSource = function(url, opts) {
-      {{STACK_CODE}}
-      const __msg = '[Hook:EventSource] url=' + url;
-      {{LOG_FN}}
-      window.__aiHooks['preset-eventsource'].push({ url: String(url), stack: __stack, ts: Date.now() });
-      return new _ES(url, opts);
-    };
-    window.EventSource.prototype = _ES.prototype;
-  }`, cs, lc),
-    },
-    'window-open': {
-        description: ' Hook window.open to capture popup and new tab creation',
-        buildCode: (cs, lc) => buildHookCode('window-open', `
-  const _orig = window.open.bind(window);
-  window.open = function(url, target, features) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:window.open] url=' + url + ' target=' + target;
-    {{LOG_FN}}
-    window.__aiHooks['preset-window-open'].push({ url: String(url), target: String(target||''), stack: __stack, ts: Date.now() });
-    return _orig(url, target, features);
-  };`, cs, lc),
-    },
-    mutationobserver: {
-        description: ' Hook MutationObserver to track dynamic DOM mutation watchers',
-        buildCode: (cs, lc) => buildHookCode('mutationobserver', `
-  const _MO = MutationObserver;
-  window.MutationObserver = function(callback) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:MutationObserver] created';
-    {{LOG_FN}}
-    window.__aiHooks['preset-mutationobserver'].push({ stack: __stack, ts: Date.now() });
-    return new _MO(callback);
-  };
-  window.MutationObserver.prototype = _MO.prototype;`, cs, lc),
-    },
-    formdata: {
-        description: ' Hook FormData.append to capture form data before submission',
-        buildCode: (cs, lc) => buildHookCode('formdata', `
-  const _orig = FormData.prototype.append;
-  FormData.prototype.append = function(name, value, filename) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:FormData.append] name=' + name + ' value=' + String(value).substring(0,100);
-    {{LOG_FN}}
-    window.__aiHooks['preset-formdata'].push({ name: String(name), value: String(value).substring(0,200), stack: __stack, ts: Date.now() });
-    return _orig.call(this, name, value, filename);
-  };`, cs, lc),
-    },
-};

package/dist/src/server/domains/hooks/preset-definitions.d.ts

@@ -1,6 +0,0 @@
-import type { PresetEntry } from '../../domains/hooks/preset-builder.js';
-export declare const PRESETS: Record<string, PresetEntry>;
-export declare const PRESET_LIST: {
-    id: string;
-    description: string;
-}[];

package/dist/src/server/domains/hooks/preset-definitions.js

@@ -1,10 +0,0 @@
-import { CORE_PRESETS } from '../../domains/hooks/preset-definitions.core.js';
-import { SECURITY_PRESETS } from '../../domains/hooks/preset-definitions.security.js';
-export const PRESETS = {
-    ...CORE_PRESETS,
-    ...SECURITY_PRESETS,
-};
-export const PRESET_LIST = Object.entries(PRESETS).map(([id, p]) => ({
-    id,
-    description: p.description,
-}));

package/dist/src/server/domains/hooks/preset-definitions.security.d.ts

@@ -1,2 +0,0 @@
-import type { PresetEntry } from '../../domains/hooks/preset-builder.js';
-export declare const SECURITY_PRESETS: Record<string, PresetEntry>;

package/dist/src/server/domains/hooks/preset-definitions.security.js

@@ -1,141 +0,0 @@
-import { buildHookCode } from '../../domains/hooks/preset-builder.js';
-export const SECURITY_PRESETS = {
-    'anti-debug-bypass': {
-        description: ' Block anti-debugging: setInterval/setTimeout debugger traps, console.clear spam, timing attacks (performance.now freeze), outerWidth/outerHeight devtools detection',
-        buildCode: (cs, lc) => buildHookCode('anti-debug-bypass', `
-  window.__aiHooks['preset-anti-debug-bypass'] = window.__aiHooks['preset-anti-debug-bypass'] || [];
-  // 1. Block setInterval/setTimeout containing debugger/devtools
-  const _si = window.setInterval;
-  window.setInterval = function(fn, delay) {
-    const rest = Array.prototype.slice.call(arguments, 2);
-    const fnStr = typeof fn === 'function' ? fn.toString() : String(fn);
-    if (fnStr.includes('debugger') || fnStr.includes('devtools') || fnStr.includes('disable-devtool')) {
-      window.__aiHooks['preset-anti-debug-bypass'].push({ blocked: 'setInterval', fn: fnStr.substring(0, 200), ts: Date.now() });
-      return -1;
-    }
-    return _si.apply(this, [fn, delay].concat(rest));
-  };
-  const _st = window.setTimeout;
-  window.setTimeout = function(fn, delay) {
-    const rest = Array.prototype.slice.call(arguments, 2);
-    const fnStr = typeof fn === 'function' ? fn.toString() : String(fn);
-    if (fnStr.includes('debugger') || fnStr.includes('devtools')) {
-      window.__aiHooks['preset-anti-debug-bypass'].push({ blocked: 'setTimeout', fn: fnStr.substring(0, 200), ts: Date.now() });
-      return -1;
-    }
-    return _st.apply(this, [fn, delay].concat(rest));
-  };
-  // 2. Suppress console.clear spam
-  console.clear = function() {
-    window.__aiHooks['preset-anti-debug-bypass'].push({ blocked: 'console.clear', ts: Date.now() });
-  };
-  // 3. Freeze performance.now to defeat timing attacks
-  const _pn = performance.now.bind(performance);
-  let _t = _pn();
-  performance.now = function() { return (_t += 0.001); };
-  // 4. Fix outerWidth/outerHeight DevTools size detection
-  Object.defineProperty(window, 'outerWidth', { get: function() { return window.innerWidth; }, configurable: true });
-  Object.defineProperty(window, 'outerHeight', { get: function() { return window.innerHeight; }, configurable: true });`, cs, lc),
-    },
-    'crypto-key-capture': {
-        description: ' Force extractable:true on all WebCrypto importKey calls and capture plaintext/ciphertext + key material for encrypt/decrypt/sign/verify',
-        buildCode: (cs, lc) => buildHookCode('crypto-key-capture', `
-  if (window.crypto && window.crypto.subtle) {
-    const _subtle = window.crypto.subtle;
-    const _importKey = _subtle.importKey.bind(_subtle);
-    const _encrypt  = _subtle.encrypt.bind(_subtle);
-    const _decrypt  = _subtle.decrypt.bind(_subtle);
-    const _sign     = _subtle.sign.bind(_subtle);
-    const _verify   = _subtle.verify.bind(_subtle);
-    const _exportKey = _subtle.exportKey.bind(_subtle);
-    const toHex = function(buf) {
-      return Array.from(new Uint8Array(buf instanceof ArrayBuffer ? buf : buf.buffer || buf))
-        .map(function(b) { return b.toString(16).padStart(2,'0'); }).join('');
-    };
-    const tryExport = async function(key) {
-      try { return await _exportKey('jwk', key); } catch(e) { return null; }
-    };
-    _subtle.importKey = async function(format, keyData, algorithm, extractable, usages) {
-      {{STACK_CODE}}
-      const keyHex = (keyData instanceof ArrayBuffer || ArrayBuffer.isView(keyData)) ? toHex(keyData) : JSON.stringify(keyData);
-      const __msg = '[Hook:importKey] format=' + format + ' algo=' + JSON.stringify(algorithm) + ' key=' + keyHex.substring(0,64);
-      {{LOG_FN}}
-      const key = await _importKey(format, keyData, algorithm, true, usages);
-      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'importKey', format, algorithm: JSON.stringify(algorithm), keyHex, stack: __stack, ts: Date.now() });
-      return key;
-    };
-    _subtle.encrypt = async function(algo, key, data) {
-      {{STACK_CODE}}
-      const plainHex = toHex(data);
-      const result = await _encrypt(algo, key, data);
-      const cipherHex = toHex(result);
-      const keyJwk = await tryExport(key);
-      const __msg = '[Hook:encrypt] algo=' + JSON.stringify(algo) + ' plain=' + plainHex.substring(0,64);
-      {{LOG_FN}}
-      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'encrypt', algo: JSON.stringify(algo), plainHex, cipherHex, key: keyJwk, stack: __stack, ts: Date.now() });
-      return result;
-    };
-    _subtle.decrypt = async function(algo, key, data) {
-      {{STACK_CODE}}
-      const result = await _decrypt(algo, key, data);
-      const plainHex = toHex(result);
-      const keyJwk = await tryExport(key);
-      const __msg = '[Hook:decrypt] algo=' + JSON.stringify(algo) + ' plain=' + new TextDecoder().decode(new Uint8Array(result instanceof ArrayBuffer ? result : result.buffer, 0, Math.min(100, (result.byteLength || result.length || 0))));
-      {{LOG_FN}}
-      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'decrypt', algo: JSON.stringify(algo), plainHex, key: keyJwk, stack: __stack, ts: Date.now() });
-      return result;
-    };
-    _subtle.sign = async function(algo, key, data) {
-      {{STACK_CODE}}
-      const result = await _sign(algo, key, data);
-      const keyJwk = await tryExport(key);
-      const __msg = '[Hook:sign] algo=' + JSON.stringify(algo);
-      {{LOG_FN}}
-      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'sign', algo: JSON.stringify(algo), sigHex: toHex(result), key: keyJwk, stack: __stack, ts: Date.now() });
-      return result;
-    };
-  }`, cs, lc),
-    },
-    'webassembly-full': {
-        description: ' Hook WebAssembly.instantiate to log all import calls, export names, and memory creation',
-        buildCode: (cs, lc) => buildHookCode('webassembly-full', `
-  if (typeof WebAssembly !== 'undefined') {
-    const _inst = WebAssembly.instantiate;
-    WebAssembly.instantiate = async function(bufferSource, importObject) {
-      {{STACK_CODE}}
-      const size = bufferSource && (bufferSource.byteLength || bufferSource.length) || 0;
-      const __msg = '[Hook:WASM.instantiate] size=' + size;
-      {{LOG_FN}}
-      // Wrap all imported functions to trace calls
-      if (importObject && typeof importObject === 'object') {
-        Object.keys(importObject).forEach(function(modName) {
-          const mod = importObject[modName];
-          if (mod && typeof mod === 'object') {
-            Object.keys(mod).forEach(function(fnName) {
-              if (typeof mod[fnName] === 'function') {
-                const _fn = mod[fnName];
-                mod[fnName] = function() {
-                  const args = Array.prototype.slice.call(arguments);
-                  window.__aiHooks['preset-webassembly-full'].push({ type:'import_call', mod: modName, fn: fnName, args: args.map(function(a){ return typeof a === 'number' ? a : '?'; }), ts: Date.now() });
-                  return _fn.apply(this, args);
-                };
-              }
-            });
-          }
-        });
-      }
-      const result = await _inst(bufferSource, importObject);
-      const exports = result && result.instance ? Object.keys(result.instance.exports) : [];
-      window.__aiHooks['preset-webassembly-full'].push({ type:'instantiated', size, exports, importMods: importObject ? Object.keys(importObject) : [], stack: __stack, ts: Date.now() });
-      return result;
-    };
-    // Also hook WebAssembly.Memory creation
-    const _Memory = WebAssembly.Memory;
-    WebAssembly.Memory = function(descriptor) {
-      window.__aiHooks['preset-webassembly-full'].push({ type:'memory_created', initial: descriptor && descriptor.initial, maximum: descriptor && descriptor.maximum, shared: descriptor && descriptor.shared, ts: Date.now() });
-      return new _Memory(descriptor);
-    };
-    WebAssembly.Memory.prototype = _Memory.prototype;
-  }`, cs, lc),
-    },
-};

package/dist/src/server/domains/hooks/preset-handlers.d.ts

@@ -1,19 +0,0 @@
-interface HookablePage {
-    evaluateOnNewDocument(code: string): Promise<unknown>;
-    evaluate(code: string): Promise<unknown>;
-}
-interface PageControllerLike {
-    getPage(): Promise<HookablePage>;
-}
-export declare class HookPresetToolHandlers {
-    private pageController;
-    constructor(pageController: PageControllerLike);
-    handleHookPreset(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    private buildCustomPresetMap;
-}
-export {};