@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/debugger-gnKxRSN0.mjs

@@ -0,0 +1,1271 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { t as ToolError } from "./ToolError-jh9whhMd.mjs";
+import { a as argString, i as argObject, r as argNumber, t as argBool } from "./parse-args-BlRjqlkL.mjs";
+import "./definitions-DVGfrn7y.mjs";
+//#region src/server/domains/debugger/handlers/debugger-control.ts
+var DebuggerControlHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleDebuggerLifecycle(args) {
+		if (args.action === "enable") {
+			await this.deps.debuggerManager.init();
+			await this.deps.runtimeInspector.init();
+			await this.deps.debuggerManager.initAdvancedFeatures(this.deps.runtimeInspector);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Debugger enabled",
+					enabled: this.deps.debuggerManager.isEnabled()
+				}, null, 2)
+			}] };
+		} else {
+			await this.deps.debuggerManager.disable();
+			await this.deps.runtimeInspector.disable();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Debugger disabled"
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleDebuggerPause(_args) {
+		await this.deps.debuggerManager.pause();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				message: "Execution paused"
+			}, null, 2)
+		}] };
+	}
+	async handleDebuggerResume(_args) {
+		await this.deps.debuggerManager.resume();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				message: "Execution resumed"
+			}, null, 2)
+		}] };
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/debugger-stepping.ts
+var DebuggerSteppingHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleDebuggerStepInto(_args) {
+		const mgr = this.deps.debuggerManager;
+		if (!mgr.isEnabled()) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: "Debugger not enabled",
+				hint: "Call debugger_lifecycle({ action: 'enable' })() first to enable the debugger"
+			}, null, 2)
+		}] };
+		if (!mgr.isPaused()) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: "Cannot step while not paused",
+				hint: "The debugger must be paused at a breakpoint to perform step operations. Set a breakpoint with breakpoint_set() or pause with debugger_pause().",
+				currentState: "running"
+			}, null, 2)
+		}] };
+		try {
+			await mgr.stepInto();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Stepped into"
+				}, null, 2)
+			}] };
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			logger.error(`Step into failed: ${errorMsg}`);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: errorMsg
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleDebuggerStepOver(_args) {
+		const mgr = this.deps.debuggerManager;
+		if (!mgr.isEnabled()) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: "Debugger not enabled",
+				hint: "Call debugger_lifecycle({ action: 'enable' })() first to enable the debugger"
+			}, null, 2)
+		}] };
+		if (!mgr.isPaused()) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: "Cannot step while not paused",
+				hint: "The debugger must be paused at a breakpoint to perform step operations. Set a breakpoint with breakpoint_set() or pause with debugger_pause().",
+				currentState: "running"
+			}, null, 2)
+		}] };
+		try {
+			await mgr.stepOver();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Stepped over"
+				}, null, 2)
+			}] };
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			logger.error(`Step over failed: ${errorMsg}`);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: errorMsg
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleDebuggerStepOut(_args) {
+		const mgr = this.deps.debuggerManager;
+		if (!mgr.isEnabled()) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: "Debugger not enabled",
+				hint: "Call debugger_lifecycle({ action: 'enable' })() first to enable the debugger"
+			}, null, 2)
+		}] };
+		if (!mgr.isPaused()) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: "Cannot step out while not paused",
+				hint: "The debugger must be paused at a breakpoint to perform step out. Set a breakpoint with breakpoint_set() or pause with debugger_pause().",
+				currentState: "running"
+			}, null, 2)
+		}] };
+		try {
+			await mgr.stepOut();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Stepped out"
+				}, null, 2)
+			}] };
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			logger.error(`Step out failed: ${errorMsg}`);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: errorMsg
+				}, null, 2)
+			}] };
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/debugger-evaluate.ts
+var DebuggerEvaluateHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleDebuggerEvaluate(args) {
+		const expression = argString(args, "expression", "");
+		const callFrameId = argString(args, "callFrameId");
+		const result = await this.deps.runtimeInspector.evaluate(expression, callFrameId);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				expression,
+				result
+			}, null, 2)
+		}] };
+	}
+	async handleDebuggerEvaluateGlobal(args) {
+		const expression = argString(args, "expression", "");
+		const result = await this.deps.runtimeInspector.evaluateGlobal(expression);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				expression,
+				result
+			}, null, 2)
+		}] };
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/debugger-state.ts
+var DebuggerStateHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleDebuggerWaitForPaused(args) {
+		const timeout = argNumber(args, "timeout", 3e4);
+		try {
+			const pausedState = await this.deps.debuggerManager.waitForPaused(timeout);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					paused: true,
+					reason: pausedState.reason,
+					location: pausedState.callFrames[0]?.location,
+					hitBreakpoints: pausedState.hitBreakpoints
+				}, null, 2)
+			}] };
+		} catch (error) {
+			if (error instanceof ToolError) throw error;
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					paused: false,
+					message: error instanceof Error ? error.message : "Timeout waiting for paused event"
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleDebuggerGetPausedState(_args) {
+		const pausedState = this.deps.debuggerManager.getPausedState();
+		if (!pausedState) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				paused: false,
+				message: "Debugger is not paused"
+			}, null, 2)
+		}] };
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				paused: true,
+				reason: pausedState.reason,
+				frameCount: pausedState.callFrames.length,
+				topFrame: {
+					functionName: pausedState.callFrames[0]?.functionName,
+					location: pausedState.callFrames[0]?.location
+				},
+				hitBreakpoints: pausedState.hitBreakpoints,
+				timestamp: pausedState.timestamp
+			}, null, 2)
+		}] };
+	}
+	async handleGetCallStack(_args) {
+		const callStack = await this.deps.runtimeInspector.getCallStack();
+		if (!callStack) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				message: "Not in paused state. Set a breakpoint and trigger it first."
+			}, null, 2)
+		}] };
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				callStack: {
+					frameCount: callStack.callFrames.length,
+					reason: callStack.reason,
+					frames: callStack.callFrames.map((frame, index) => ({
+						index,
+						callFrameId: frame.callFrameId,
+						functionName: frame.functionName,
+						location: `${frame.location.url}:${frame.location.lineNumber}:${frame.location.columnNumber}`,
+						scopeCount: frame.scopeChain.length
+					}))
+				}
+			}, null, 2)
+		}] };
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/session-management.ts
+function getErrorMessage$5(error) {
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	return String(error);
+}
+var SessionManagementHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleSaveSession(args) {
+		const filePath = argString(args, "filePath");
+		const metadata = argObject(args, "metadata");
+		try {
+			const savedPath = await this.deps.debuggerManager.saveSession(filePath, metadata);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Session saved successfully",
+					filePath: savedPath,
+					breakpointCount: this.deps.debuggerManager.listBreakpoints().length
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to save session",
+					error: getErrorMessage$5(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleLoadSession(args) {
+		const filePath = argString(args, "filePath");
+		const sessionData = argString(args, "sessionData");
+		try {
+			if (filePath) await this.deps.debuggerManager.loadSessionFromFile(filePath);
+			else if (sessionData) await this.deps.debuggerManager.importSession(sessionData);
+			else throw new Error("Either filePath or sessionData must be provided");
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Session loaded successfully",
+					breakpointCount: this.deps.debuggerManager.listBreakpoints().length,
+					pauseOnExceptions: this.deps.debuggerManager.getPauseOnExceptionsState()
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to load session",
+					error: getErrorMessage$5(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleExportSession(args) {
+		const metadata = argObject(args, "metadata");
+		try {
+			const session = this.deps.debuggerManager.exportSession(metadata);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Session exported successfully",
+					session
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to export session",
+					error: getErrorMessage$5(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleListSessions(_args) {
+		try {
+			const sessions = await this.deps.debuggerManager.listSavedSessions();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					count: sessions.length,
+					sessions: sessions.map((s) => ({
+						path: s.path,
+						timestamp: s.timestamp,
+						date: new Date(s.timestamp).toISOString(),
+						metadata: s.metadata
+					}))
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to list sessions",
+					error: getErrorMessage$5(error)
+				}, null, 2)
+			}] };
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/breakpoint-basic.ts
+var BreakpointBasicHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleBreakpointSet(args) {
+		const url = argString(args, "url");
+		const scriptId = argString(args, "scriptId");
+		const lineNumber = argNumber(args, "lineNumber", 0);
+		const columnNumber = argNumber(args, "columnNumber");
+		const condition = argString(args, "condition");
+		let breakpoint;
+		if (url) breakpoint = await this.deps.debuggerManager.setBreakpointByUrl({
+			url,
+			lineNumber,
+			columnNumber,
+			condition
+		});
+		else if (scriptId) breakpoint = await this.deps.debuggerManager.setBreakpoint({
+			scriptId,
+			lineNumber,
+			columnNumber,
+			condition
+		});
+		else throw new Error("Either url or scriptId must be provided");
+		this.deps.eventBus?.emit("debugger:breakpoint_hit", {
+			scriptId: breakpoint.location?.scriptId ?? scriptId ?? "",
+			lineNumber: breakpoint.location?.lineNumber ?? lineNumber,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				breakpoint: {
+					breakpointId: breakpoint.breakpointId,
+					location: breakpoint.location,
+					condition: breakpoint.condition,
+					enabled: breakpoint.enabled
+				}
+			}, null, 2)
+		}] };
+	}
+	async handleBreakpointRemove(args) {
+		const breakpointId = argString(args, "breakpointId", "");
+		await this.deps.debuggerManager.removeBreakpoint(breakpointId);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				message: `Breakpoint ${breakpointId} removed`
+			}, null, 2)
+		}] };
+	}
+	async handleBreakpointList(_args) {
+		const breakpoints = this.deps.debuggerManager.listBreakpoints();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				count: breakpoints.length,
+				breakpoints: breakpoints.map((bp) => ({
+					breakpointId: bp.breakpointId,
+					location: bp.location,
+					condition: bp.condition,
+					enabled: bp.enabled,
+					hitCount: bp.hitCount
+				}))
+			}, null, 2)
+		}] };
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/breakpoint-exception.ts
+var BreakpointExceptionHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleBreakpointSetOnException(args) {
+		const state = argString(args, "state", "none");
+		await this.deps.debuggerManager.setPauseOnExceptions(state);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				message: `Pause on exceptions set to: ${state}`,
+				state
+			}, null, 2)
+		}] };
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/xhr-breakpoint.ts
+function hasEnsureAdvancedFeatures$2(manager) {
+	return typeof manager.ensureAdvancedFeatures === "function";
+}
+function getErrorMessage$4(error) {
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	return String(error);
+}
+var XHRBreakpointHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async ensureAdvancedFeaturesIfSupported() {
+		if (hasEnsureAdvancedFeatures$2(this.deps.debuggerManager)) await this.deps.debuggerManager.ensureAdvancedFeatures();
+	}
+	async handleXHRBreakpointSet(args) {
+		try {
+			const urlPattern = argString(args, "urlPattern", "");
+			await this.ensureAdvancedFeaturesIfSupported();
+			const breakpointId = await this.deps.debuggerManager.getXHRManager().setXHRBreakpoint(urlPattern);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "XHR breakpoint set",
+					breakpointId,
+					urlPattern
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to set XHR breakpoint",
+					error: getErrorMessage$4(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleXHRBreakpointRemove(args) {
+		try {
+			const breakpointId = argString(args, "breakpointId", "");
+			await this.ensureAdvancedFeaturesIfSupported();
+			const removed = await this.deps.debuggerManager.getXHRManager().removeXHRBreakpoint(breakpointId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: removed,
+					message: removed ? "XHR breakpoint removed" : "XHR breakpoint not found",
+					breakpointId
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to remove XHR breakpoint",
+					error: getErrorMessage$4(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleXHRBreakpointList(_args) {
+		try {
+			await this.ensureAdvancedFeaturesIfSupported();
+			const breakpoints = this.deps.debuggerManager.getXHRManager().getAllXHRBreakpoints();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: `Found ${breakpoints.length} XHR breakpoint(s)`,
+					breakpoints
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to list XHR breakpoints",
+					error: getErrorMessage$4(error)
+				}, null, 2)
+			}] };
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/event-breakpoint.ts
+function hasEnsureAdvancedFeatures$1(manager) {
+	return typeof manager.ensureAdvancedFeatures === "function";
+}
+function getErrorMessage$3(error) {
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	return String(error);
+}
+var EventBreakpointHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async ensureAdvancedFeaturesIfSupported() {
+		if (hasEnsureAdvancedFeatures$1(this.deps.debuggerManager)) await this.deps.debuggerManager.ensureAdvancedFeatures();
+	}
+	async handleEventBreakpointSet(args) {
+		try {
+			const eventName = argString(args, "eventName", "");
+			const targetName = argString(args, "targetName");
+			await this.ensureAdvancedFeaturesIfSupported();
+			const breakpointId = await this.deps.debuggerManager.getEventManager().setEventListenerBreakpoint(eventName, targetName);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Event breakpoint set",
+					breakpointId,
+					eventName,
+					targetName
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to set event breakpoint",
+					error: getErrorMessage$3(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleEventBreakpointSetCategory(args) {
+		try {
+			const category = argString(args, "category", "");
+			await this.ensureAdvancedFeaturesIfSupported();
+			const eventManager = this.deps.debuggerManager.getEventManager();
+			let breakpointIds;
+			switch (category) {
+				case "mouse":
+					breakpointIds = await eventManager.setMouseEventBreakpoints();
+					break;
+				case "keyboard":
+					breakpointIds = await eventManager.setKeyboardEventBreakpoints();
+					break;
+				case "timer":
+					breakpointIds = await eventManager.setTimerEventBreakpoints();
+					break;
+				case "websocket":
+					breakpointIds = await eventManager.setWebSocketEventBreakpoints();
+					break;
+				default: throw new Error(`Unknown category: ${category}`);
+			}
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: `Set ${breakpointIds.length} ${category} event breakpoint(s)`,
+					category,
+					breakpointIds
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to set event breakpoints",
+					error: getErrorMessage$3(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleEventBreakpointRemove(args) {
+		try {
+			const breakpointId = argString(args, "breakpointId", "");
+			await this.ensureAdvancedFeaturesIfSupported();
+			const removed = await this.deps.debuggerManager.getEventManager().removeEventListenerBreakpoint(breakpointId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: removed,
+					message: removed ? "Event breakpoint removed" : "Event breakpoint not found",
+					breakpointId
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to remove event breakpoint",
+					error: getErrorMessage$3(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleEventBreakpointList(_args) {
+		try {
+			await this.ensureAdvancedFeaturesIfSupported();
+			const breakpoints = this.deps.debuggerManager.getEventManager().getAllEventBreakpoints();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: `Found ${breakpoints.length} event breakpoint(s)`,
+					breakpoints
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to list event breakpoints",
+					error: getErrorMessage$3(error)
+				}, null, 2)
+			}] };
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/watch-expressions.ts
+function getErrorMessage$2(error) {
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	return String(error);
+}
+var WatchExpressionsHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleWatchAdd(args) {
+		try {
+			const expression = argString(args, "expression", "");
+			const name = argString(args, "name");
+			const watchId = this.deps.debuggerManager.getWatchManager().addWatch(expression, name);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Watch expression added",
+					watchId,
+					expression,
+					name: name || expression
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to add watch expression",
+					error: getErrorMessage$2(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleWatchRemove(args) {
+		try {
+			const watchId = argString(args, "watchId", "");
+			const removed = this.deps.debuggerManager.getWatchManager().removeWatch(watchId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: removed,
+					message: removed ? "Watch expression removed" : "Watch expression not found",
+					watchId
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to remove watch expression",
+					error: getErrorMessage$2(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleWatchList(_args) {
+		try {
+			const watches = this.deps.debuggerManager.getWatchManager().getAllWatches();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: `Found ${watches.length} watch expression(s)`,
+					watches
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to list watch expressions",
+					error: getErrorMessage$2(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleWatchEvaluateAll(args) {
+		try {
+			const callFrameId = argString(args, "callFrameId");
+			const results = await this.deps.debuggerManager.getWatchManager().evaluateAll(callFrameId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: `Evaluated ${results.length} watch expression(s)`,
+					results
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to evaluate watch expressions",
+					error: getErrorMessage$2(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleWatchClearAll(_args) {
+		try {
+			this.deps.debuggerManager.getWatchManager().clearAll();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "All watch expressions cleared"
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to clear watch expressions",
+					error: getErrorMessage$2(error)
+				}, null, 2)
+			}] };
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/scope-inspection.ts
+const getErrorMessage$1 = (error, fallback) => {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string") return message;
+	}
+	return fallback;
+};
+var ScopeInspectionHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleGetScopeVariablesEnhanced(args) {
+		const callFrameId = argString(args, "callFrameId");
+		const includeObjectProperties = argBool(args, "includeObjectProperties");
+		const maxDepth = argNumber(args, "maxDepth");
+		const skipErrors = argBool(args, "skipErrors", true);
+		try {
+			const result = await this.deps.debuggerManager.getScopeVariables({
+				callFrameId,
+				includeObjectProperties,
+				maxDepth,
+				skipErrors
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: getErrorMessage$1(error, "Failed to get scope variables"),
+					error: String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleGetObjectProperties(args) {
+		const objectId = argString(args, "objectId", "");
+		if (!objectId) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				message: "objectId parameter is required"
+			}, null, 2)
+		}] };
+		try {
+			const properties = await this.deps.debuggerManager.getObjectPropertiesById(objectId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					propertyCount: properties.length,
+					properties
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: getErrorMessage$1(error, "Failed to get object properties"),
+					error: String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers/blackbox-handlers.ts
+function hasEnsureAdvancedFeatures(manager) {
+	return typeof manager.ensureAdvancedFeatures === "function";
+}
+function getErrorMessage(error) {
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	return String(error);
+}
+var BlackboxHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async ensureAdvancedFeaturesIfSupported() {
+		if (hasEnsureAdvancedFeatures(this.deps.debuggerManager)) await this.deps.debuggerManager.ensureAdvancedFeatures();
+	}
+	async getBlackboxManager() {
+		await this.ensureAdvancedFeaturesIfSupported();
+		return this.deps.debuggerManager.getBlackboxManager();
+	}
+	async handleBlackboxAdd(args) {
+		try {
+			const urlPattern = argString(args, "urlPattern", "");
+			await (await this.getBlackboxManager()).blackboxByPattern(urlPattern);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Script pattern blackboxed",
+					urlPattern
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to add blackbox pattern",
+					error: getErrorMessage(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleBlackboxAddCommon(_args) {
+		try {
+			await (await this.getBlackboxManager()).blackboxCommonLibraries();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Blackboxed common library patterns"
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to add common blackbox patterns",
+					error: getErrorMessage(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleBlackboxList(_args) {
+		try {
+			const patterns = (await this.getBlackboxManager()).getAllBlackboxedPatterns();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: `Found ${patterns.length} blackboxed pattern(s)`,
+					patterns
+				}, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Failed to list blackbox patterns",
+					error: getErrorMessage(error)
+				}, null, 2)
+			}] };
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/debugger/handlers.ts
+var DebuggerToolHandlers = class {
+	debuggerManager;
+	runtimeInspector;
+	debuggerControl;
+	debuggerStepping;
+	debuggerEvaluate;
+	debuggerState;
+	sessionManagement;
+	breakpointBasic;
+	breakpointException;
+	xhrBreakpoint;
+	eventBreakpoint;
+	watchExpressions;
+	scopeInspection;
+	blackbox;
+	constructor(debuggerManager, runtimeInspector, eventBus) {
+		this.debuggerManager = debuggerManager;
+		this.runtimeInspector = runtimeInspector;
+		const commonDeps = {
+			debuggerManager: this.debuggerManager,
+			runtimeInspector: this.runtimeInspector
+		};
+		this.debuggerControl = new DebuggerControlHandlers(commonDeps);
+		this.debuggerStepping = new DebuggerSteppingHandlers({ debuggerManager: this.debuggerManager });
+		this.debuggerEvaluate = new DebuggerEvaluateHandlers({ runtimeInspector: this.runtimeInspector });
+		this.debuggerState = new DebuggerStateHandlers(commonDeps);
+		this.sessionManagement = new SessionManagementHandlers({ debuggerManager: this.debuggerManager });
+		this.breakpointBasic = new BreakpointBasicHandlers({
+			debuggerManager: this.debuggerManager,
+			eventBus
+		});
+		this.breakpointException = new BreakpointExceptionHandlers({ debuggerManager: this.debuggerManager });
+		this.xhrBreakpoint = new XHRBreakpointHandlers({ debuggerManager: this.debuggerManager });
+		this.eventBreakpoint = new EventBreakpointHandlers({ debuggerManager: this.debuggerManager });
+		this.watchExpressions = new WatchExpressionsHandlers({ debuggerManager: this.debuggerManager });
+		this.scopeInspection = new ScopeInspectionHandlers(commonDeps);
+		this.blackbox = new BlackboxHandlers({ debuggerManager: this.debuggerManager });
+	}
+	async handleDebuggerLifecycle(args) {
+		return this.debuggerControl.handleDebuggerLifecycle(args);
+	}
+	async handleDebuggerPause(args) {
+		return this.debuggerControl.handleDebuggerPause(args);
+	}
+	async handleDebuggerResume(args) {
+		return this.debuggerControl.handleDebuggerResume(args);
+	}
+	async handleDebuggerStepInto(args) {
+		return this.debuggerStepping.handleDebuggerStepInto(args);
+	}
+	async handleDebuggerStepOver(args) {
+		return this.debuggerStepping.handleDebuggerStepOver(args);
+	}
+	async handleDebuggerStepOut(args) {
+		return this.debuggerStepping.handleDebuggerStepOut(args);
+	}
+	async handleDebuggerEvaluate(args) {
+		return this.debuggerEvaluate.handleDebuggerEvaluate(args);
+	}
+	async handleDebuggerEvaluateGlobal(args) {
+		return this.debuggerEvaluate.handleDebuggerEvaluateGlobal(args);
+	}
+	async handleDebuggerWaitForPaused(args) {
+		return this.debuggerState.handleDebuggerWaitForPaused(args);
+	}
+	async handleDebuggerGetPausedState(args) {
+		return this.debuggerState.handleDebuggerGetPausedState(args);
+	}
+	async handleGetCallStack(args) {
+		return this.debuggerState.handleGetCallStack(args);
+	}
+	async handleSaveSession(args) {
+		return this.sessionManagement.handleSaveSession(args);
+	}
+	async handleLoadSession(args) {
+		return this.sessionManagement.handleLoadSession(args);
+	}
+	async handleExportSession(args) {
+		return this.sessionManagement.handleExportSession(args);
+	}
+	async handleListSessions(args) {
+		return this.sessionManagement.handleListSessions(args);
+	}
+	async handleBreakpointSet(args) {
+		return this.breakpointBasic.handleBreakpointSet(args);
+	}
+	async handleBreakpointRemove(args) {
+		return this.breakpointBasic.handleBreakpointRemove(args);
+	}
+	async handleBreakpointList(args) {
+		return this.breakpointBasic.handleBreakpointList(args);
+	}
+	async handleBreakpointSetOnException(args) {
+		return this.breakpointException.handleBreakpointSetOnException(args);
+	}
+	async handleXHRBreakpointSet(args) {
+		return this.xhrBreakpoint.handleXHRBreakpointSet(args);
+	}
+	async handleXHRBreakpointRemove(args) {
+		return this.xhrBreakpoint.handleXHRBreakpointRemove(args);
+	}
+	async handleXHRBreakpointList(args) {
+		return this.xhrBreakpoint.handleXHRBreakpointList(args);
+	}
+	async handleEventBreakpointSet(args) {
+		return this.eventBreakpoint.handleEventBreakpointSet(args);
+	}
+	async handleEventBreakpointSetCategory(args) {
+		return this.eventBreakpoint.handleEventBreakpointSetCategory(args);
+	}
+	async handleEventBreakpointRemove(args) {
+		return this.eventBreakpoint.handleEventBreakpointRemove(args);
+	}
+	async handleEventBreakpointList(args) {
+		return this.eventBreakpoint.handleEventBreakpointList(args);
+	}
+	async handleWatchAdd(args) {
+		return this.watchExpressions.handleWatchAdd(args);
+	}
+	async handleWatchRemove(args) {
+		return this.watchExpressions.handleWatchRemove(args);
+	}
+	async handleWatchList(args) {
+		return this.watchExpressions.handleWatchList(args);
+	}
+	async handleWatchEvaluateAll(args) {
+		return this.watchExpressions.handleWatchEvaluateAll(args);
+	}
+	async handleWatchClearAll(args) {
+		return this.watchExpressions.handleWatchClearAll(args);
+	}
+	async handleGetScopeVariablesEnhanced(args) {
+		return this.scopeInspection.handleGetScopeVariablesEnhanced(args);
+	}
+	async handleGetObjectProperties(args) {
+		return this.scopeInspection.handleGetObjectProperties(args);
+	}
+	async handleBlackboxAdd(args) {
+		return this.blackbox.handleBlackboxAdd(args);
+	}
+	async handleBlackboxAddCommon(args) {
+		return this.blackbox.handleBlackboxAddCommon(args);
+	}
+	async handleBlackboxList(args) {
+		return this.blackbox.handleBlackboxList(args);
+	}
+	/** breakpoint(action, type, ...) — unified breakpoint management */
+	async handleBreakpoint(args) {
+		const action = String(args["action"] ?? "");
+		const type = String(args["type"] ?? "code");
+		switch (type) {
+			case "code":
+				switch (action) {
+					case "set": return this.breakpointBasic.handleBreakpointSet(args);
+					case "remove": return this.breakpointBasic.handleBreakpointRemove(args);
+					case "list": return this.breakpointBasic.handleBreakpointList(args);
+				}
+				break;
+			case "xhr":
+				switch (action) {
+					case "set": return this.xhrBreakpoint.handleXHRBreakpointSet(args);
+					case "remove": return this.xhrBreakpoint.handleXHRBreakpointRemove(args);
+					case "list": return this.xhrBreakpoint.handleXHRBreakpointList(args);
+				}
+				break;
+			case "event":
+				switch (action) {
+					case "set": return this.eventBreakpoint.handleEventBreakpointSet(args);
+					case "remove": return this.eventBreakpoint.handleEventBreakpointRemove(args);
+					case "list": return this.eventBreakpoint.handleEventBreakpointList(args);
+				}
+				break;
+			case "event_category":
+				if (action === "set") return this.eventBreakpoint.handleEventBreakpointSetCategory(args);
+				break;
+			case "exception":
+				if (action === "set") return this.breakpointException.handleBreakpointSetOnException(args);
+				break;
+		}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: `Invalid breakpoint action/type: ${action}/${type}. Valid types: code, xhr, event, event_category, exception. Valid actions: set, remove, list.`
+			})
+		}] };
+	}
+	/** watch(action) — unified watch expression management */
+	async handleWatch(args) {
+		const action = String(args["action"] ?? "");
+		switch (action) {
+			case "add": return this.watchExpressions.handleWatchAdd(args);
+			case "remove": return this.watchExpressions.handleWatchRemove(args);
+			case "list": return this.watchExpressions.handleWatchList(args);
+			case "evaluate_all": return this.watchExpressions.handleWatchEvaluateAll(args);
+			case "clear_all": return this.watchExpressions.handleWatchClearAll(args);
+			default: return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: `Unknown watch action: ${action}. Valid: add, remove, list, evaluate_all, clear_all`
+				})
+			}] };
+		}
+	}
+	/** debugger_step(direction: 'into'|'over'|'out') */
+	async handleDebuggerStep(args) {
+		const direction = String(args["direction"] ?? "over");
+		switch (direction) {
+			case "into": return this.debuggerStepping.handleDebuggerStepInto(args);
+			case "over": return this.debuggerStepping.handleDebuggerStepOver(args);
+			case "out": return this.debuggerStepping.handleDebuggerStepOut(args);
+			default: return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: `Unknown direction: ${direction}. Valid: into, over, out`
+				})
+			}] };
+		}
+	}
+	/** debugger_evaluate(context: 'frame'|'global') */
+	async handleDebuggerEvaluateDispatch(args) {
+		if (String(args["context"] ?? "frame") === "global") return this.debuggerEvaluate.handleDebuggerEvaluateGlobal(args);
+		return this.debuggerEvaluate.handleDebuggerEvaluate(args);
+	}
+	/** debugger_session(action: 'save'|'load'|'export'|'list') */
+	async handleDebuggerSession(args) {
+		const action = String(args["action"] ?? "");
+		switch (action) {
+			case "save": return this.sessionManagement.handleSaveSession(args);
+			case "load": return this.sessionManagement.handleLoadSession(args);
+			case "export": return this.sessionManagement.handleExportSession(args);
+			case "list": return this.sessionManagement.handleListSessions(args);
+			default: return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: `Unknown action: ${action}. Valid actions: save, load, export, list`
+				})
+			}] };
+		}
+	}
+};
+//#endregion
+export { DebuggerToolHandlers };