@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/streaming-Dal6utPp.mjs

@@ -0,0 +1,725 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { Hr as WS_PAYLOAD_PREVIEW_LIMIT, Ur as WS_PAYLOAD_SAMPLE_LIMIT } from "./constants-CDZLOoVv.mjs";
+import { o as evaluateOnNewDocumentWithTimeout, s as evaluateWithTimeout } from "./PageController-BPJNqqBN.mjs";
+import "./definitions-DcYLVLCo.mjs";
+//#region src/utils/RingBuffer.ts
+/**
+* Fixed-capacity ring buffer with O(1) push/shift.
+* Drop-in replacement for arrays used as bounded FIFO queues.
+*/
+var RingBuffer = class {
+	buf;
+	head = 0;
+	tail = 0;
+	count = 0;
+	constructor(capacity) {
+		this.capacity = capacity;
+		this.buf = Array.from({ length: capacity });
+	}
+	get length() {
+		return this.count;
+	}
+	push(item) {
+		if (this.count === this.buf.length) if (this.buf.length < this.capacity) this.grow();
+		else {
+			this.buf[this.tail] = item;
+			this.tail = (this.tail + 1) % this.buf.length;
+			this.head = (this.head + 1) % this.buf.length;
+			return;
+		}
+		this.buf[this.tail] = item;
+		this.tail = (this.tail + 1) % this.buf.length;
+		this.count++;
+	}
+	shift() {
+		if (this.count === 0) return void 0;
+		const item = this.buf[this.head];
+		this.buf[this.head] = void 0;
+		this.head = (this.head + 1) % this.buf.length;
+		this.count--;
+		return item;
+	}
+	clear() {
+		this.buf = Array.from({ length: Math.min(64, this.capacity) });
+		this.head = 0;
+		this.tail = 0;
+		this.count = 0;
+	}
+	*[Symbol.iterator]() {
+		for (let i = 0; i < this.count; i++) yield this.buf[(this.head + i) % this.buf.length];
+	}
+	toArray() {
+		const result = Array.from({ length: this.count });
+		for (let i = 0; i < this.count; i++) result[i] = this.buf[(this.head + i) % this.buf.length];
+		return result;
+	}
+	map(fn) {
+		const result = Array.from({ length: this.count });
+		for (let i = 0; i < this.count; i++) result[i] = fn(this.buf[(this.head + i) % this.buf.length], i);
+		return result;
+	}
+	grow() {
+		const newSize = Math.min(this.buf.length * 2, this.capacity);
+		const newBuf = Array.from({ length: newSize });
+		for (let i = 0; i < this.count; i++) newBuf[i] = this.buf[(this.head + i) % this.buf.length];
+		this.buf = newBuf;
+		this.head = 0;
+		this.tail = this.count;
+	}
+};
+//#endregion
+//#region src/server/domains/streaming/handlers/shared.ts
+function createStreamingSharedState(collector) {
+	return {
+		collector,
+		wsSession: null,
+		wsListeners: null,
+		wsConfig: {
+			enabled: false,
+			maxFrames: 1e3
+		},
+		wsFramesByRequest: /* @__PURE__ */ new Map(),
+		wsFrameOrder: new RingBuffer(1e3),
+		wsConnections: /* @__PURE__ */ new Map(),
+		sseConfig: { maxEvents: 2e3 }
+	};
+}
+function asJson(payload) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(payload, null, 2)
+	}] };
+}
+function parseOptionalStringArg(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	return normalized.length > 0 ? normalized : void 0;
+}
+function parseNumberArg(value, options) {
+	let parsed;
+	if (typeof value === "number" && Number.isFinite(value)) parsed = value;
+	else if (typeof value === "string") {
+		const n = Number(value.trim());
+		if (Number.isFinite(n)) parsed = n;
+	}
+	if (parsed === void 0) parsed = options.defaultValue;
+	if (options.integer) parsed = Math.trunc(parsed);
+	if (parsed < options.min) parsed = options.min;
+	if (parsed > options.max) parsed = options.max;
+	return parsed;
+}
+function parseWsDirection(value) {
+	if (value === "sent" || value === "received" || value === "all") return value;
+	return "all";
+}
+function compileRegex(pattern) {
+	try {
+		return { regex: new RegExp(pattern) };
+	} catch (error) {
+		return { error: error instanceof Error ? error.message : String(error) };
+	}
+}
+//#endregion
+//#region src/server/domains/streaming/handlers/ws-handlers.ts
+/**
+* WebSocket monitoring handlers — enable, disable, get frames, get connections.
+*/
+const asRecord = (value) => typeof value === "object" && value !== null ? value : void 0;
+const getStringField = (value, key) => {
+	const field = asRecord(value)?.[key];
+	return typeof field === "string" ? field : void 0;
+};
+const getNumberField = (value, key) => {
+	const field = asRecord(value)?.[key];
+	return typeof field === "number" ? field : void 0;
+};
+const getRecordField = (value, key) => {
+	const nested = asRecord(value)?.[key];
+	return asRecord(nested);
+};
+var WsHandlers = class {
+	constructor(s) {
+		this.s = s;
+	}
+	async teardownWsSession() {
+		if (this.s.wsSession && this.s.wsListeners) {
+			try {
+				this.s.wsSession.off("Network.webSocketCreated", this.s.wsListeners.created);
+			} catch (e) {
+				logger.debug("[ws-teardown] Failed to remove webSocketCreated listener", e);
+			}
+			try {
+				this.s.wsSession.off("Network.webSocketClosed", this.s.wsListeners.closed);
+			} catch (e) {
+				logger.debug("[ws-teardown] Failed to remove webSocketClosed listener", e);
+			}
+			try {
+				this.s.wsSession.off("Network.webSocketHandshakeResponseReceived", this.s.wsListeners.handshake);
+			} catch (e) {
+				logger.debug("[ws-teardown] Failed to remove handshakeResponseReceived listener", e);
+			}
+			try {
+				this.s.wsSession.off("Network.webSocketFrameSent", this.s.wsListeners.frameSent);
+			} catch (e) {
+				logger.debug("[ws-teardown] Failed to remove webSocketFrameSent listener", e);
+			}
+			try {
+				this.s.wsSession.off("Network.webSocketFrameReceived", this.s.wsListeners.frameReceived);
+			} catch (e) {
+				logger.debug("[ws-teardown] Failed to remove webSocketFrameReceived listener", e);
+			}
+		}
+		if (this.s.wsSession) try {
+			await this.s.wsSession.detach();
+		} catch (e) {
+			logger.debug("[ws-teardown] Failed to detach CDP session", e);
+		}
+		this.s.wsSession = null;
+		this.s.wsListeners = null;
+	}
+	handleWsFrame(direction, params) {
+		const requestId = getStringField(params, "requestId");
+		if (!requestId) return;
+		if (!this.s.wsConnections.get(requestId)) {
+			if (this.s.wsConfig.urlFilter) return;
+			this.s.wsConnections.set(requestId, {
+				requestId,
+				url: "unknown",
+				status: "open",
+				framesCount: 0,
+				createdTimestamp: Date.now() / 1e3
+			});
+		}
+		const connection = this.s.wsConnections.get(requestId);
+		if (!connection) return;
+		if (this.s.wsConfig.urlFilter && connection.url !== "unknown" && !this.s.wsConfig.urlFilter.test(connection.url)) return;
+		const response = getRecordField(params, "response");
+		const opcode = getNumberField(response, "opcode") ?? -1;
+		const payloadData = getStringField(response, "payloadData") ?? "";
+		const payloadPreview = payloadData.length > WS_PAYLOAD_PREVIEW_LIMIT ? `${payloadData.slice(0, WS_PAYLOAD_PREVIEW_LIMIT)}…` : payloadData;
+		const payloadSample = payloadData.length > WS_PAYLOAD_SAMPLE_LIMIT ? payloadData.slice(0, WS_PAYLOAD_SAMPLE_LIMIT) : payloadData;
+		const frame = {
+			requestId,
+			timestamp: getNumberField(params, "timestamp") ?? Date.now() / 1e3,
+			direction,
+			opcode,
+			payloadLength: payloadData.length,
+			payloadPreview,
+			payloadSample,
+			isBinary: opcode === 2
+		};
+		this.appendWsFrame(requestId, frame);
+	}
+	appendWsFrame(requestId, frame) {
+		const list = this.s.wsFramesByRequest.get(requestId) ?? [];
+		list.push(frame);
+		this.s.wsFramesByRequest.set(requestId, list);
+		const connection = this.s.wsConnections.get(requestId);
+		if (connection) {
+			connection.framesCount += 1;
+			if (connection.status === "connecting") connection.status = "open";
+		}
+		this.s.wsFrameOrder.push({
+			requestId,
+			frame
+		});
+		this.enforceWsFrameLimit();
+	}
+	enforceWsFrameLimit() {
+		while (this.s.wsFrameOrder.length > this.s.wsConfig.maxFrames) {
+			const oldest = this.s.wsFrameOrder.shift();
+			if (!oldest) break;
+			const bucket = this.s.wsFramesByRequest.get(oldest.requestId);
+			if (bucket && bucket.length > 0) {
+				bucket.shift();
+				if (bucket.length === 0) this.s.wsFramesByRequest.delete(oldest.requestId);
+				else this.s.wsFramesByRequest.set(oldest.requestId, bucket);
+			}
+			const connection = this.s.wsConnections.get(oldest.requestId);
+			if (connection) connection.framesCount = Math.max(0, connection.framesCount - 1);
+		}
+	}
+	getWsFrameStats() {
+		let sent = 0;
+		let received = 0;
+		for (const entry of this.s.wsFrameOrder) if (entry.frame.direction === "sent") sent += 1;
+		else received += 1;
+		return {
+			total: this.s.wsFrameOrder.length,
+			sent,
+			received
+		};
+	}
+	async handleWsMonitorEnable(args) {
+		const maxFrames = parseNumberArg(args.maxFrames, {
+			defaultValue: 1e3,
+			min: 1,
+			max: 2e4,
+			integer: true
+		});
+		const urlFilterRaw = parseOptionalStringArg(args.urlFilter);
+		let urlFilter;
+		if (urlFilterRaw) {
+			const compiled = compileRegex(urlFilterRaw);
+			if (compiled.error) return asJson({
+				success: false,
+				error: `Invalid urlFilter regex: ${compiled.error}`
+			});
+			urlFilter = compiled.regex;
+		}
+		await this.teardownWsSession();
+		this.s.wsFramesByRequest.clear();
+		this.s.wsFrameOrder = new RingBuffer(maxFrames);
+		this.s.wsConnections.clear();
+		const session = await (await this.s.collector.getActivePage()).createCDPSession();
+		await session.send("Network.enable");
+		const listeners = {
+			created: (params) => {
+				const reqId = getStringField(params, "requestId");
+				const url = getStringField(params, "url");
+				if (!reqId || !url) return;
+				if (urlFilter && !urlFilter.test(url)) return;
+				const existing = this.s.wsConnections.get(reqId);
+				this.s.wsConnections.set(reqId, {
+					requestId: reqId,
+					url,
+					status: existing?.status ?? "connecting",
+					framesCount: existing?.framesCount ?? 0,
+					createdTimestamp: existing?.createdTimestamp ?? Date.now() / 1e3,
+					closedTimestamp: existing?.closedTimestamp,
+					handshakeStatus: existing?.handshakeStatus
+				});
+			},
+			closed: (params) => {
+				const reqId = getStringField(params, "requestId");
+				if (!reqId) return;
+				const connection = this.s.wsConnections.get(reqId);
+				if (!connection) return;
+				connection.status = "closed";
+				const ts = getNumberField(params, "timestamp");
+				connection.closedTimestamp = ts !== void 0 ? ts : Date.now() / 1e3;
+			},
+			handshake: (params) => {
+				const reqId = getStringField(params, "requestId");
+				if (!reqId) return;
+				const connection = this.s.wsConnections.get(reqId);
+				if (!connection) return;
+				const status = getNumberField(getRecordField(params, "response"), "status");
+				if (status !== void 0) {
+					connection.handshakeStatus = status;
+					connection.status = status >= 100 && status < 400 ? "open" : "error";
+				}
+			},
+			frameSent: (params) => {
+				this.handleWsFrame("sent", params);
+			},
+			frameReceived: (params) => {
+				this.handleWsFrame("received", params);
+			}
+		};
+		session.on("Network.webSocketCreated", listeners.created);
+		session.on("Network.webSocketClosed", listeners.closed);
+		session.on("Network.webSocketHandshakeResponseReceived", listeners.handshake);
+		session.on("Network.webSocketFrameSent", listeners.frameSent);
+		session.on("Network.webSocketFrameReceived", listeners.frameReceived);
+		this.s.wsSession = session;
+		this.s.wsListeners = listeners;
+		this.s.wsConfig = {
+			enabled: true,
+			maxFrames,
+			urlFilterRaw,
+			urlFilter
+		};
+		return asJson({
+			success: true,
+			message: "WebSocket monitor enabled",
+			config: {
+				maxFrames,
+				urlFilter: urlFilterRaw ?? null
+			},
+			stats: {
+				trackedConnections: this.s.wsConnections.size,
+				capturedFrames: this.s.wsFrameOrder.length
+			}
+		});
+	}
+	async handleWsMonitorDisable(_args) {
+		const stats = this.getWsFrameStats();
+		const connections = Array.from(this.s.wsConnections.values());
+		const summary = {
+			success: true,
+			message: "WebSocket monitor disabled",
+			config: {
+				maxFrames: this.s.wsConfig.maxFrames,
+				urlFilter: this.s.wsConfig.urlFilterRaw ?? null
+			},
+			summary: {
+				trackedConnections: connections.length,
+				activeConnections: connections.filter((c) => c.status === "open" || c.status === "connecting").length,
+				closedConnections: connections.filter((c) => c.status === "closed").length,
+				totalFrames: stats.total,
+				sentFrames: stats.sent,
+				receivedFrames: stats.received
+			}
+		};
+		await this.teardownWsSession();
+		this.s.wsConfig = {
+			...this.s.wsConfig,
+			enabled: false
+		};
+		return asJson(summary);
+	}
+	async handleWsGetFrames(args) {
+		const direction = parseWsDirection(args.direction);
+		const limit = parseNumberArg(args.limit, {
+			defaultValue: 100,
+			min: 1,
+			max: 5e3,
+			integer: true
+		});
+		const offset = parseNumberArg(args.offset, {
+			defaultValue: 0,
+			min: 0,
+			max: Number.MAX_SAFE_INTEGER,
+			integer: true
+		});
+		const payloadFilterRaw = parseOptionalStringArg(args.payloadFilter);
+		let payloadFilter;
+		if (payloadFilterRaw) {
+			const compiled = compileRegex(payloadFilterRaw);
+			if (compiled.error) return asJson({
+				success: false,
+				error: `Invalid payloadFilter regex: ${compiled.error}`
+			});
+			payloadFilter = compiled.regex;
+		}
+		const filtered = this.s.wsFrameOrder.toArray().map((entry) => entry.frame).filter((frame) => direction === "all" ? true : frame.direction === direction).filter((frame) => payloadFilter ? payloadFilter.test(frame.payloadSample) : true);
+		const pageItems = filtered.slice(offset, offset + limit).map((frame) => ({
+			requestId: frame.requestId,
+			timestamp: frame.timestamp,
+			direction: frame.direction,
+			opcode: frame.opcode,
+			payloadLength: frame.payloadLength,
+			payloadPreview: frame.payloadPreview,
+			isBinary: frame.isBinary
+		}));
+		return asJson({
+			success: true,
+			monitorEnabled: this.s.wsConfig.enabled,
+			filters: {
+				direction,
+				payloadFilter: payloadFilterRaw ?? null
+			},
+			page: {
+				offset,
+				limit,
+				returned: pageItems.length,
+				totalAfterFilter: filtered.length,
+				hasMore: offset + pageItems.length < filtered.length,
+				nextOffset: offset + pageItems.length < filtered.length ? offset + pageItems.length : null
+			},
+			frames: pageItems
+		});
+	}
+	async handleWsGetConnections(_args) {
+		const connections = Array.from(this.s.wsConnections.values()).toSorted((a, b) => a.createdTimestamp - b.createdTimestamp).map((conn) => ({
+			requestId: conn.requestId,
+			url: conn.url,
+			status: conn.status,
+			framesCount: conn.framesCount
+		}));
+		return asJson({
+			success: true,
+			monitorEnabled: this.s.wsConfig.enabled,
+			total: connections.length,
+			connections
+		});
+	}
+};
+//#endregion
+//#region src/server/domains/streaming/handlers/sse-handlers.ts
+function sseInjectionFn(config) {
+	const globalWindow = window;
+	if (!globalWindow.__jshookSSEMonitor) globalWindow.__jshookSSEMonitor = {
+		enabled: true,
+		patched: false,
+		maxEvents: config.maxEvents,
+		urlFilterRaw: config.urlFilterRaw,
+		events: [],
+		sources: {}
+	};
+	const state = globalWindow.__jshookSSEMonitor;
+	state.enabled = true;
+	state.maxEvents = config.maxEvents;
+	state.urlFilterRaw = config.urlFilterRaw;
+	if (state.events.length > state.maxEvents) state.events = state.events.slice(-state.maxEvents);
+	const shouldCapture = (sourceUrl) => {
+		if (!state.urlFilterRaw) return true;
+		try {
+			return new RegExp(state.urlFilterRaw).test(sourceUrl);
+		} catch {
+			return true;
+		}
+	};
+	const toDataString = (value) => {
+		if (typeof value === "string") return value;
+		if (value === null || value === void 0) return "";
+		if (typeof value === "object") try {
+			return JSON.stringify(value);
+		} catch {
+			return "[unserializable]";
+		}
+		return String(value);
+	};
+	const pushEvent = (sourceUrl, eventType, rawData, lastEventId) => {
+		if (!state.enabled || !shouldCapture(sourceUrl)) return;
+		const dataString = toDataString(rawData);
+		const record = {
+			sourceUrl,
+			eventType,
+			dataPreview: dataString.length > 200 ? `${dataString.slice(0, 200)}…` : dataString,
+			dataLength: dataString.length,
+			lastEventId,
+			timestamp: Date.now()
+		};
+		state.events.push(record);
+		while (state.events.length > state.maxEvents) state.events.shift();
+		const source = state.sources[sourceUrl] ?? {
+			url: sourceUrl,
+			status: "connecting",
+			eventCount: 0
+		};
+		source.eventCount += 1;
+		source.lastEventTimestamp = record.timestamp;
+		state.sources[sourceUrl] = source;
+	};
+	if (typeof globalWindow.EventSource === "undefined") return {
+		success: false,
+		error: "EventSource is not available in current page context"
+	};
+	if (!state.patched) {
+		const OriginalEventSource = globalWindow.EventSource;
+		const WrappedEventSource = function(url, eventSourceInitDict) {
+			const sourceUrl = String(url);
+			const es = new OriginalEventSource(url, eventSourceInitDict);
+			if (shouldCapture(sourceUrl)) {
+				const source = state.sources[sourceUrl] ?? {
+					url: sourceUrl,
+					status: "connecting",
+					eventCount: 0
+				};
+				state.sources[sourceUrl] = source;
+			}
+			es.addEventListener("open", () => {
+				const source = state.sources[sourceUrl];
+				if (source) source.status = "open";
+				pushEvent(sourceUrl, "open", "", null);
+			});
+			es.addEventListener("error", () => {
+				const source = state.sources[sourceUrl];
+				if (source) source.status = "error";
+				pushEvent(sourceUrl, "error", "", null);
+			});
+			es.addEventListener("message", (event) => {
+				const lastEventId = typeof event.lastEventId === "string" && event.lastEventId.length > 0 ? event.lastEventId : null;
+				pushEvent(sourceUrl, event.type || "message", event.data, lastEventId);
+			});
+			const originalAddEventListener = es.addEventListener.bind(es);
+			const callOriginalAddEventListener = (type, listener, listenerOpts) => {
+				originalAddEventListener(type, listener, listenerOpts);
+			};
+			const wrappedAddEventListener = (type, listener, listenerOpts) => {
+				if (type !== "message" && type !== "open" && type !== "error" && listener) {
+					const wrapped = (evt) => {
+						const messageEvent = evt;
+						const lastEventId = typeof messageEvent.lastEventId === "string" && messageEvent.lastEventId.length > 0 ? messageEvent.lastEventId : null;
+						pushEvent(sourceUrl, type, messageEvent.data, lastEventId);
+						if (typeof listener === "function") listener.call(es, evt);
+						else listener.handleEvent(evt);
+					};
+					callOriginalAddEventListener(type, wrapped, listenerOpts);
+					return;
+				}
+				callOriginalAddEventListener(type, listener, listenerOpts);
+			};
+			Object.defineProperty(es, "addEventListener", {
+				value: wrappedAddEventListener,
+				configurable: true,
+				writable: true
+			});
+			return es;
+		};
+		WrappedEventSource.prototype = OriginalEventSource.prototype;
+		try {
+			Object.defineProperty(WrappedEventSource, "CONNECTING", { value: OriginalEventSource.CONNECTING });
+			Object.defineProperty(WrappedEventSource, "OPEN", { value: OriginalEventSource.OPEN });
+			Object.defineProperty(WrappedEventSource, "CLOSED", { value: OriginalEventSource.CLOSED });
+		} catch {}
+		globalWindow.EventSource = WrappedEventSource;
+		state.originalEventSource = OriginalEventSource;
+		state.patched = true;
+	}
+	return {
+		success: true,
+		message: "SSE monitor enabled",
+		patched: state.patched,
+		urlFilter: state.urlFilterRaw,
+		maxEvents: state.maxEvents,
+		existingEvents: state.events.length
+	};
+}
+var SseHandlers = class {
+	constructor(s) {
+		this.s = s;
+	}
+	async enableSseInterceptor(maxEvents, urlFilterRaw, options) {
+		const page = await this.s.collector.getActivePage();
+		if (options?.persistent) {
+			await evaluateOnNewDocumentWithTimeout(page, sseInjectionFn, {
+				maxEvents,
+				urlFilterRaw
+			});
+			return {
+				success: true,
+				message: "SSE monitor enabled (persistent — survives navigations)",
+				patched: true,
+				urlFilter: urlFilterRaw,
+				maxEvents,
+				existingEvents: 0
+			};
+		}
+		return await evaluateWithTimeout(page, sseInjectionFn, {
+			maxEvents,
+			urlFilterRaw
+		});
+	}
+	async handleSseMonitorEnable(args) {
+		const maxEvents = parseNumberArg(args.maxEvents, {
+			defaultValue: 2e3,
+			min: 1,
+			max: 5e4,
+			integer: true
+		});
+		const urlFilterRaw = parseOptionalStringArg(args.urlFilter);
+		if (urlFilterRaw) {
+			const compiled = compileRegex(urlFilterRaw);
+			if (compiled.error) return asJson({
+				success: false,
+				error: `Invalid urlFilter regex: ${compiled.error}`
+			});
+		}
+		const persistent = args.persistent === true;
+		const result = await this.enableSseInterceptor(maxEvents, urlFilterRaw, { persistent });
+		if (!result.success) return asJson(result);
+		this.s.sseConfig = {
+			maxEvents,
+			urlFilterRaw
+		};
+		return asJson({
+			success: true,
+			message: result.message,
+			patched: result.patched,
+			config: {
+				maxEvents: this.s.sseConfig.maxEvents,
+				urlFilter: this.s.sseConfig.urlFilterRaw ?? null
+			},
+			existingEvents: result.existingEvents
+		});
+	}
+	async handleSseGetEvents(args) {
+		const sourceUrl = parseOptionalStringArg(args.sourceUrl);
+		const eventType = parseOptionalStringArg(args.eventType);
+		const limit = parseNumberArg(args.limit, {
+			defaultValue: 100,
+			min: 1,
+			max: 5e3,
+			integer: true
+		});
+		const offset = parseNumberArg(args.offset, {
+			defaultValue: 0,
+			min: 0,
+			max: Number.MAX_SAFE_INTEGER,
+			integer: true
+		});
+		return asJson(await evaluateWithTimeout(await this.s.collector.getActivePage(), (query) => {
+			const state = window.__jshookSSEMonitor;
+			if (!state) return {
+				success: false,
+				message: "SSE monitor is not enabled. Call sse_monitor_enable first."
+			};
+			let events = state.events;
+			if (query.sourceUrl) events = events.filter((evt) => evt.sourceUrl === query.sourceUrl);
+			if (query.eventType) events = events.filter((evt) => evt.eventType === query.eventType);
+			const totalAfterFilter = events.length;
+			const paged = events.slice(query.offset, query.offset + query.limit);
+			return {
+				success: true,
+				filters: {
+					sourceUrl: query.sourceUrl ?? null,
+					eventType: query.eventType ?? null
+				},
+				page: {
+					offset: query.offset,
+					limit: query.limit,
+					returned: paged.length,
+					totalAfterFilter,
+					hasMore: query.offset + paged.length < totalAfterFilter,
+					nextOffset: query.offset + paged.length < totalAfterFilter ? query.offset + paged.length : null
+				},
+				monitor: {
+					enabled: state.enabled,
+					patched: state.patched,
+					maxEvents: state.maxEvents,
+					urlFilter: state.urlFilterRaw ?? null,
+					sourceCount: Object.keys(state.sources).length
+				},
+				events: paged
+			};
+		}, {
+			sourceUrl,
+			eventType,
+			limit,
+			offset
+		}));
+	}
+};
+//#endregion
+//#region src/server/domains/streaming/handlers.impl.core.ts
+var StreamingToolHandlers = class {
+	collector;
+	state;
+	ws;
+	sse;
+	get wsConnections() {
+		return this.state.wsConnections;
+	}
+	get wsFrameOrder() {
+		return this.state.wsFrameOrder;
+	}
+	get wsConfig() {
+		return this.state.wsConfig;
+	}
+	get wsFramesByRequest() {
+		return this.state.wsFramesByRequest;
+	}
+	get sseConfig() {
+		return this.state.sseConfig;
+	}
+	constructor(collector) {
+		this.collector = collector;
+		this.state = createStreamingSharedState(collector);
+		this.ws = new WsHandlers(this.state);
+		this.sse = new SseHandlers(this.state);
+	}
+	handleWsMonitorDispatch = (args) => {
+		return String(args["action"] ?? "") === "disable" ? this.ws.handleWsMonitorDisable(args) : this.ws.handleWsMonitorEnable(args);
+	};
+	handleWsMonitorEnable = (args) => this.ws.handleWsMonitorEnable(args);
+	handleWsMonitorDisable = (args) => this.ws.handleWsMonitorDisable(args);
+	handleWsGetFrames = (args) => this.ws.handleWsGetFrames(args);
+	handleWsGetConnections = (args) => this.ws.handleWsGetConnections(args);
+	handleSseMonitorEnable = (args) => this.sse.handleSseMonitorEnable(args);
+	handleSseGetEvents = (args) => this.sse.handleSseGetEvents(args);
+};
+//#endregion
+export { StreamingToolHandlers };