@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/hooks-B1B8NRHL.mjs

@@ -0,0 +1,898 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { a as argString, o as argStringArray, s as argStringRequired, t as argBool } from "./parse-args-B4cY5Vx5.mjs";
+import { o as evaluateOnNewDocumentWithTimeout, s as evaluateWithTimeout } from "./PageController-BPJNqqBN.mjs";
+import "./definitions-C1gCHO0i.mjs";
+//#region src/server/domains/hooks/ai-handlers.ts
+var AIHookToolHandlers = class {
+	injectedHooks = /* @__PURE__ */ new Map();
+	constructor(pageController) {
+		this.pageController = pageController;
+	}
+	hasAttachedTargetSession() {
+		return this.pageController.hasAttachedTargetSession();
+	}
+	async evaluateInAttachedTarget(expression) {
+		return await this.pageController.evaluateAttachedTarget(expression, {
+			returnByValue: true,
+			awaitPromise: true
+		});
+	}
+	async addScriptToAttachedTarget(source) {
+		await this.pageController.addScriptToAttachedTarget(source);
+	}
+	async handleAIHookInject(args) {
+		try {
+			const hookId = argStringRequired(args, "hookId");
+			const code = argStringRequired(args, "code");
+			const method = argString(args, "method", "evaluate");
+			if (this.hasAttachedTargetSession()) if (method === "evaluateOnNewDocument") {
+				await this.addScriptToAttachedTarget(code);
+				logger.info(`Hook injected into attached target (evaluateOnNewDocument): ${hookId}`);
+			} else {
+				await this.evaluateInAttachedTarget(code);
+				logger.info(`Hook injected into attached target (evaluate): ${hookId}`);
+			}
+			else {
+				const page = await this.pageController.getPage();
+				if (method === "evaluateOnNewDocument") {
+					await evaluateOnNewDocumentWithTimeout(page, code);
+					logger.info(`Hook injected (evaluateOnNewDocument): ${hookId}`);
+				} else {
+					await evaluateWithTimeout(page, code);
+					logger.info(`Hook injected (evaluate): ${hookId}`);
+				}
+			}
+			this.injectedHooks.set(hookId, {
+				code,
+				injectionTime: Date.now()
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					hookId,
+					message: `Hook (: ${method})`,
+					injectionTime: (/* @__PURE__ */ new Date()).toISOString()
+				}, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Hook injection failed", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleAIHookGetData(args) {
+		try {
+			const hookId = argStringRequired(args, "hookId");
+			const hookData = this.hasAttachedTargetSession() ? await this.evaluateInAttachedTarget(`(() => {
+            const hookId = ${JSON.stringify(hookId)};
+            const hooks = globalThis.__aiHooks;
+            if (!hooks?.[hookId]) {
+              return null;
+            }
+            return {
+              hookId,
+              metadata: globalThis.__aiHookMetadata?.[hookId],
+              records: hooks[hookId],
+              totalRecords: hooks[hookId].length,
+            };
+          })()`) : await evaluateWithTimeout(await this.pageController.getPage(), (id) => {
+				if (!window.__aiHooks?.[id]) return null;
+				return {
+					hookId: id,
+					metadata: window.__aiHookMetadata?.[id],
+					records: window.__aiHooks[id],
+					totalRecords: window.__aiHooks[id].length
+				};
+			}, hookId);
+			if (!hookData) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: `Hook: ${hookId}`
+				}, null, 2)
+			}] };
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					...hookData
+				}, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Failed to get hook data", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleAIHookList(_args) {
+		try {
+			const allHooks = this.hasAttachedTargetSession() ? await this.evaluateInAttachedTarget(`(() => {
+            const metadata = globalThis.__aiHookMetadata;
+            const hooks = globalThis.__aiHooks;
+            if (!metadata) {
+              return [];
+            }
+            return Object.keys(metadata).map((hookId) => ({
+              hookId,
+              metadata: metadata[hookId],
+              recordCount: hooks?.[hookId]?.length || 0,
+            }));
+          })()`) : await evaluateWithTimeout(await this.pageController.getPage(), () => {
+				if (!window.__aiHookMetadata) return [];
+				return Object.keys(window.__aiHookMetadata).map((hookId) => ({
+					hookId,
+					metadata: window.__aiHookMetadata[hookId],
+					recordCount: window.__aiHooks?.[hookId]?.length || 0
+				}));
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					totalHooks: allHooks.length,
+					hooks: allHooks
+				}, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Failed to list hooks", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleAIHookClear(args) {
+		try {
+			const hookId = argString(args, "hookId");
+			if (hookId) {
+				if (this.hasAttachedTargetSession()) await this.evaluateInAttachedTarget(`(() => {
+              const hookId = ${JSON.stringify(hookId)};
+              if (globalThis.__aiHooks?.[hookId]) {
+                globalThis.__aiHooks[hookId] = [];
+              }
+              return true;
+            })()`);
+				else await evaluateWithTimeout(await this.pageController.getPage(), (id) => {
+					if (window.__aiHooks?.[id]) window.__aiHooks[id] = [];
+				}, hookId);
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: true,
+						message: `Hook: ${hookId}`
+					}, null, 2)
+				}] };
+			} else {
+				if (this.hasAttachedTargetSession()) await this.evaluateInAttachedTarget(`(() => {
+              if (globalThis.__aiHooks) {
+                for (const key in globalThis.__aiHooks) {
+                  globalThis.__aiHooks[key] = [];
+                }
+              }
+              return true;
+            })()`);
+				else await evaluateWithTimeout(await this.pageController.getPage(), () => {
+					if (window.__aiHooks) for (const key in window.__aiHooks) window.__aiHooks[key] = [];
+				});
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: true,
+						message: "Hook"
+					}, null, 2)
+				}] };
+			}
+		} catch (error) {
+			logger.error("Failed to clear hook data", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleAIHookToggle(args) {
+		try {
+			const hookId = argStringRequired(args, "hookId");
+			const enabled = argBool(args, "enabled");
+			if (this.hasAttachedTargetSession()) await this.evaluateInAttachedTarget(`(() => {
+            const hookId = ${JSON.stringify(hookId)};
+            const enabled = ${JSON.stringify(enabled)};
+            if (globalThis.__aiHookMetadata?.[hookId]) {
+              globalThis.__aiHookMetadata[hookId].enabled = enabled;
+            }
+            return true;
+          })()`);
+			else await evaluateWithTimeout(await this.pageController.getPage(), (id, enable) => {
+				if (window.__aiHookMetadata?.[id]) window.__aiHookMetadata[id].enabled = enable;
+			}, hookId, enabled);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					hookId,
+					enabled,
+					message: `Hook${enabled ? "" : ""}`
+				}, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Failed to toggle hook", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleAIHookExport(args) {
+		try {
+			const hookId = argString(args, "hookId");
+			const format = argString(args, "format", "json");
+			const exportData = this.hasAttachedTargetSession() ? await this.evaluateInAttachedTarget(`(() => {
+            const hookId = ${JSON.stringify(hookId)};
+            if (hookId) {
+              return {
+                hookId,
+                metadata: globalThis.__aiHookMetadata?.[hookId],
+                records: globalThis.__aiHooks?.[hookId] || [],
+              };
+            }
+            return {
+              metadata: globalThis.__aiHookMetadata || {},
+              records: globalThis.__aiHooks || {},
+            };
+          })()`) : await evaluateWithTimeout(await this.pageController.getPage(), (id) => {
+				if (id) return {
+					hookId: id,
+					metadata: window.__aiHookMetadata?.[id],
+					records: window.__aiHooks?.[id] || []
+				};
+				else return {
+					metadata: window.__aiHookMetadata || {},
+					records: window.__aiHooks || {}
+				};
+			}, hookId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					format,
+					data: exportData,
+					exportTime: (/* @__PURE__ */ new Date()).toISOString()
+				}, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Failed to export hook data", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleAIHook(args) {
+		const action = String(args["action"] ?? "");
+		switch (action) {
+			case "inject": return this.handleAIHookInject(args);
+			case "get_data": return this.handleAIHookGetData(args);
+			case "list": return this.handleAIHookList(args);
+			case "clear": return this.handleAIHookClear(args);
+			case "toggle": return this.handleAIHookToggle(args);
+			case "export": return this.handleAIHookExport(args);
+			default: return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: `Unknown action: ${action}. Valid actions: inject, get_data, list, clear, toggle, export`
+				})
+			}] };
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/hooks/preset-builder.ts
+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}'] || [];
+})();`;
+}
+//#endregion
+//#region src/server/domains/hooks/preset-definitions.core.ts
+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)
+	}
+};
+//#endregion
+//#region src/server/domains/hooks/preset-definitions.security.ts
+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)
+	}
+};
+//#endregion
+//#region src/server/domains/hooks/preset-definitions.ts
+const PRESETS = {
+	...CORE_PRESETS,
+	...SECURITY_PRESETS
+};
+const PRESET_LIST = Object.entries(PRESETS).map(([id, p]) => ({
+	id,
+	description: p.description
+}));
+//#endregion
+//#region src/server/domains/hooks/preset-handlers.ts
+var HookPresetToolHandlers = class {
+	pageController;
+	constructor(pageController) {
+		this.pageController = pageController;
+	}
+	async handleHookPreset(args) {
+		try {
+			const customPresetMap = this.buildCustomPresetMap(args);
+			const availablePresets = {
+				...PRESETS,
+				...customPresetMap
+			};
+			const availablePresetList = [...PRESET_LIST, ...Object.entries(customPresetMap).map(([id, preset]) => ({
+				id,
+				description: `${preset.description} (custom)`
+			}))];
+			if (args.listPresets === true) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					totalPresets: availablePresetList.length,
+					presets: availablePresetList
+				}, null, 2)
+			}] };
+			const captureStack = argBool(args, "captureStack", false);
+			const logToConsole = argBool(args, "logToConsole", true);
+			const method = argString(args, "method", "evaluate");
+			let targets = [];
+			if (args.preset) targets = [argString(args, "preset")];
+			else if (Array.isArray(args.presets)) targets = argStringArray(args, "presets");
+			else return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: " Provide either preset (single) or presets (multiple), or set listPresets=true to list available presets"
+				}, null, 2)
+			}] };
+			const invalid = targets.filter((t) => !availablePresets[t]);
+			if (invalid.length > 0) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: `: ${invalid.join(", ")}`,
+					availablePresets: availablePresetList.map((p) => p.id)
+				}, null, 2)
+			}] };
+			const page = await this.pageController.getPage();
+			const injected = [];
+			const errors = [];
+			for (const presetId of targets) try {
+				const code = availablePresets[presetId].buildCode(captureStack, logToConsole);
+				if (method === "evaluateOnNewDocument") await page.evaluateOnNewDocument(code);
+				else await page.evaluate(code);
+				injected.push(presetId);
+				logger.info(` Hook preset injected: ${presetId}`);
+			} catch (err) {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				errors.push({
+					preset: presetId,
+					error: errorMessage
+				});
+				logger.error(` Failed to inject preset ${presetId}:`, err);
+			}
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: errors.length === 0,
+					injected,
+					failed: errors,
+					method,
+					captureStack,
+					message: ` ${injected.length}/${targets.length}  Hook`,
+					usage: ` ai_hook_get_data(hookId: "preset-<>") `
+				}, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Hook preset injection failed", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	buildCustomPresetMap(args) {
+		const rawTemplates = [];
+		if (args.customTemplate && typeof args.customTemplate === "object") rawTemplates.push(args.customTemplate);
+		if (Array.isArray(args.customTemplates)) rawTemplates.push(...args.customTemplates);
+		const customPresets = {};
+		for (const template of rawTemplates) {
+			const id = template.id?.trim();
+			const body = template.body?.trim();
+			if (!id || !body) throw new Error("Each custom template requires non-empty id and body");
+			if (PRESETS[id]) throw new Error(`Custom template id conflicts with built-in preset: ${id}`);
+			customPresets[id] = {
+				description: template.description?.trim() || `Custom inline preset: ${id}`,
+				buildCode: (captureStack, logToConsole) => buildHookCode(id, body, captureStack, logToConsole)
+			};
+		}
+		return customPresets;
+	}
+};
+//#endregion
+export { AIHookToolHandlers, HookPresetToolHandlers };