@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/TraceRecorder-DgxyVbdQ.mjs

@@ -1,519 +0,0 @@
-import { n as __require } from "./chunk-CjcI7cDX.mjs";
-import { i as resolveArtifactPath } from "./artifacts-Bk2-_uPq.mjs";
-import { t as formatBetterSqlite3Error } from "./betterSqlite3-0pqusHHH.mjs";
-import { randomUUID } from "node:crypto";
-//#region src/modules/trace/TraceDB.ts
-let Database;
-try {
-	Database = __require("better-sqlite3");
-} catch {}
-/** Write-modify SQL keywords rejected by the safety filter. */
-const WRITE_SQL_PATTERN = /\b(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|ATTACH|DETACH|REPLACE|PRAGMA)\b/i;
-var TraceDB = class {
-	db;
-	batchSize;
-	eventBuffer = [];
-	memoryBuffer = [];
-	closed = false;
-	insertEventStmt;
-	insertDeltaStmt;
-	insertSnapshotStmt;
-	upsertMetadataStmt;
-	constructor(options) {
-		this.options = options;
-		if (!Database) throw new Error(formatBetterSqlite3Error(/* @__PURE__ */ new Error("Cannot find package 'better-sqlite3'")));
-		try {
-			this.db = new Database(options.dbPath);
-		} catch (error) {
-			throw new Error(formatBetterSqlite3Error(error), { cause: error });
-		}
-		this.batchSize = options.batchSize ?? 200;
-		this.db.pragma("journal_mode = WAL");
-		this.db.pragma("synchronous = NORMAL");
-		this.createSchema();
-		this.prepareStatements();
-	}
-	/** Database file path. */
-	get dbPath() {
-		return this.options.dbPath;
-	}
-	createSchema() {
-		this.db.exec(`
-      CREATE TABLE IF NOT EXISTS events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        timestamp REAL NOT NULL,
-        category TEXT NOT NULL,
-        event_type TEXT NOT NULL,
-        data TEXT NOT NULL DEFAULT '{}',
-        script_id TEXT,
-        line_number INTEGER
-      );
-      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_events_category_type ON events(category, event_type);
-      CREATE INDEX IF NOT EXISTS idx_events_script_id ON events(script_id);
-
-      CREATE TABLE IF NOT EXISTS memory_deltas (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        timestamp REAL NOT NULL,
-        address TEXT NOT NULL,
-        old_value TEXT NOT NULL,
-        new_value TEXT NOT NULL,
-        size INTEGER NOT NULL,
-        value_type TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_memory_timestamp ON memory_deltas(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_memory_address ON memory_deltas(address);
-
-      CREATE TABLE IF NOT EXISTS heap_snapshots (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        timestamp REAL NOT NULL,
-        snapshot_data BLOB,
-        summary TEXT NOT NULL DEFAULT '{}'
-      );
-
-      CREATE TABLE IF NOT EXISTS metadata (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-    `);
-	}
-	prepareStatements() {
-		this.insertEventStmt = this.db.prepare(`
-      INSERT INTO events (timestamp, category, event_type, data, script_id, line_number)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-		this.insertDeltaStmt = this.db.prepare(`
-      INSERT INTO memory_deltas (timestamp, address, old_value, new_value, size, value_type)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-		this.insertSnapshotStmt = this.db.prepare(`
-      INSERT INTO heap_snapshots (timestamp, snapshot_data, summary)
-      VALUES (?, ?, ?)
-    `);
-		this.upsertMetadataStmt = this.db.prepare(`
-      INSERT INTO metadata (key, value) VALUES (?, ?)
-      ON CONFLICT(key) DO UPDATE SET value = excluded.value
-    `);
-	}
-	/** Buffer an event for batched insertion. */
-	insertEvent(event) {
-		this.ensureOpen();
-		this.eventBuffer.push(event);
-		if (this.eventBuffer.length >= this.batchSize) this.flush();
-	}
-	/** Buffer a memory delta for batched insertion. */
-	insertMemoryDelta(delta) {
-		this.ensureOpen();
-		this.memoryBuffer.push(delta);
-		if (this.memoryBuffer.length >= this.batchSize) this.flush();
-	}
-	/** Insert a heap snapshot immediately (infrequent, large). */
-	insertHeapSnapshot(snapshot) {
-		this.ensureOpen();
-		this.insertSnapshotStmt.run(snapshot.timestamp, snapshot.snapshotData, snapshot.summary);
-	}
-	/** Set or update a metadata key-value pair. */
-	setMetadata(key, value) {
-		this.ensureOpen();
-		this.upsertMetadataStmt.run(key, value);
-	}
-	/** Flush all buffered events and memory deltas to disk in a single transaction. */
-	flush() {
-		if (this.closed) return;
-		this.db.transaction(() => {
-			for (const e of this.eventBuffer) this.insertEventStmt.run(e.timestamp, e.category, e.eventType, e.data, e.scriptId, e.lineNumber);
-			for (const d of this.memoryBuffer) this.insertDeltaStmt.run(d.timestamp, d.address, d.oldValue, d.newValue, d.size, d.valueType);
-		})();
-		this.eventBuffer = [];
-		this.memoryBuffer = [];
-	}
-	/**
-	* Execute a read-only SQL query against the trace database.
-	* Write statements are rejected for safety.
-	*/
-	query(sql) {
-		this.ensureOpen();
-		if (WRITE_SQL_PATTERN.test(sql)) throw new Error(`Write operations are not allowed in trace queries. Rejected SQL: ${sql.slice(0, 100)}`);
-		const stmt = this.db.prepare(sql);
-		const rows = stmt.all();
-		if (rows.length === 0) return {
-			columns: stmt.columns().map((c) => c.name),
-			rows: [],
-			rowCount: 0
-		};
-		const columns = Object.keys(rows[0]);
-		return {
-			columns,
-			rows: rows.map((row) => columns.map((col) => row[col])),
-			rowCount: rows.length
-		};
-	}
-	/** Get events within a time range. */
-	getEventsByTimeRange(start, end) {
-		this.ensureOpen();
-		this.flush();
-		return this.db.prepare(`
-      SELECT id, timestamp, category, event_type, data, script_id, line_number
-      FROM events
-      WHERE timestamp >= ? AND timestamp <= ?
-      ORDER BY timestamp ASC
-    `).all(start, end).map((row) => ({
-			id: row["id"],
-			timestamp: row["timestamp"],
-			category: row["category"],
-			eventType: row["event_type"],
-			data: row["data"],
-			scriptId: row["script_id"] ?? null,
-			lineNumber: row["line_number"] ?? null
-		}));
-	}
-	/** Get memory deltas for a specific address. */
-	getMemoryDeltasByAddress(address) {
-		this.ensureOpen();
-		this.flush();
-		return this.db.prepare(`
-      SELECT id, timestamp, address, old_value, new_value, size, value_type
-      FROM memory_deltas
-      WHERE address = ?
-      ORDER BY timestamp ASC
-    `).all(address).map((row) => ({
-			id: row["id"],
-			timestamp: row["timestamp"],
-			address: row["address"],
-			oldValue: row["old_value"],
-			newValue: row["new_value"],
-			size: row["size"],
-			valueType: row["value_type"]
-		}));
-	}
-	/** Get all heap snapshots ordered by timestamp. */
-	getHeapSnapshots() {
-		this.ensureOpen();
-		return this.db.prepare(`
-      SELECT id, timestamp, snapshot_data, summary
-      FROM heap_snapshots
-      ORDER BY timestamp ASC
-    `).all().map((row) => ({
-			id: row["id"],
-			timestamp: row["timestamp"],
-			snapshotData: row["snapshot_data"],
-			summary: row["summary"]
-		}));
-	}
-	/** Get all metadata as a key-value record. */
-	getMetadata() {
-		this.ensureOpen();
-		const rows = this.db.prepare("SELECT key, value FROM metadata").all();
-		const result = {};
-		for (const row of rows) result[row.key] = row.value;
-		return result;
-	}
-	/** Flush buffers and close the database connection. */
-	close() {
-		if (this.closed) return;
-		this.flush();
-		this.db.close();
-		this.closed = true;
-	}
-	/** Check if the database is closed. */
-	get isClosed() {
-		return this.closed;
-	}
-	ensureOpen() {
-		if (this.closed) throw new Error("TraceDB is closed");
-	}
-};
-//#endregion
-//#region src/modules/trace/TraceRecorder.ts
-/**
-* TraceRecorder — Event capture engine for time-travel debugging.
-*
-* Subscribes to EventBus events and CDP session events, capturing them
-* into a TraceDB instance. Handles recording lifecycle (start/stop),
-* selective CDP domain filtering, and differential memory tracing.
-*/
-/**
-* Known CDP events to subscribe to per domain.
-* CDP sessions don't support wildcards, so we explicitly list relevant events.
-*/
-const CDP_EVENTS_BY_DOMAIN = {
-	Debugger: [
-		"Debugger.paused",
-		"Debugger.resumed",
-		"Debugger.scriptParsed"
-	],
-	Runtime: ["Runtime.consoleAPICalled", "Runtime.exceptionThrown"],
-	Network: [
-		"Network.requestWillBeSent",
-		"Network.responseReceived",
-		"Network.loadingFinished"
-	],
-	Page: ["Page.navigatedWithinDocument", "Page.loadEventFired"]
-};
-const DEFAULT_CDP_DOMAINS = [
-	"Debugger",
-	"Runtime",
-	"Network",
-	"Page"
-];
-var TraceRecorder = class {
-	db = null;
-	state = "idle";
-	session = null;
-	eventBusUnsub = null;
-	cdpListeners = /* @__PURE__ */ new Map();
-	cdpSession = null;
-	eventCount = 0;
-	memoryDeltaCount = 0;
-	heapSnapshotCount = 0;
-	/**
-	* Start recording events into a new trace database.
-	*
-	* @param eventBus The server EventBus to subscribe to
-	* @param cdpSession Optional CDP session for browser event recording
-	* @param options Recording configuration
-	* @returns The recording session details
-	*/
-	async start(eventBus, cdpSession, options) {
-		if (this.state === "recording") throw new Error("Recording already in progress");
-		const sessionId = randomUUID();
-		const { absolutePath } = await resolveArtifactPath({
-			category: "traces",
-			toolName: "trace_recorder",
-			target: sessionId.slice(0, 8),
-			ext: "db"
-		});
-		this.db = new TraceDB({ dbPath: absolutePath });
-		this.eventCount = 0;
-		this.memoryDeltaCount = 0;
-		this.heapSnapshotCount = 0;
-		const startedAt = Date.now();
-		this.db.setMetadata("sessionId", sessionId);
-		this.db.setMetadata("platform", process.platform);
-		this.db.setMetadata("startedAt", String(startedAt));
-		this.db.setMetadata("nodeVersion", process.version);
-		this.eventBusUnsub = eventBus.onAny((wrapped) => {
-			if (this.state !== "recording" || !this.db) return;
-			try {
-				this.db.insertEvent({
-					timestamp: Date.now(),
-					category: this.mapEventCategory(String(wrapped.event)),
-					eventType: String(wrapped.event),
-					data: JSON.stringify(wrapped.payload ?? {}),
-					scriptId: null,
-					lineNumber: null
-				});
-				this.eventCount++;
-			} catch {}
-		});
-		this.cdpSession = cdpSession;
-		if (cdpSession) {
-			const domains = options?.cdpDomains ?? DEFAULT_CDP_DOMAINS;
-			for (const domain of domains) {
-				const events = CDP_EVENTS_BY_DOMAIN[domain];
-				if (!events) continue;
-				for (const eventName of events) {
-					const handler = (params) => {
-						if (this.state !== "recording" || !this.db) return;
-						try {
-							let scriptId = null;
-							let lineNumber = null;
-							if (typeof params === "object" && params !== null) {
-								const p = params;
-								if ("scriptId" in p) scriptId = String(p["scriptId"]);
-								if ("lineNumber" in p) lineNumber = Number(p["lineNumber"]) || null;
-								if (eventName === "Debugger.paused" && Array.isArray(p["callFrames"])) {
-									const frame = p["callFrames"][0];
-									if (frame) {
-										const loc = frame["location"];
-										if (loc) {
-											scriptId = String(loc["scriptId"] ?? scriptId);
-											lineNumber = Number(loc["lineNumber"] ?? lineNumber) || null;
-										}
-									}
-								}
-							}
-							this.db.insertEvent({
-								timestamp: Date.now(),
-								category: domain.toLowerCase(),
-								eventType: eventName,
-								data: JSON.stringify(params ?? {}),
-								scriptId,
-								lineNumber
-							});
-							this.eventCount++;
-						} catch {}
-					};
-					cdpSession.on(eventName, handler);
-					this.cdpListeners.set(eventName, handler);
-				}
-			}
-		}
-		this.session = {
-			sessionId,
-			dbPath: absolutePath,
-			startedAt,
-			eventCount: 0,
-			memoryDeltaCount: 0,
-			heapSnapshotCount: 0
-		};
-		this.state = "recording";
-		return { ...this.session };
-	}
-	/**
-	* Record a memory write delta.
-	* Silently ignored if not currently recording.
-	*/
-	recordMemoryDelta(delta) {
-		if (this.state !== "recording" || !this.db) return;
-		try {
-			this.db.insertMemoryDelta(delta);
-			this.memoryDeltaCount++;
-		} catch {}
-	}
-	/**
-	* Capture a heap snapshot via CDP HeapProfiler.
-	* Requires an active CDP session and recording in progress.
-	*/
-	async captureHeapSnapshot(cdpSession) {
-		if (this.state !== "recording" || !this.db) throw new Error("Cannot capture heap snapshot: not recording");
-		const chunks = [];
-		const chunkHandler = (params) => {
-			if (typeof params === "object" && params !== null) {
-				const chunk = params["chunk"];
-				if (typeof chunk === "string") chunks.push(chunk);
-			}
-		};
-		try {
-			await cdpSession.send("HeapProfiler.enable");
-			cdpSession.on("HeapProfiler.addHeapSnapshotChunk", chunkHandler);
-			await cdpSession.send("HeapProfiler.takeHeapSnapshot", { reportProgress: false });
-			cdpSession.off("HeapProfiler.addHeapSnapshotChunk", chunkHandler);
-			const snapshotStr = chunks.join("");
-			const snapshotBuffer = Buffer.from(snapshotStr, "utf-8");
-			const summary = this.extractHeapSummary(snapshotStr);
-			this.db.insertHeapSnapshot({
-				timestamp: Date.now(),
-				snapshotData: snapshotBuffer,
-				summary: JSON.stringify(summary)
-			});
-			this.heapSnapshotCount++;
-		} finally {
-			await cdpSession.send("HeapProfiler.disable").catch(() => {});
-		}
-	}
-	/**
-	* Stop recording and finalize the trace database.
-	* @returns Final session summary with event counts
-	*/
-	stop() {
-		if (this.state !== "recording") throw new Error("GRACEFUL: Cannot stop: not currently recording");
-		if (this.eventBusUnsub) {
-			this.eventBusUnsub();
-			this.eventBusUnsub = null;
-		}
-		if (this.cdpSession) {
-			for (const [event, handler] of this.cdpListeners) this.cdpSession.off(event, handler);
-			this.cdpListeners.clear();
-			this.cdpSession = null;
-		}
-		if (this.db) {
-			const stoppedAt = Date.now();
-			this.db.setMetadata("stoppedAt", String(stoppedAt));
-			this.db.setMetadata("eventCount", String(this.eventCount));
-			this.db.setMetadata("memoryDeltaCount", String(this.memoryDeltaCount));
-			this.db.setMetadata("heapSnapshotCount", String(this.heapSnapshotCount));
-			this.db.close();
-			if (this.session) {
-				this.session.stoppedAt = stoppedAt;
-				this.session.eventCount = this.eventCount;
-				this.session.memoryDeltaCount = this.memoryDeltaCount;
-				this.session.heapSnapshotCount = this.heapSnapshotCount;
-			}
-		}
-		this.state = "stopped";
-		const finalSession = this.session ? { ...this.session } : this.createEmptySession();
-		this.db = null;
-		return finalSession;
-	}
-	/** Get the current recording state. */
-	getState() {
-		return this.state;
-	}
-	/** Get the current session details (null if not recording). */
-	getSession() {
-		return this.session ? { ...this.session } : null;
-	}
-	/** Get the active TraceDB instance (null if not recording). */
-	getDB() {
-		return this.db;
-	}
-	/**
-	* Map an EventBus event name to a trace category.
-	* E.g., 'tool:called' → 'tool', 'debugger:breakpoint_hit' → 'debugger'
-	*/
-	mapEventCategory(event) {
-		const colonIdx = event.indexOf(":");
-		return colonIdx > 0 ? event.substring(0, colonIdx) : "other";
-	}
-	/**
-	* Extract a lightweight summary from a V8 heap snapshot.
-	* Only parses the minimal structure needed for diffing.
-	*/
-	extractHeapSummary(snapshotStr) {
-		try {
-			const snapshot = JSON.parse(snapshotStr);
-			const snapshotInfo = snapshot["snapshot"];
-			if (!snapshotInfo) return {
-				totalSize: 0,
-				nodeCount: 0,
-				objectCounts: {}
-			};
-			const meta = snapshotInfo["meta"];
-			const nodeCount = snapshotInfo["node_count"] ?? 0;
-			const nodeFields = meta?.["node_fields"];
-			const nodeTypes = meta?.["node_types"];
-			const nodes = snapshot["nodes"];
-			const objectCounts = {};
-			let totalSize = 0;
-			if (nodeFields && nodes && nodeTypes) {
-				const fieldCount = nodeFields.length;
-				const typeIndex = nodeFields.indexOf("type");
-				const nameIndex = nodeFields.indexOf("name");
-				const selfSizeIndex = nodeFields.indexOf("self_size");
-				const strings = snapshot["strings"] ?? [];
-				for (let i = 0; i < nodes.length; i += fieldCount) {
-					const selfSize = selfSizeIndex >= 0 ? nodes[i + selfSizeIndex] ?? 0 : 0;
-					totalSize += selfSize;
-					if (nameIndex >= 0) {
-						const name = strings[nodes[i + nameIndex] ?? 0] ?? `type_${nodes[i + (typeIndex >= 0 ? typeIndex : 0)]}`;
-						if (name) objectCounts[name] = (objectCounts[name] ?? 0) + 1;
-					}
-				}
-			}
-			return {
-				totalSize,
-				nodeCount,
-				objectCounts
-			};
-		} catch {
-			return {
-				totalSize: 0,
-				nodeCount: 0,
-				objectCounts: {}
-			};
-		}
-	}
-	createEmptySession() {
-		return {
-			sessionId: "",
-			dbPath: "",
-			startedAt: 0,
-			eventCount: 0,
-			memoryDeltaCount: 0,
-			heapSnapshotCount: 0
-		};
-	}
-};
-//#endregion
-export { TraceRecorder, TraceDB as t };

package/dist/VersionDetector-CwVLVdDM.mjs

@@ -1,104 +0,0 @@
-import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
-//#region src/modules/v8-inspector/VersionDetector.ts
-var VersionDetector_exports = /* @__PURE__ */ __exportAll({ VersionDetector: () => VersionDetector });
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-function isCDPPageLike(value) {
-	return isRecord(value) && typeof value["createCDPSession"] === "function";
-}
-function readString(record, key) {
-	const value = record[key];
-	return typeof value === "string" ? value : null;
-}
-function readBooleanResult(value) {
-	if (typeof value === "boolean") return value;
-	if (isRecord(value)) {
-		const nested = value["value"];
-		return typeof nested === "boolean" ? nested : false;
-	}
-	return false;
-}
-var VersionDetector = class {
-	constructor(getPage) {
-		this.getPage = getPage;
-	}
-	async detectV8Version() {
-		const browserVersion = await this.detectBrowserVersion();
-		if (browserVersion) return browserVersion;
-		if (typeof process.versions.v8 === "string" && process.versions.v8.length > 0) return this.parseV8Version(process.versions.v8);
-		return null;
-	}
-	parseV8Version(versionString) {
-		const match = /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:\.(?<commit>[A-Za-z0-9._-]+))?/u.exec(versionString.trim());
-		if (!match?.groups) return {
-			major: 0,
-			minor: 0,
-			patch: 0,
-			commit: ""
-		};
-		const major = Number(match.groups["major"] ?? 0);
-		const minor = Number(match.groups["minor"] ?? 0);
-		const patch = Number(match.groups["patch"] ?? 0);
-		return {
-			major: Number.isFinite(major) ? major : 0,
-			minor: Number.isFinite(minor) ? minor : 0,
-			patch: Number.isFinite(patch) ? patch : 0,
-			commit: match.groups["commit"] ?? ""
-		};
-	}
-	async supportsNativesSyntax() {
-		if (process.execArgv.includes("--allow-natives-syntax")) return true;
-		const session = await this.createSession();
-		if (!session) return false;
-		try {
-			const response = await session.send("Runtime.evaluate", {
-				expression: `
-          (() => {
-            try {
-              return Boolean(new Function("return %HaveSameMap({}, {})")());
-            } catch (error) {
-              return false;
-            }
-          })()
-        `,
-				returnByValue: true,
-				awaitPromise: false
-			});
-			if (!isRecord(response)) return false;
-			return readBooleanResult(response["result"]);
-		} catch {
-			return false;
-		} finally {
-			await session.detach().catch(() => void 0);
-		}
-	}
-	async detectBrowserVersion() {
-		const session = await this.createSession();
-		if (!session) return null;
-		try {
-			const response = await session.send("Browser.getVersion");
-			if (!isRecord(response)) return null;
-			const jsVersion = readString(response, "jsVersion");
-			if (jsVersion) return this.parseV8Version(jsVersion);
-			const product = readString(response, "product");
-			return product ? this.parseV8Version(product) : null;
-		} catch {
-			return null;
-		} finally {
-			await session.detach().catch(() => void 0);
-		}
-	}
-	async createSession() {
-		if (!this.getPage) return null;
-		try {
-			const page = await this.getPage();
-			if (!isCDPPageLike(page)) return null;
-			return await page.createCDPSession();
-		} catch {
-			return null;
-		}
-	}
-};
-//#endregion
-export { VersionDetector_exports as n, VersionDetector as t };