spider-watch 0.1.0

package/dist/middleware/error.js

@@ -0,0 +1,27 @@
+import { getCorrelationId } from "../services/context.js";
+export function createErrorMiddleware(config, repository) {
+    return (err, req, _res, next) => {
+        if (config.enabled) {
+            try {
+                const correlationId = getCorrelationId();
+                const eventId = repository.insertEvent({
+                    eventType: "EXCEPTION",
+                    severity: "ERROR",
+                    correlationId,
+                    summary: `${err.name || "Error"}: ${err.message || String(err)}`,
+                    data: { path: req.path, method: req.method },
+                });
+                repository.insertException(eventId, {
+                    correlationId,
+                    name: err.name || "Error",
+                    message: err.message || String(err),
+                    stackTrace: err.stack || null,
+                });
+            }
+            catch (captureErr) {
+                console.error("[monitoring] Failed to capture exception:", captureErr instanceof Error ? captureErr.message : String(captureErr));
+            }
+        }
+        next(err);
+    };
+}

package/dist/repository/monitoring-repository.d.ts

@@ -0,0 +1,4 @@
+import type { MonitoringRepository } from "../types.js";
+import type { SqliteDbAdapter } from "./sqlite-db.js";
+export declare function createMonitoringRepository(adapter: SqliteDbAdapter): MonitoringRepository;
+//# sourceMappingURL=monitoring-repository.d.ts.map

package/dist/repository/monitoring-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitoring-repository.d.ts","sourceRoot":"","sources":["../../src/repository/monitoring-repository.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAMV,oBAAoB,EAErB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AA0EtD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,eAAe,GAAG,oBAAoB,CA6PzF"}

package/dist/repository/monitoring-repository.js

@@ -0,0 +1,239 @@
+import { randomUUID } from "node:crypto";
+function serialize(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value);
+}
+function deserialize(value) {
+    if (value === null || value === undefined)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function rowToEvent(row) {
+    if (!row)
+        return null;
+    return {
+        id: String(row.id),
+        eventType: String(row.event_type),
+        timestamp: String(row.timestamp),
+        severity: String(row.severity),
+        correlationId: row.correlation_id ?? null,
+        parentId: row.parent_id ?? null,
+        summary: row.summary ?? null,
+        data: deserialize(row.data),
+    };
+}
+function rowToRequest(row) {
+    if (!row)
+        return null;
+    return {
+        eventId: String(row.event_id),
+        method: row.method ?? null,
+        path: row.path ?? null,
+        statusCode: row.status_code ?? null,
+        durationMs: row.duration_ms ?? null,
+        ipAddress: row.ip_address ?? null,
+        requestHeaders: deserialize(row.request_headers),
+        requestBody: row.request_body ?? null,
+        responseHeaders: deserialize(row.response_headers),
+        responseBody: row.response_body ?? null,
+    };
+}
+function rowToExternalHttp(row) {
+    if (!row)
+        return null;
+    return {
+        eventId: String(row.event_id),
+        correlationId: row.correlation_id ?? null,
+        method: row.method ?? null,
+        url: row.url ?? null,
+        statusCode: row.status_code ?? null,
+        durationMs: row.duration_ms ?? null,
+        requestHeaders: deserialize(row.request_headers),
+        requestBody: row.request_body ?? null,
+        responseHeaders: deserialize(row.response_headers),
+        responseBody: row.response_body ?? null,
+    };
+}
+function rowToException(row) {
+    if (!row)
+        return null;
+    return {
+        eventId: String(row.event_id),
+        correlationId: row.correlation_id ?? null,
+        name: row.name ?? null,
+        message: row.message ?? null,
+        stackTrace: row.stack_trace ?? null,
+    };
+}
+export function createMonitoringRepository(adapter) {
+    function insertEvent({ eventType, severity = "INFO", correlationId, parentId, summary, data, }) {
+        const db = adapter.getDb();
+        const id = randomUUID();
+        const timestamp = new Date().toISOString();
+        db.prepare(`INSERT INTO monitoring_events (id, event_type, timestamp, severity, correlation_id, parent_id, summary, data)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, eventType, timestamp, severity, correlationId ?? null, parentId ?? null, summary ?? null, serialize(data));
+        return id;
+    }
+    function getEventById(id) {
+        const db = adapter.getDb();
+        const row = db.prepare("SELECT * FROM monitoring_events WHERE id = ?").get(id);
+        return rowToEvent(row);
+    }
+    function listEvents({ from, to, status, type, method, q, page = 1, pageSize = 50, } = {}) {
+        const db = adapter.getDb();
+        const conditions = [];
+        const params = [];
+        if (typeof from === "string" && from) {
+            conditions.push("e.timestamp >= ?");
+            params.push(from);
+        }
+        if (typeof to === "string" && to) {
+            conditions.push("e.timestamp <= ?");
+            params.push(to);
+        }
+        if (typeof type === "string" && type) {
+            conditions.push("e.event_type = ?");
+            params.push(type.toUpperCase());
+        }
+        if (typeof method === "string" && method) {
+            conditions.push("r.method = ?");
+            params.push(method.toUpperCase());
+        }
+        if (typeof status === "string" && status) {
+            if (status === "success") {
+                conditions.push("(r.status_code < 400 OR r.status_code IS NULL)");
+            }
+            else if (status === "error") {
+                conditions.push("(r.status_code >= 400 OR e.severity = 'ERROR')");
+            }
+            else if (!Number.isNaN(Number(status))) {
+                conditions.push("r.status_code = ?");
+                params.push(Number(status));
+            }
+        }
+        if (typeof q === "string" && q) {
+            conditions.push("(e.correlation_id LIKE ? OR e.summary LIKE ? OR r.path LIKE ? OR r.ip_address LIKE ?)");
+            const like = `%${q}%`;
+            params.push(like, like, like, like);
+        }
+        const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+        const safePage = Math.max(1, Number(page) || 1);
+        const safePageSize = Math.min(200, Math.max(1, Number(pageSize) || 50));
+        const offset = (safePage - 1) * safePageSize;
+        const countRow = db
+            .prepare(`SELECT COUNT(*) as cnt
+         FROM monitoring_events e
+         LEFT JOIN request_records r ON r.event_id = e.id
+         ${where}`)
+            .get(...params);
+        const rows = db
+            .prepare(`SELECT e.*, r.method, r.path, r.status_code, r.duration_ms, r.ip_address
+         FROM monitoring_events e
+         LEFT JOIN request_records r ON r.event_id = e.id
+         ${where}
+         ORDER BY e.timestamp DESC
+         LIMIT ? OFFSET ?`)
+            .all(...params, safePageSize, offset);
+        return {
+            items: rows.map((row) => ({
+                id: String(row.id),
+                eventType: String(row.event_type),
+                timestamp: String(row.timestamp),
+                severity: String(row.severity),
+                correlationId: row.correlation_id ?? null,
+                summary: row.summary ?? null,
+                method: row.method ?? null,
+                path: row.path ?? null,
+                statusCode: row.status_code ?? null,
+                durationMs: row.duration_ms ?? null,
+                ipAddress: row.ip_address ?? null,
+            })),
+            page: safePage,
+            pageSize: safePageSize,
+            total: countRow?.cnt ?? 0,
+        };
+    }
+    function insertRequest(eventId, record) {
+        const db = adapter.getDb();
+        db.prepare(`INSERT INTO request_records (event_id, method, path, status_code, duration_ms, ip_address, request_headers, request_body, response_headers, response_body)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(eventId, record.method ?? null, record.path ?? null, record.statusCode ?? null, record.durationMs ?? null, record.ipAddress ?? null, serialize(record.requestHeaders), record.requestBody ?? null, serialize(record.responseHeaders), record.responseBody ?? null);
+    }
+    function getRequestByEventId(eventId) {
+        const db = adapter.getDb();
+        const row = db.prepare("SELECT * FROM request_records WHERE event_id = ?").get(eventId);
+        return rowToRequest(row);
+    }
+    function insertExternalHttp(eventId, record) {
+        const db = adapter.getDb();
+        db.prepare(`INSERT INTO external_http_records (event_id, correlation_id, method, url, status_code, duration_ms, request_headers, request_body, response_headers, response_body)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(eventId, record.correlationId ?? null, record.method ?? null, record.url ?? null, record.statusCode ?? null, record.durationMs ?? null, serialize(record.requestHeaders), record.requestBody ?? null, serialize(record.responseHeaders), record.responseBody ?? null);
+    }
+    function getExternalHttpsByCorrelationId(correlationId) {
+        const db = adapter.getDb();
+        const rows = db
+            .prepare("SELECT * FROM external_http_records WHERE correlation_id = ? ORDER BY rowid ASC")
+            .all(correlationId);
+        return rows
+            .map((row) => rowToExternalHttp(row))
+            .filter((row) => Boolean(row));
+    }
+    function insertException(eventId, record) {
+        const db = adapter.getDb();
+        db.prepare(`INSERT INTO exception_records (event_id, correlation_id, name, message, stack_trace)
+       VALUES (?, ?, ?, ?, ?)`).run(eventId, record.correlationId ?? null, record.name ?? null, record.message ?? null, record.stackTrace ?? null);
+    }
+    function getExceptionsByCorrelationId(correlationId) {
+        const db = adapter.getDb();
+        const rows = db
+            .prepare("SELECT * FROM exception_records WHERE correlation_id = ? ORDER BY rowid ASC")
+            .all(correlationId);
+        return rows
+            .map((row) => rowToException(row))
+            .filter((row) => Boolean(row));
+    }
+    function deleteOldEvents(olderThanDays) {
+        const db = adapter.getDb();
+        const cutoff = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000).toISOString();
+        const result = db.prepare("DELETE FROM monitoring_events WHERE timestamp < ?").run(cutoff);
+        return result.changes;
+    }
+    function countEvents() {
+        const db = adapter.getDb();
+        const row = db.prepare("SELECT COUNT(*) as cnt FROM monitoring_events").get();
+        return row?.cnt ?? 0;
+    }
+    function deleteAllEvents() {
+        const db = adapter.getDb();
+        const tx = db.transaction(() => {
+            const deleteResult = db.prepare("DELETE FROM monitoring_events").run();
+            const remainingRow = db.prepare("SELECT COUNT(*) as cnt FROM monitoring_events").get();
+            return {
+                deleted: deleteResult.changes ?? 0,
+                remaining: remainingRow?.cnt ?? 0,
+            };
+        });
+        return tx();
+    }
+    return {
+        insertEvent,
+        getEventById,
+        listEvents,
+        insertRequest,
+        getRequestByEventId,
+        insertExternalHttp,
+        getExternalHttpsByCorrelationId,
+        insertException,
+        getExceptionsByCorrelationId,
+        deleteOldEvents,
+        countEvents,
+        deleteAllEvents,
+    };
+}

package/dist/repository/sqlite-db.d.ts

@@ -0,0 +1,7 @@
+import Database from "better-sqlite3";
+export interface SqliteDbAdapter {
+    getDb: () => Database.Database;
+    closeDb: () => void;
+}
+export declare function createSqliteDb(dbPath: string): SqliteDbAdapter;
+//# sourceMappingURL=sqlite-db.d.ts.map

package/dist/repository/sqlite-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-db.d.ts","sourceRoot":"","sources":["../../src/repository/sqlite-db.ts"],"names":[],"mappings":"AAGA,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AAEtC,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,QAAQ,CAAC,QAAQ,CAAC;IAC/B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CA2B9D"}

package/dist/repository/sqlite-db.js

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+export function createSqliteDb(dbPath) {
+    let db = null;
+    function getDb() {
+        if (!db) {
+            const resolvedPath = path.resolve(dbPath);
+            const dir = path.dirname(resolvedPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            db = new Database(resolvedPath);
+            db.pragma("journal_mode = WAL");
+            db.pragma("foreign_keys = ON");
+            initSchema(db);
+        }
+        return db;
+    }
+    function closeDb() {
+        if (db) {
+            db.close();
+            db = null;
+        }
+    }
+    return { getDb, closeDb };
+}
+function initSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS monitoring_events (
+      id          TEXT PRIMARY KEY,
+      event_type  TEXT NOT NULL,
+      timestamp   TEXT NOT NULL,
+      severity    TEXT NOT NULL DEFAULT 'INFO',
+      correlation_id TEXT,
+      parent_id   TEXT,
+      summary     TEXT,
+      data        TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_events_timestamp    ON monitoring_events(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_events_correlation  ON monitoring_events(correlation_id);
+    CREATE INDEX IF NOT EXISTS idx_events_type         ON monitoring_events(event_type);
+    CREATE INDEX IF NOT EXISTS idx_events_severity     ON monitoring_events(severity);
+
+    CREATE TABLE IF NOT EXISTS request_records (
+      event_id          TEXT PRIMARY KEY,
+      method            TEXT,
+      path              TEXT,
+      status_code       INTEGER,
+      duration_ms       INTEGER,
+      ip_address        TEXT,
+      request_headers   TEXT,
+      request_body      TEXT,
+      response_headers  TEXT,
+      response_body     TEXT,
+      FOREIGN KEY (event_id) REFERENCES monitoring_events(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_req_path   ON request_records(path);
+    CREATE INDEX IF NOT EXISTS idx_req_status ON request_records(status_code);
+    CREATE INDEX IF NOT EXISTS idx_req_method ON request_records(method);
+
+    CREATE TABLE IF NOT EXISTS external_http_records (
+      event_id          TEXT PRIMARY KEY,
+      correlation_id    TEXT,
+      method            TEXT,
+      url               TEXT,
+      status_code       INTEGER,
+      duration_ms       INTEGER,
+      request_headers   TEXT,
+      request_body      TEXT,
+      response_headers  TEXT,
+      response_body     TEXT,
+      FOREIGN KEY (event_id) REFERENCES monitoring_events(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_ext_correlation ON external_http_records(correlation_id);
+
+    CREATE TABLE IF NOT EXISTS exception_records (
+      event_id       TEXT PRIMARY KEY,
+      correlation_id TEXT,
+      name           TEXT,
+      message        TEXT,
+      stack_trace    TEXT,
+      FOREIGN KEY (event_id) REFERENCES monitoring_events(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_exc_correlation ON exception_records(correlation_id);
+  `);
+}

package/dist/router/async-handler.d.ts

@@ -0,0 +1,3 @@
+import type { NextFunction, Request, RequestHandler, Response } from "express";
+export declare function asyncHandler(handler: (req: Request, res: Response, next: NextFunction) => Promise<unknown> | unknown): RequestHandler;
+//# sourceMappingURL=async-handler.d.ts.map

package/dist/router/async-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-handler.d.ts","sourceRoot":"","sources":["../../src/router/async-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/E,wBAAgB,YAAY,CAC1B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,GACvF,cAAc,CAIhB"}

package/dist/router/async-handler.js

@@ -0,0 +1,5 @@
+export function asyncHandler(handler) {
+    return (req, res, next) => {
+        Promise.resolve(handler(req, res, next)).catch(next);
+    };
+}

package/dist/router/monitoring-router.d.ts

@@ -0,0 +1,4 @@
+import { type RequestHandler, type Router } from "express";
+import type { MonitoringOptions, MonitoringRepository } from "../types.js";
+export declare function createMonitoringRouter(config: MonitoringOptions, repository: MonitoringRepository, authMiddleware: RequestHandler, uiDir: string): Router;
+//# sourceMappingURL=monitoring-router.d.ts.map

package/dist/router/monitoring-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitoring-router.d.ts","sourceRoot":"","sources":["../../src/router/monitoring-router.ts"],"names":[],"mappings":"AAGA,OAAgB,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAGpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAc3E,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,iBAAiB,EACzB,UAAU,EAAE,oBAAoB,EAChC,cAAc,EAAE,cAAc,EAC9B,KAAK,EAAE,MAAM,GACZ,MAAM,CAoIR"}

package/dist/router/monitoring-router.js

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import path from "node:path";
+import express from "express";
+import { asyncHandler } from "./async-handler.js";
+function parseDeleteScope(body) {
+    if (!body || typeof body !== "object") {
+        return { valid: false, error: "Request body is required" };
+    }
+    if (body.scope !== "all") {
+        return { valid: false, error: 'Invalid scope. Expected {"scope":"all"}' };
+    }
+    return { valid: true };
+}
+export function createMonitoringRouter(config, repository, authMiddleware, uiDir) {
+    const router = express.Router();
+    const prefix = config.routePrefix;
+    if (!config.enabled) {
+        router.use(prefix, (_req, res) => {
+            res.status(503).json({ error: "Monitoring is disabled" });
+        });
+        return router;
+    }
+    router.use(prefix, authMiddleware);
+    router.get(prefix, asyncHandler(async (_req, res) => {
+        const indexPath = path.join(uiDir, "index.html");
+        const html = await fs.promises.readFile(indexPath, "utf8");
+        const withPrefix = html.replaceAll("__MONITORING_BASE_PATH__", prefix);
+        res.type("html").send(withPrefix);
+    }));
+    router.get(`${prefix}/app.js`, asyncHandler(async (_req, res) => {
+        const js = await fs.promises.readFile(path.join(uiDir, "app.js"), "utf8");
+        res.type("js").send(js);
+    }));
+    router.get(`${prefix}/api/events`, asyncHandler(async (req, res) => {
+        const { from, to, status, type, method, q } = req.query;
+        const page = Math.max(1, parseInt(String(req.query.page ?? "1"), 10));
+        const pageSize = Math.min(200, Math.max(1, parseInt(String(req.query.pageSize ?? "50"), 10)));
+        const result = repository.listEvents({ from, to, status, type, method, q, page, pageSize });
+        res.json(result);
+    }));
+    router.get(`${prefix}/api/events/:id`, asyncHandler(async (req, res) => {
+        const eventId = String(req.params.id ?? "");
+        const event = repository.getEventById(eventId);
+        if (!event) {
+            res.status(404).json({ error: "Event not found" });
+            return;
+        }
+        const response = { event };
+        if (event.eventType === "REQUEST") {
+            response.request = repository.getRequestByEventId(event.id);
+            if (event.correlationId) {
+                response.externalHttpCalls = repository.getExternalHttpsByCorrelationId(event.correlationId);
+                response.exceptions = repository.getExceptionsByCorrelationId(event.correlationId);
+            }
+        }
+        else if (event.eventType === "EXCEPTION") {
+            const exceptions = repository.getExceptionsByCorrelationId(event.correlationId || event.id);
+            response.exception = exceptions[0] ?? null;
+        }
+        else if (event.eventType === "EXTERNAL_HTTP") {
+            const rows = repository.getExternalHttpsByCorrelationId(event.correlationId || event.id);
+            response.externalHttp = rows.find((row) => row.eventId === event.id) ?? null;
+        }
+        res.json(response);
+    }));
+    router.delete(`${prefix}/api/events`, asyncHandler(async (req, res) => {
+        const validation = parseDeleteScope(req.body);
+        if (!validation.valid) {
+            res.status(400).json({ error: validation.error });
+            return;
+        }
+        const { deleted, remaining } = repository.deleteAllEvents();
+        const message = deleted === 0 ? "No monitoring data to delete." : `Deleted ${deleted} monitoring event(s).`;
+        res.json({ success: true, deleted, remaining, message });
+    }));
+    router.get(`${prefix}/api/requests`, asyncHandler(async (req, res) => {
+        const { from, to, status, method, q } = req.query;
+        const page = Math.max(1, parseInt(String(req.query.page ?? "1"), 10));
+        const pageSize = Math.min(200, Math.max(1, parseInt(String(req.query.pageSize ?? "50"), 10)));
+        const result = repository.listEvents({
+            from,
+            to,
+            status,
+            type: "REQUEST",
+            method,
+            q,
+            page,
+            pageSize,
+        });
+        res.json(result);
+    }));
+    router.get(`${prefix}/api/requests/:id`, asyncHandler(async (req, res) => {
+        const eventId = String(req.params.id ?? "");
+        const event = repository.getEventById(eventId);
+        if (!event || event.eventType !== "REQUEST") {
+            res.status(404).json({ error: "Request not found" });
+            return;
+        }
+        const request = repository.getRequestByEventId(event.id);
+        const externalHttpCalls = event.correlationId
+            ? repository.getExternalHttpsByCorrelationId(event.correlationId)
+            : [];
+        const exceptions = event.correlationId
+            ? repository.getExceptionsByCorrelationId(event.correlationId)
+            : [];
+        res.json({ request: { ...event, ...request }, externalHttpCalls, exceptions });
+    }));
+    return router;
+}

package/dist/services/console-hook.d.ts

@@ -0,0 +1,12 @@
+import type { MonitoringOptions } from "../types.js";
+export declare function createConsoleHookService(config: MonitoringOptions, recordEvent: (event: {
+    eventType: string;
+    severity?: "INFO" | "WARN" | "ERROR";
+    summary: string;
+    data?: unknown;
+}) => string | null): {
+    install: () => void;
+    uninstall: () => void;
+    isInstalled: () => boolean;
+};
+//# sourceMappingURL=console-hook.d.ts.map

package/dist/services/console-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-hook.d.ts","sourceRoot":"","sources":["../../src/services/console-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,CAAC,KAAK,EAAE;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,KAAK,MAAM,GAAG,IAAI;mBAMC,IAAI;qBA0CF,IAAI;uBAcF,OAAO;EAKhC"}

package/dist/services/console-hook.js

@@ -0,0 +1,61 @@
+export function createConsoleHookService(config, recordEvent) {
+    let installed = false;
+    const levels = ["log", "info", "warn", "error", "debug"];
+    const originals = new Map();
+    function install() {
+        if (installed || !config.captureLogs)
+            return;
+        installed = true;
+        for (const level of levels) {
+            const original = console[level].bind(console);
+            originals.set(level, original);
+            console[level] = (...args) => {
+                original(...args);
+                try {
+                    const severity = level === "error" ? "ERROR" : level === "warn" ? "WARN" : "INFO";
+                    const summary = args
+                        .map((value) => {
+                        if (typeof value === "string")
+                            return value;
+                        try {
+                            return JSON.stringify(value);
+                        }
+                        catch {
+                            return String(value);
+                        }
+                    })
+                        .join(" ")
+                        .substring(0, 500);
+                    recordEvent({
+                        eventType: "LOG",
+                        severity,
+                        summary,
+                        data: {
+                            level,
+                            args: args.map((value) => String(value)),
+                        },
+                    });
+                }
+                catch (err) {
+                    console.error("[monitoring] Failed to capture console log:", err instanceof Error ? err.message : String(err));
+                }
+            };
+        }
+    }
+    function uninstall() {
+        if (!installed)
+            return;
+        for (const level of levels) {
+            const original = originals.get(level);
+            if (original) {
+                console[level] = original;
+            }
+        }
+        originals.clear();
+        installed = false;
+    }
+    function isInstalled() {
+        return installed;
+    }
+    return { install, uninstall, isInstalled };
+}

package/dist/services/context.d.ts

@@ -0,0 +1,7 @@
+import type { MonitoringContext } from "../types.js";
+export declare function runWithContext(context: MonitoringContext, fn: () => void): void;
+export declare function getContext(): MonitoringContext | null;
+export declare function getCorrelationId(): string | null;
+export declare function getRequestId(): string | null;
+export declare function createContext(overrides?: Partial<MonitoringContext>): MonitoringContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/services/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/services/context.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD,wBAAgB,cAAc,CAAC,OAAO,EAAE,iBAAiB,EAAE,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAE/E;AAED,wBAAgB,UAAU,IAAI,iBAAiB,GAAG,IAAI,CAErD;AAED,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAEhD;AAED,wBAAgB,YAAY,IAAI,MAAM,GAAG,IAAI,CAE5C;AAED,wBAAgB,aAAa,CAAC,SAAS,GAAE,OAAO,CAAC,iBAAiB,CAAM,GAAG,iBAAiB,CAM3F"}

package/dist/services/context.js

@@ -0,0 +1,22 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+const storage = new AsyncLocalStorage();
+export function runWithContext(context, fn) {
+    storage.run(context, fn);
+}
+export function getContext() {
+    return storage.getStore() ?? null;
+}
+export function getCorrelationId() {
+    return storage.getStore()?.correlationId ?? null;
+}
+export function getRequestId() {
+    return storage.getStore()?.requestId ?? null;
+}
+export function createContext(overrides = {}) {
+    return {
+        correlationId: randomUUID(),
+        requestId: randomUUID(),
+        ...overrides,
+    };
+}

package/dist/services/http-client.d.ts

@@ -0,0 +1,7 @@
+import { type AxiosInstance } from "axios";
+import type { MonitoringOptions, MonitoringRepository } from "../types.js";
+export declare function createMonitoredAxios(config: MonitoringOptions, repository: MonitoringRepository, masking: {
+    maskBody: (body: unknown) => string | null;
+    maskHeaders: (headers: unknown) => Record<string, unknown>;
+}, getCorrelationId: () => string | null): AxiosInstance;
+//# sourceMappingURL=http-client.d.ts.map

package/dist/services/http-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-client.d.ts","sourceRoot":"","sources":["../../src/services/http-client.ts"],"names":[],"mappings":"AAAA,OAAc,EACZ,KAAK,aAAa,EAGnB,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAO3E,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,iBAAiB,EACzB,UAAU,EAAE,oBAAoB,EAChC,OAAO,EAAE;IACP,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAC;IAC3C,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC5D,EACD,gBAAgB,EAAE,MAAM,MAAM,GAAG,IAAI,GACpC,aAAa,CA0Cf"}