@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/TraceRecorder-DgxyVbdQ.mjs

@@ -0,0 +1,519 @@
+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/{Win32API-Bc0QnQsN.mjs → Win32API-CePkipZY.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
-import { t as logger } from "./logger-BmWzC2lM.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
 import koffi from "koffi";
 //#region src/native/Win32API.ts
 /**

package/dist/{Win32Debug-DUHt9XUn.mjs → Win32Debug-BvKs-gxc.mjs}

@@ -1,5 +1,5 @@
-import { t as logger } from "./logger-BmWzC2lM.mjs";
-import { r as GetLastError, t as CloseHandle } from "./Win32API-Bc0QnQsN.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { r as GetLastError, t as CloseHandle } from "./Win32API-CePkipZY.mjs";
 import koffi from "koffi";
 //#region src/native/Win32Debug.ts
 /**