@jshookmcp/jshook 0.3.0 → 0.3.1

package/dist/debugger-RS3RSAqs.mjs

@@ -1,1288 +0,0 @@
-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-B4cY5Vx5.mjs";
-import "./definitions-BbkvZkiv.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();
-		try {
-			const pausedState = await this.deps.debuggerManager.waitForPaused(500);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: true,
-					paused: true,
-					message: "Execution paused",
-					reason: pausedState.reason,
-					location: pausedState.callFrames[0]?.location
-				}, null, 2)
-			}] };
-		} catch {
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: true,
-					paused: false,
-					message: "Pause requested; no paused event observed yet"
-				}, null, 2)
-			}] };
-		}
-	}
-	async handleDebuggerResume(_args) {
-		const wasPaused = this.deps.debuggerManager.getPausedState() !== null;
-		await this.deps.debuggerManager.resume();
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: true,
-				resumed: wasPaused,
-				message: wasPaused ? "Execution resumed" : "Resume requested; debugger was not paused"
-			}, 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 one with breakpoint({ action: 'set', type: 'code', ... }) 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 one with breakpoint({ action: 'set', type: 'code', ... }) 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 one with breakpoint({ action: 'set', type: 'code', ... }) 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 };