@adjedaini/clockwork-node 0.0.1

package/dist/index.js

@@ -0,0 +1,695 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// packages/core/dist/index.js
+var require_dist = __commonJS({
+  "packages/core/dist/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export(index_exports, {
+      MonitorCore: () => MonitorCore2
+    });
+    module.exports = __toCommonJS(index_exports);
+    var RequestRingBuffer = class {
+      constructor(capacity = 100) {
+        this.buffer = /* @__PURE__ */ new Map();
+        this.order = [];
+        this.capacity = Math.max(1, capacity);
+      }
+      push(id, request) {
+        if (this.buffer.has(id)) {
+          this.buffer.set(id, request);
+          return;
+        }
+        while (this.order.length >= this.capacity && this.order.length > 0) {
+          const oldest = this.order.shift();
+          this.buffer.delete(oldest);
+        }
+        this.order.push(id);
+        this.buffer.set(id, request);
+      }
+      get(id) {
+        return this.buffer.get(id);
+      }
+      getAll(limit = 100) {
+        const ids = this.order.slice(-limit).reverse();
+        return ids.map((id) => this.buffer.get(id)).filter(Boolean);
+      }
+      getLatest() {
+        if (this.order.length === 0) return void 0;
+        return this.buffer.get(this.order[this.order.length - 1]);
+      }
+      count() {
+        return this.buffer.size;
+      }
+    };
+    var DEFAULT_MAX_REQUESTS = 100;
+    var MonitorCore2 = class {
+      constructor(config = {}) {
+        this.current = /* @__PURE__ */ new Map();
+        this.startedAt = 0;
+        this.config = {
+          maxRequests: config.maxRequests ?? DEFAULT_MAX_REQUESTS
+        };
+        this.buffer = config.storage ?? new RequestRingBuffer(this.config.maxRequests);
+      }
+      /** Start the monitor (call once at bootstrap). */
+      start() {
+        this.startedAt = Date.now();
+      }
+      /** Begin capturing a request. Returns request id. */
+      captureRequest(initial) {
+        const id = initial.id || `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 9)}`;
+        const startTime = Date.now();
+        const heapAtStart = process.memoryUsage().heapUsed;
+        const snapshot = {
+          id,
+          type: "http",
+          method: initial.method ?? "",
+          uri: initial.uri ?? "",
+          headers: initial.headers ?? {},
+          getData: initial.getData ?? {},
+          postData: initial.postData,
+          cookies: initial.cookies,
+          responseStatus: 0,
+          responseTime: startTime,
+          responseDuration: 0,
+          memoryUsage: heapAtStart,
+          time: startTime / 1e3,
+          log: [],
+          databaseQueries: [],
+          timelineData: [],
+          controller: initial.controller
+        };
+        this.current.set(id, snapshot);
+        return id;
+      }
+      /** Attach a log entry to a request. */
+      captureLog(requestId, level, message, context) {
+        const req = this.current.get(requestId);
+        if (!req) return;
+        const startTime = req.time * 1e3;
+        req.log.push({
+          level,
+          message,
+          context,
+          time: (Date.now() - startTime) / 1e3,
+          source: "clockwork"
+        });
+      }
+      /** Attach a native (e.g. console) log entry. */
+      captureNativeLog(requestId, level, message, context, timeOffset) {
+        const req = this.current.get(requestId);
+        if (!req) return;
+        const startTime = req.time * 1e3;
+        req.log.push({
+          level,
+          message,
+          context,
+          time: timeOffset ?? (Date.now() - startTime) / 1e3,
+          source: "native"
+        });
+      }
+      /** Capture an error. If requestId is set, also attach to that request's log. */
+      captureError(error, requestId) {
+        const message = error instanceof Error ? error.message : String(error);
+        const context = error instanceof Error ? { name: error.name, stack: error.stack } : void 0;
+        if (requestId) {
+          this.captureLog(requestId, "error", message, context);
+        }
+      }
+      /** Add a query to a request. */
+      addQuery(requestId, data) {
+        const req = this.current.get(requestId);
+        if (!req) return;
+        req.databaseQueries.push(data);
+      }
+      /** Add a timeline event to a request. */
+      addEvent(requestId, data) {
+        const req = this.current.get(requestId);
+        if (!req) return;
+        req.timelineData.push(data);
+      }
+      /** Update request data (e.g. response status, duration, body). */
+      finalizeRequest(requestId, update) {
+        const req = this.current.get(requestId);
+        if (!req) return;
+        req.responseStatus = update.responseStatus;
+        req.responseDuration = update.responseDuration;
+        if (update.responseData !== void 0) req.responseData = update.responseData;
+        req.memoryUsage = process.memoryUsage().heapUsed - req.memoryUsage;
+        this.buffer.push(requestId, req);
+        this.current.delete(requestId);
+      }
+      /** Get full request by id. */
+      getRequest(id) {
+        return this.current.get(id) ?? this.buffer.get(id);
+      }
+      /** Get snapshot for UI: list of requests + optional metrics. */
+      getSnapshot(limit = 50) {
+        const all = this.buffer.getAll(limit);
+        const requests = all.map((r) => ({
+          id: r.id,
+          method: r.method,
+          uri: r.uri,
+          controller: r.controller,
+          responseStatus: r.responseStatus,
+          responseDuration: r.responseDuration,
+          time: r.time
+        }));
+        return {
+          requests,
+          metrics: {
+            timestamp: Date.now() / 1e3,
+            spans: []
+          }
+        };
+      }
+      /** For plugin/collector registration later. */
+      registerCollector(_name, _fn) {
+      }
+    };
+  }
+});
+
+// packages/transport-http/dist/index.js
+var require_dist2 = __commonJS({
+  "packages/transport-http/dist/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export(index_exports, {
+      createHttpAdapter: () => createHttpAdapter2
+    });
+    module.exports = __toCommonJS(index_exports);
+    var DEFAULT_REDACT_KEYS = [
+      "authorization",
+      "cookie",
+      "set-cookie",
+      "x-api-key",
+      "x-auth-token",
+      "password",
+      "passwd",
+      "secret",
+      "token",
+      "access_token",
+      "refresh_token",
+      "api_key",
+      "apikey",
+      "credential",
+      "credentials"
+    ];
+    function redactValue() {
+      return "[REDACTED]";
+    }
+    function truncate(str, maxLength) {
+      if (typeof str !== "string") return str;
+      if (str.length <= maxLength) return str;
+      return str.slice(0, maxLength) + "...[truncated]";
+    }
+    function shouldRedact(key, redactKeys) {
+      const lower = key.toLowerCase();
+      return redactKeys.some((k) => lower.includes(k.toLowerCase()) || k.toLowerCase().includes(lower));
+    }
+    function sanitizeHeaders(obj, options = {}) {
+      if (!obj || typeof obj !== "object") return {};
+      const keys = options.redactKeys ?? DEFAULT_REDACT_KEYS;
+      const maxLen = options.maxValueLength ?? 500;
+      const out = {};
+      for (const [k, v] of Object.entries(obj)) {
+        if (shouldRedact(k, keys)) {
+          out[k] = redactValue();
+        } else if (typeof v === "string") {
+          out[k] = truncate(v, maxLen);
+        } else {
+          out[k] = v;
+        }
+      }
+      return out;
+    }
+    var DEFAULT_MAX_DEPTH = 10;
+    var OMITTED_DEPTH = "[depth exceeded]";
+    function sanitizeBodyAtDepth(value, options) {
+      const keys = options.redactKeys ?? DEFAULT_REDACT_KEYS;
+      const maxLength = options.maxLength ?? 1e4;
+      const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+      const depth = options._depth ?? 0;
+      if (value === null || value === void 0) return value;
+      if (typeof value === "string") return truncate(value, maxLength);
+      if (depth >= maxDepth) return OMITTED_DEPTH;
+      const nextOpts = {
+        redactKeys: keys,
+        maxLength,
+        maxDepth,
+        _depth: depth + 1
+      };
+      if (Array.isArray(value)) {
+        return value.slice(0, 50).map((item) => sanitizeBodyAtDepth(item, nextOpts));
+      }
+      if (typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+          if (shouldRedact(k, keys)) out[k] = redactValue();
+          else out[k] = sanitizeBodyAtDepth(v, nextOpts);
+        }
+        return out;
+      }
+      return value;
+    }
+    function sanitizeBody(value, options = {}) {
+      const { _depth, ...opts } = options;
+      return sanitizeBodyAtDepth(value, opts);
+    }
+    var DEFAULT_PATH2 = "/__clockwork";
+    var DEFAULT_REDACT_KEYS2 = [
+      "authorization",
+      "cookie",
+      "set-cookie",
+      "x-api-key",
+      "x-auth-token",
+      "password",
+      "passwd",
+      "secret",
+      "token",
+      "access_token",
+      "refresh_token"
+    ];
+    function getPathPrefix2(path3) {
+      return path3.replace(/\/$/, "") || DEFAULT_PATH2;
+    }
+    function getMethod(req) {
+      return (req.method || "GET").toUpperCase();
+    }
+    function getUri(req) {
+      return req.originalUrl ?? req.url ?? req.path ?? "/";
+    }
+    function getPathname2(req) {
+      const u = req.originalUrl ?? req.url ?? req.path ?? "/";
+      const q = u.indexOf("?");
+      return q === -1 ? u : u.slice(0, q);
+    }
+    function createHttpAdapter2(core, options = {}) {
+      const pathPrefix = getPathPrefix2(options.path ?? DEFAULT_PATH2);
+      const contextRunner = options.contextRunner;
+      const snapshotLimit = options.snapshotLimit ?? 50;
+      const redactKeys = options.redactKeys ?? DEFAULT_REDACT_KEYS2;
+      const maxBodySize = options.maxBodySize ?? 1e4;
+      const maxBodyDepth = options.maxBodyDepth ?? 10;
+      const captureRequestBody = options.captureRequestBody ?? true;
+      const captureResponseBody = options.captureResponseBody ?? true;
+      const ignoreStartsWith = options.ignoreStartsWith ?? [];
+      const sanitizeOpts = { redactKeys, maxLength: maxBodySize, maxDepth: maxBodyDepth };
+      function shouldIgnore(pathname) {
+        return ignoreStartsWith.some((p) => pathname.startsWith(p));
+      }
+      function isClockworkPath(pathname) {
+        return pathname === pathPrefix || pathname.startsWith(pathPrefix + "/");
+      }
+      function sendJson(res, body, statusCode) {
+        const payload = JSON.stringify(body);
+        if (statusCode != null && res.status) {
+          const r = res.status(statusCode);
+          if (r.json) r.json(body);
+          else r.end?.(payload);
+        } else if (res.json) {
+          res.json(body);
+        } else {
+          res.setHeader("Content-Type", "application/json");
+          res.end?.(payload);
+        }
+      }
+      const dataHandler = (req, res) => {
+        const pathname = getPathname2(req);
+        if (!isClockworkPath(pathname)) {
+          if (res.status) res.status(404).end?.("Not found");
+          else {
+            res.setHeader("Content-Type", "text/plain");
+            res.end?.("Not found");
+          }
+          return;
+        }
+        const relative = pathname.slice(pathPrefix.length).replace(/^\/+/, "") || "index";
+        const segments = relative.split("/");
+        if (segments[0] === "index" || segments[0] === "") {
+          sendJson(res, core.getSnapshot(snapshotLimit));
+          return;
+        }
+        if (segments[0] === "metrics") {
+          const snapshot = core.getSnapshot(1);
+          sendJson(res, snapshot.metrics ?? { timestamp: Date.now() / 1e3, spans: [] });
+          return;
+        }
+        if (segments[0] === "latest") {
+          const snapshot = core.getSnapshot(1);
+          const reqs = snapshot.requests;
+          if (reqs.length === 0) {
+            sendJson(res, { error: "No requests found" }, 404);
+            return;
+          }
+          const latest = core.getRequest(reqs[0].id);
+          sendJson(res, latest ?? {});
+          return;
+        }
+        const id = segments[0];
+        const request = core.getRequest(id);
+        if (!request) {
+          sendJson(res, { error: "Request not found" }, 404);
+          return;
+        }
+        sendJson(res, request);
+      };
+      const middleware = (req, res, next) => {
+        const pathname = getPathname2(req);
+        if (isClockworkPath(pathname)) {
+          dataHandler(req, res);
+          return;
+        }
+        if (shouldIgnore(pathname)) {
+          next();
+          return;
+        }
+        const headers = sanitizeHeaders(
+          req.headers,
+          { redactKeys, maxValueLength: 500 }
+        );
+        const getData = req.query ?? {};
+        const postData = captureRequestBody && req.body !== void 0 ? sanitizeBody(req.body, sanitizeOpts) : void 0;
+        const cookies = req.cookies !== void 0 ? sanitizeHeaders(req.cookies, { redactKeys }) : void 0;
+        const requestId = core.captureRequest({
+          method: getMethod(req),
+          uri: getUri(req),
+          headers,
+          getData: sanitizeBody(getData, sanitizeOpts),
+          postData,
+          cookies,
+          controller: req.route?.path
+        });
+        const startTimeMs = Date.now();
+        let capturedResponseBody = void 0;
+        const setHeader = res.setHeader.bind(res);
+        res.setHeader = function(name, value) {
+          if (!res.headersSent) {
+            if (name.toLowerCase() === "x-clockwork-id") {
+              setHeader("X-Clockwork-Id", String(value));
+            } else if (name.toLowerCase() === "x-clockwork-version") {
+              setHeader("X-Clockwork-Version", "2.0");
+            } else if (name.toLowerCase() === "x-clockwork-path") {
+              setHeader("X-Clockwork-Path", `${pathPrefix}/${value}`);
+            }
+          }
+          return setHeader(name, value);
+        };
+        const originalSend = res.send;
+        const originalJson = res.json;
+        if (originalSend) {
+          res.send = function(body) {
+            if (!res.headersSent) {
+              res.setHeader("X-Clockwork-Id", requestId);
+              res.setHeader("X-Clockwork-Version", "2.0");
+              res.setHeader("X-Clockwork-Path", `${pathPrefix}/${requestId}`);
+            }
+            if (captureResponseBody && body !== void 0) {
+              try {
+                const str = typeof body === "string" ? body : JSON.stringify(body);
+                capturedResponseBody = str.length <= maxBodySize ? typeof body === "string" ? body : body : str.slice(0, maxBodySize) + "...[truncated]";
+              } catch {
+                capturedResponseBody = "[unserializable]";
+              }
+            }
+            return originalSend.call(this, body);
+          };
+        }
+        if (originalJson) {
+          res.json = function(body) {
+            if (!res.headersSent) {
+              res.setHeader("X-Clockwork-Id", requestId);
+              res.setHeader("X-Clockwork-Version", "2.0");
+              res.setHeader("X-Clockwork-Path", `${pathPrefix}/${requestId}`);
+            }
+            if (captureResponseBody && body !== void 0) {
+              try {
+                const str = JSON.stringify(body);
+                capturedResponseBody = str.length <= maxBodySize ? body : str.slice(0, maxBodySize) + "...[truncated]";
+              } catch {
+                capturedResponseBody = "[unserializable]";
+              }
+            }
+            return originalJson.call(this, body);
+          };
+        }
+        res.on("finish", () => {
+          const statusCode = typeof res.statusCode === "number" ? res.statusCode : 200;
+          const duration = Date.now() - startTimeMs;
+          core.finalizeRequest(requestId, {
+            responseStatus: statusCode,
+            responseDuration: duration,
+            responseData: capturedResponseBody !== void 0 ? sanitizeBody(capturedResponseBody, sanitizeOpts) : void 0
+          });
+        });
+        req.clockworkId = requestId;
+        if (contextRunner) {
+          contextRunner(requestId, next);
+        } else {
+          next();
+        }
+      };
+      return { middleware, dataHandler };
+    }
+  }
+});
+
+// src/index.ts
+var import_clockwork_core = __toESM(require_dist(), 1);
+var import_clockwork_transport_http = __toESM(require_dist2(), 1);
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/serve-static.ts
+import fs from "fs";
+import path from "path";
+var MIMES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".ico": "image/x-icon",
+  ".svg": "image/svg+xml",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function getPathname(req) {
+  const u = req.originalUrl ?? req.url ?? req.path ?? "/";
+  const q = u.indexOf("?");
+  return q === -1 ? u : u.slice(0, q);
+}
+function sendFile(res, filePath, contentType) {
+  const data = fs.readFileSync(filePath);
+  res.setHeader("Content-Type", contentType);
+  res.setHeader("Content-Length", String(data.length));
+  if (res.status) res.status(200);
+  if (res.end) res.end(data);
+  else if (res.send) res.send(data);
+}
+function send404(res) {
+  if (res.status) res.status(404);
+  res.setHeader("Content-Type", "text/plain");
+  if (res.end) res.end("Not Found");
+}
+function createServeStatic(dir, appPath) {
+  const normalizedApp = appPath.replace(/\/+$/, "") || "/app";
+  const dirResolved = path.resolve(dir);
+  return function serveStatic(req, res, next) {
+    const pathname = getPathname(req);
+    if (pathname !== normalizedApp && pathname !== normalizedApp + "/" && !pathname.startsWith(normalizedApp + "/")) {
+      return next();
+    }
+    let relative = pathname.slice(normalizedApp.length).replace(/^\/+/, "") || "";
+    if (relative === "" || pathname.endsWith("/")) relative = "index.html";
+    const filePath = path.join(dirResolved, relative);
+    const resolved = path.resolve(filePath);
+    if (!resolved.startsWith(dirResolved + path.sep) && resolved !== dirResolved) {
+      send404(res);
+      return;
+    }
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+      send404(res);
+      return;
+    }
+    const ext = path.extname(resolved);
+    const contentType = MIMES[ext] ?? "application/octet-stream";
+    sendFile(res, resolved, contentType);
+  };
+}
+
+// src/index.ts
+import {
+  getDefaultPlugins,
+  contextPlugin,
+  consolePlugin,
+  processErrorsPlugin,
+  pinoPlugin,
+  winstonPlugin,
+  defaultCorePlugins,
+  defaultLogPlugins,
+  defaultDbPlugins,
+  pgPlugin,
+  mysql2Plugin
+} from "@adjedaini/clockwork-plugins";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var DEFAULT_PATH = "/__clockwork";
+function getPathPrefix(p) {
+  return (p ?? DEFAULT_PATH).replace(/\/$/, "") || DEFAULT_PATH;
+}
+function startClockwork(options = {}) {
+  const coreConfig = options.core ?? {};
+  const core = new import_clockwork_core.MonitorCore(coreConfig);
+  core.start();
+  let getRequestIdRef = () => void 0;
+  let contextRunnerRef = null;
+  const pluginContext = {
+    get core() {
+      return core;
+    },
+    getRequestId() {
+      return getRequestIdRef();
+    },
+    registerContext(getRequestId, contextRunner2) {
+      getRequestIdRef = getRequestId;
+      contextRunnerRef = contextRunner2;
+    }
+  };
+  const plugins = options.plugins !== void 0 && options.plugins.length > 0 ? options.plugins : getDefaultPlugins({
+    console: options.autoConsole !== false,
+    errors: options.autoErrors !== false,
+    logPlugins: options.autoLogPlugins === true,
+    db: options.autoDb === true,
+    dbPlugins: options.dbPlugins
+  });
+  const restores = [];
+  for (const plugin of plugins) {
+    restores.push(plugin.install(pluginContext));
+  }
+  const contextRunner = contextRunnerRef ?? ((_, next) => next());
+  const pathPrefix = getPathPrefix(options.path ?? DEFAULT_PATH);
+  const adapter = (0, import_clockwork_transport_http.createHttpAdapter)(core, {
+    path: options.path,
+    contextRunner,
+    snapshotLimit: options.snapshotLimit,
+    redactKeys: options.redactKeys,
+    maxBodySize: options.maxBodySize,
+    maxBodyDepth: options.maxBodyDepth,
+    captureRequestBody: options.captureRequestBody,
+    captureResponseBody: options.captureResponseBody,
+    ignoreStartsWith: options.ignoreStartsWith
+  });
+  const uiPath = options.uiPath ?? path2.join(__dirname, "public");
+  const uiEnabled = options.ui !== false;
+  const serveUi = uiEnabled ? createServeStatic(uiPath, pathPrefix + "/app") : null;
+  function registerPlugin(plugin) {
+    restores.push(plugin.install(pluginContext));
+  }
+  const middleware = (req, res, next) => {
+    if (serveUi) {
+      serveUi(req, res, () => adapter.middleware(req, res, next));
+    } else {
+      adapter.middleware(req, res, next);
+    }
+  };
+  return {
+    core,
+    middleware,
+    handler: adapter.dataHandler,
+    uiPath,
+    registerPlugin,
+    restore() {
+      restores.forEach((r) => r());
+    }
+  };
+}
+var index_default = {
+  startClockwork,
+  MonitorCore: import_clockwork_core.MonitorCore,
+  createHttpAdapter: import_clockwork_transport_http.createHttpAdapter,
+  contextPlugin,
+  consolePlugin,
+  processErrorsPlugin,
+  pinoPlugin,
+  winstonPlugin,
+  pgPlugin,
+  mysql2Plugin,
+  defaultCorePlugins,
+  defaultLogPlugins,
+  defaultDbPlugins,
+  getDefaultPlugins
+};
+export {
+  consolePlugin,
+  contextPlugin,
+  index_default as default,
+  defaultCorePlugins,
+  defaultDbPlugins,
+  defaultLogPlugins,
+  getDefaultPlugins,
+  mysql2Plugin,
+  pgPlugin,
+  pinoPlugin,
+  processErrorsPlugin,
+  startClockwork,
+  winstonPlugin
+};