@singhak/nodeui-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1240 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConfirmationStore: () => ConfirmationStore,
+  CpuProvider: () => CpuProvider,
+  DEFAULT_LOG_SIZE: () => DEFAULT_LOG_SIZE,
+  EnvProvider: () => EnvProvider,
+  EventLoopLagProvider: () => EventLoopLagProvider,
+  HealthProvider: () => HealthProvider,
+  HeapSnapshotProvider: () => HeapSnapshotProvider,
+  LogsProvider: () => LogsProvider,
+  MemoryProvider: () => MemoryProvider,
+  MetricsProvider: () => MetricsProvider,
+  ProviderRegistry: () => ProviderRegistry,
+  RequestsProvider: () => RequestsProvider,
+  RingBuffer: () => RingBuffer,
+  RoutesProvider: () => RoutesProvider,
+  SECRET_KEY_PATTERN: () => SECRET_KEY_PATTERN,
+  SECRET_MASKED: () => SECRET_MASKED,
+  Sampler: () => Sampler,
+  StartupTracker: () => StartupTracker,
+  createNodeUI: () => createNodeUI,
+  extractRoutes: () => extractRoutes,
+  interceptConsole: () => interceptConsole,
+  isLoopbackAddress: () => isLoopbackAddress,
+  maskSecrets: () => maskSecrets,
+  resolveActivation: () => resolveActivation,
+  resolveStaticAsset: () => resolveStaticAsset,
+  serializeEnvelope: () => serializeEnvelope,
+  startSse: () => startSse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants.ts
+var SECRET_MASKED = "[REDACTED]";
+var DEFAULT_LOG_SIZE = 500;
+
+// src/ring-buffer.ts
+var RingBuffer = class {
+  buffer;
+  head = 0;
+  count = 0;
+  capacity;
+  constructor(size) {
+    if (!Number.isInteger(size) || size <= 0) {
+      throw new Error("RingBuffer size must be a positive integer");
+    }
+    this.capacity = size;
+    this.buffer = new Array(size);
+  }
+  push(item) {
+    this.buffer[(this.head + this.count) % this.capacity] = item;
+    if (this.count < this.capacity) {
+      this.count += 1;
+    } else {
+      this.head = (this.head + 1) % this.capacity;
+    }
+  }
+  get length() {
+    return this.count;
+  }
+  toArray() {
+    return this.slice(0, this.count);
+  }
+  /**
+   * Returns up to `limit` items starting at `offset`, oldest first.
+   */
+  slice(offset = 0, limit) {
+    const capped = limit === void 0 ? this.count : Math.max(0, limit);
+    const out = [];
+    for (let i = 0; i < this.count && out.length < capped; i += 1) {
+      if (i >= offset) out.push(this.buffer[(this.head + i) % this.capacity]);
+    }
+    return out;
+  }
+};
+
+// src/safety.ts
+var SECRET_KEY_PATTERN = /token|key|secret|password|credential/i;
+function resolveActivation(env) {
+  if (env.NODEUI_ENABLED === "true") {
+    return { active: true, reason: "activated by NODEUI_ENABLED=true" };
+  }
+  if (env.NODEUI_ENABLED === "false") {
+    return { active: false, reason: "inactive: explicitly disabled by NODEUI_ENABLED=false" };
+  }
+  if (env.NODE_ENV !== "production") {
+    return {
+      active: true,
+      reason: `activated by NODE_ENV="${env.NODE_ENV ?? "unset"}" (non-production)`
+    };
+  }
+  return {
+    active: false,
+    reason: "inactive: NODE_ENV=production and NODEUI_ENABLED is not 'true' (fail-closed)"
+  };
+}
+function isLoopbackAddress(address) {
+  if (!address) return false;
+  return address.startsWith("127.") || address === "::1" || address.startsWith("::ffff:127.") || address === "localhost";
+}
+function maskSecrets(value, pattern = SECRET_KEY_PATTERN) {
+  if (value !== null && typeof value === "object") {
+    if (Array.isArray(value)) {
+      return value.map((v) => maskSecrets(v, pattern));
+    }
+    const record = value;
+    const keys = Object.keys(record);
+    if (keys.length === 2 && keys.includes("key") && keys.includes("value") && typeof record.key === "string") {
+      const masked = pattern.test(record.key) ? SECRET_MASKED : record.value;
+      return { key: record.key, value: maskSecrets(masked, pattern) };
+    }
+    const out = {};
+    for (const [key, v] of Object.entries(value)) {
+      if (pattern.test(key)) {
+        out[key] = SECRET_MASKED;
+      } else {
+        out[key] = maskSecrets(v, pattern);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/confirmations.ts
+var import_node_crypto = require("crypto");
+var ConfirmationStore = class {
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  nonces = /* @__PURE__ */ new Map();
+  issue() {
+    this.prune();
+    const nonce = (0, import_node_crypto.randomBytes)(16).toString("hex");
+    const expiresAtMs = Date.now() + this.ttlMs;
+    this.nonces.set(nonce, expiresAtMs);
+    return { nonce, expiresAtMs, ttlMs: this.ttlMs };
+  }
+  /** Consumes `nonce` and returns true only if it was valid and unexpired. */
+  consume(nonce) {
+    this.prune();
+    const expiresAt = this.nonces.get(nonce);
+    if (expiresAt === void 0) return false;
+    this.nonces.delete(nonce);
+    return Date.now() <= expiresAt;
+  }
+  /** Number of currently valid nonces (after pruning). */
+  size() {
+    this.prune();
+    return this.nonces.size;
+  }
+  /** Removes expired nonces. */
+  prune() {
+    const now = Date.now();
+    for (const [nonce, expiresAt] of this.nonces) {
+      if (expiresAt <= now) this.nonces.delete(nonce);
+    }
+  }
+};
+
+// src/registry.ts
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  register(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  get(id) {
+    return this.providers.get(id);
+  }
+  ids() {
+    return [...this.providers.keys()];
+  }
+  all() {
+    return [...this.providers.values()];
+  }
+};
+
+// src/static.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".map": "application/json; charset=utf-8",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".webmanifest": "application/manifest+json"
+};
+function resolveStaticAsset(rootDir, urlPath) {
+  const relative = urlPath === "" ? "index.html" : urlPath.replace(/^\/+/, "");
+  const candidate = (0, import_node_path.resolve)(rootDir, relative);
+  const rootWithSep = rootDir.endsWith(import_node_path.sep) ? rootDir : rootDir + import_node_path.sep;
+  if (candidate !== rootDir && !candidate.startsWith(rootWithSep)) {
+    return null;
+  }
+  let file = candidate;
+  if ((0, import_node_fs.existsSync)(file) && (0, import_node_fs.statSync)(file).isDirectory()) {
+    file = (0, import_node_path.join)(file, "index.html");
+  }
+  if (!(0, import_node_fs.existsSync)(file) || !(0, import_node_fs.statSync)(file).isFile()) {
+    file = (0, import_node_path.join)(rootDir, "index.html");
+  }
+  if (!(0, import_node_fs.existsSync)(file)) {
+    return null;
+  }
+  const ext = file.slice(file.lastIndexOf(".")).toLowerCase();
+  const stat2 = (0, import_node_fs.statSync)(file);
+  return {
+    content: (0, import_node_fs.createReadStream)(file),
+    contentType: MIME_TYPES[ext] ?? "application/octet-stream",
+    length: stat2.size
+  };
+}
+
+// src/providers/sampler.ts
+var Sampler = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  timer = null;
+  start() {
+    if (this.timer) return;
+    const run = () => {
+      try {
+        this.opts.onSample(this.opts.collect());
+      } catch {
+      }
+    };
+    this.timer = setInterval(run, this.opts.intervalMs);
+    run();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  get isRunning() {
+    return this.timer !== null;
+  }
+};
+
+// src/providers/startup-tracker.ts
+var StartupTracker = class {
+  startedAtMs = Date.now();
+  marks = [];
+  mark(name) {
+    const atMs = Date.now();
+    this.marks.push({ name, atMs, sinceFirstMs: atMs - this.startedAtMs });
+  }
+  getData() {
+    return { startedAtMs: this.startedAtMs, marks: [...this.marks] };
+  }
+  reset() {
+    this.startedAtMs = Date.now();
+    this.marks = [];
+  }
+};
+
+// src/providers/memory.ts
+var import_node_os = require("os");
+var ZEROED = {
+  heapUsed: 0,
+  heapTotal: 0,
+  rss: 0,
+  external: 0,
+  totalMem: 0,
+  freeMem: 0,
+  sampleAtMs: 0
+};
+var MemoryProvider = class {
+  id = "memory";
+  sampler = null;
+  latest = ZEROED;
+  collect() {
+    const usage = process.memoryUsage();
+    return {
+      heapUsed: usage.heapUsed,
+      heapTotal: usage.heapTotal,
+      rss: usage.rss,
+      external: usage.external,
+      totalMem: (0, import_node_os.totalmem)(),
+      freeMem: (0, import_node_os.freemem)(),
+      sampleAtMs: Date.now()
+    };
+  }
+  start(ctx) {
+    if (this.sampler) return;
+    this.sampler = new Sampler({
+      intervalMs: ctx.config.pollIntervalMs,
+      collect: () => this.collect(),
+      onSample: (sample) => {
+        this.latest = sample;
+        ctx.store[this.id] = sample;
+      }
+    });
+    this.sampler.start();
+  }
+  stop() {
+    this.sampler?.stop();
+    this.sampler = null;
+  }
+  get() {
+    return { ok: true, data: this.latest };
+  }
+};
+
+// src/providers/cpu.ts
+var defaultClock = {
+  nowUs: () => process.hrtime.bigint() / 1000n,
+  cpuUsage: () => process.cpuUsage()
+};
+var ZEROED2 = { userPercent: 0, systemPercent: 0, totalPercent: 0, sampleAtMs: 0 };
+function clampPercent(v) {
+  return Math.min(100, Math.max(0, v));
+}
+var CpuProvider = class {
+  constructor(clock = defaultClock) {
+    this.clock = clock;
+  }
+  clock;
+  id = "cpu";
+  sampler = null;
+  latest = ZEROED2;
+  last = null;
+  /** Runs one sampling step immediately; called by the sampler on each tick. */
+  collect() {
+    const cpu = this.clock.cpuUsage();
+    const atUs = this.clock.nowUs();
+    let sample = { ...ZEROED2, sampleAtMs: Date.now() };
+    if (this.last) {
+      const userUs = cpu.user - this.last.cpu.user;
+      const systemUs = cpu.system - this.last.cpu.system;
+      const elapsedUs = Number(atUs - this.last.atUs);
+      if (elapsedUs > 0) {
+        sample = {
+          userPercent: clampPercent(userUs / elapsedUs * 100),
+          systemPercent: clampPercent(systemUs / elapsedUs * 100),
+          totalPercent: clampPercent((userUs + systemUs) / elapsedUs * 100),
+          sampleAtMs: Date.now()
+        };
+      }
+    }
+    this.last = { cpu, atUs };
+    this.latest = sample;
+    return sample;
+  }
+  start(ctx) {
+    if (this.sampler) return;
+    this.sampler = new Sampler({
+      intervalMs: ctx.config.pollIntervalMs,
+      collect: () => this.collect(),
+      onSample: (sample) => {
+        this.latest = sample;
+        ctx.store[this.id] = sample;
+      }
+    });
+    this.sampler.start();
+  }
+  stop() {
+    this.sampler?.stop();
+    this.sampler = null;
+  }
+  get() {
+    return { ok: true, data: this.latest };
+  }
+};
+
+// src/providers/event-loop.ts
+var defaultClock2 = {
+  nowNs: () => process.hrtime.bigint()
+};
+var MAX_KEPT_SAMPLES = 600;
+var ZEROED3 = {
+  currentMs: 0,
+  maxMs: 0,
+  avgMs: 0,
+  count: 0,
+  sampleAtMs: 0
+};
+var EventLoopLagProvider = class {
+  constructor(clock = defaultClock2) {
+    this.clock = clock;
+  }
+  clock;
+  id = "event-loop";
+  sampler = null;
+  samples = [];
+  latest = ZEROED3;
+  lastFireNs = null;
+  /** Runs one measurement tick; called by the sampler on each interval. */
+  collect(intervalMs) {
+    const nowNs = this.clock.nowNs();
+    let lagMs = 0;
+    if (this.lastFireNs !== null) {
+      const elapsedMs = Number(nowNs - this.lastFireNs) / 1e6;
+      lagMs = Math.max(0, elapsedMs - intervalMs);
+    }
+    this.lastFireNs = nowNs;
+    this.samples.push(lagMs);
+    if (this.samples.length > MAX_KEPT_SAMPLES) this.samples.shift();
+    const count = this.samples.length;
+    const total = this.samples.reduce((acc, v) => acc + v, 0);
+    const sample = {
+      currentMs: lagMs,
+      maxMs: Math.max(...this.samples),
+      avgMs: count > 0 ? total / count : 0,
+      count,
+      sampleAtMs: Date.now()
+    };
+    this.latest = sample;
+    return sample;
+  }
+  start(ctx) {
+    if (this.sampler) return;
+    this.lastFireNs = this.clock.nowNs();
+    this.sampler = new Sampler({
+      intervalMs: ctx.config.pollIntervalMs,
+      collect: () => this.collect(ctx.config.pollIntervalMs),
+      onSample: (sample) => {
+        this.latest = sample;
+        ctx.store[this.id] = sample;
+      }
+    });
+    this.sampler.start();
+  }
+  stop() {
+    this.sampler?.stop();
+    this.sampler = null;
+  }
+  get() {
+    return { ok: true, data: this.latest };
+  }
+};
+
+// src/providers/health.ts
+var LAG_OK_MS = 50;
+var LAG_DEGRADED_MS = 200;
+var HealthProvider = class {
+  id = "health";
+  get(ctx) {
+    const loop = ctx.store["event-loop"];
+    const memory = ctx.store.memory;
+    const lagMs = typeof loop?.currentMs === "number" ? loop.currentMs : null;
+    const totalMem = typeof memory?.totalMem === "number" ? memory.totalMem : 0;
+    const rss = typeof memory?.rss === "number" ? memory.rss : 0;
+    const memoryUsedPercent = totalMem > 0 ? rss / totalMem * 100 : null;
+    let status;
+    let statusReason;
+    if (lagMs === null) {
+      status = "unknown";
+      statusReason = "no event-loop samples yet (open the Event-loop panel)";
+    } else if (lagMs < LAG_OK_MS) {
+      status = "ok";
+      statusReason = `event-loop lag ${lagMs.toFixed(1)}ms below ${LAG_OK_MS}ms`;
+    } else if (lagMs < LAG_DEGRADED_MS) {
+      status = "degraded";
+      statusReason = `event-loop lag ${lagMs.toFixed(1)}ms between ${LAG_OK_MS}ms and ${LAG_DEGRADED_MS}ms`;
+    } else {
+      status = "critical";
+      statusReason = `event-loop lag ${lagMs.toFixed(1)}ms above ${LAG_DEGRADED_MS}ms`;
+    }
+    return {
+      ok: true,
+      data: {
+        status,
+        statusReason,
+        uptimeSeconds: Math.round(process.uptime()),
+        pid: process.pid,
+        nodeVersion: process.version,
+        platform: process.platform,
+        eventLoopLagMs: lagMs,
+        memoryUsedPercent
+      }
+    };
+  }
+};
+
+// src/providers/heap-snapshot.ts
+var import_promises = require("fs/promises");
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
+var import_node_v8 = require("v8");
+function defaultSnapshotDir() {
+  return process.env.NODEUI_HEAP_SNAPSHOT_DIR ?? (0, import_node_os2.tmpdir)();
+}
+var HeapSnapshotProvider = class {
+  id = "heap-snapshot";
+  lastSnapshot = null;
+  get() {
+    return { ok: true, data: { supported: true, lastSnapshot: this.lastSnapshot } };
+  }
+  async takeSnapshot(ctx) {
+    const dir = ctx.config.heapSnapshotDir || defaultSnapshotDir();
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const fileName = `nodeui-heap-${process.pid}-${stamp}.heapsnapshot`;
+    const filePath = (0, import_node_path2.join)(dir, fileName);
+    try {
+      await (0, import_promises.mkdir)(dir, { recursive: true });
+      (0, import_node_v8.writeHeapSnapshot)(filePath);
+      const fileStat = await (0, import_promises.stat)(filePath);
+      const data = {
+        fileName,
+        filePath,
+        sizeBytes: fileStat.size,
+        createdAtMs: Date.now()
+      };
+      this.lastSnapshot = data;
+      return { ok: true, data };
+    } catch (err) {
+      return {
+        ok: false,
+        error: {
+          code: "heap-snapshot-failed",
+          message: err instanceof Error ? err.message : "heap snapshot failed"
+        }
+      };
+    }
+  }
+};
+
+// src/providers/requests.ts
+var RESPONSE_PAGE_SIZE = 100;
+var RequestsProvider = class {
+  id = "requests";
+  buffer;
+  nextId = 1;
+  constructor(size) {
+    this.buffer = new RingBuffer(size);
+  }
+  record(entry) {
+    this.buffer.push({ id: this.nextId, ...entry });
+    this.nextId += 1;
+  }
+  get length() {
+    return this.buffer.length;
+  }
+  get() {
+    const entries = this.buffer.slice(Math.max(0, this.buffer.length - RESPONSE_PAGE_SIZE));
+    return { ok: true, data: { total: this.buffer.length, entries } };
+  }
+};
+
+// src/providers/metrics.ts
+var WINDOW_SECONDS = 60;
+var MetricsProvider = class {
+  id = "metrics";
+  buckets = [];
+  nowMs;
+  constructor(nowMs = Date.now) {
+    this.nowMs = nowMs;
+  }
+  /** Ticks the current second bucket for one completed request. */
+  record(status) {
+    const ts = Math.floor(this.nowMs() / 1e3) * 1e3;
+    const last = this.buckets[this.buckets.length - 1];
+    if (last && last.ts === ts) {
+      last.requests += 1;
+      if (status >= 500) last.errors += 1;
+      return;
+    }
+    this.buckets.push({ ts, requests: 1, errors: status >= 500 ? 1 : 0 });
+    if (this.buckets.length > WINDOW_SECONDS + 1) {
+      this.buckets.splice(0, this.buckets.length - WINDOW_SECONDS);
+    }
+  }
+  get() {
+    const now = Math.floor(this.nowMs() / 1e3) * 1e3;
+    const start = now - (WINDOW_SECONDS - 1) * 1e3;
+    const byTs = new Map(this.buckets.map((b) => [b.ts, b]));
+    const buckets = [];
+    for (let ts = start; ts <= now; ts += 1e3) {
+      const existing = byTs.get(ts);
+      buckets.push(existing ? { ...existing } : { ts, requests: 0, errors: 0 });
+    }
+    return { ok: true, data: { buckets } };
+  }
+};
+
+// src/providers/env.ts
+function stringify(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function toEntries(source) {
+  return Object.entries(source).map(([key, value]) => ({ key, value: stringify(value) })).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+}
+var EnvProvider = class {
+  id = "env";
+  get(ctx) {
+    const environment = toEntries(ctx.env);
+    const rawConfig = ctx.store["app-config"];
+    let config = null;
+    if (rawConfig !== void 0) {
+      const resolved = typeof rawConfig === "function" ? rawConfig() : rawConfig;
+      if (resolved !== void 0 && resolved !== null) {
+        config = toEntries(resolved);
+      }
+    }
+    return { ok: true, data: { environment, config } };
+  }
+};
+
+// src/providers/routes.ts
+function joinPath(prefix, sub) {
+  if (!sub || sub === "/") return prefix || "/";
+  return `${prefix.replace(/\/+$/, "")}/${sub.replace(/^\/+/, "")}`;
+}
+function extractRoutes(router) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  let stack;
+  try {
+    stack = router?.stack;
+  } catch {
+    return out;
+  }
+  if (!Array.isArray(stack)) return out;
+  const walk = (layers, prefix) => {
+    for (const layer of layers) {
+      if (!layer || typeof layer !== "object") continue;
+      if (layer.route && typeof layer.route.path === "string") {
+        const path = joinPath(prefix, layer.route.path);
+        const methods = Object.entries(layer.route.methods ?? {}).filter(([, enabled]) => enabled).map(([method]) => method.toUpperCase());
+        const handler = layer.route.stack?.[0]?.handle?.name || "anonymous";
+        if (methods.length === 0) continue;
+        for (const method of methods) {
+          const key = `${method} ${path}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          out.push({ method, path, handler });
+        }
+        continue;
+      }
+      const nested = layer.handle?.stack;
+      if (Array.isArray(nested)) {
+        walk(nested, joinPath(prefix, layer.path ?? ""));
+      }
+    }
+  };
+  try {
+    walk(stack, "");
+  } catch {
+    return [];
+  }
+  out.sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+  return out;
+}
+var RoutesProvider = class {
+  id = "routes";
+  cache = /* @__PURE__ */ new WeakMap();
+  get(ctx) {
+    const router = ctx.store["express-router"];
+    if (!router) {
+      return {
+        ok: false,
+        error: {
+          code: "router-unavailable",
+          message: "No Express router captured yet. Send at least one request through the app."
+        }
+      };
+    }
+    if (typeof router !== "object" && typeof router !== "function") {
+      return {
+        ok: false,
+        error: {
+          code: "router-invalid",
+          message: "Captured router has an unexpected shape; route listing is unavailable."
+        }
+      };
+    }
+    let routes = this.cache.get(router);
+    if (!routes) {
+      routes = extractRoutes(router);
+      this.cache.set(router, routes);
+    }
+    return { ok: true, data: { routes } };
+  }
+};
+
+// src/providers/logs.ts
+var CONSOLE_METHODS = [
+  ["debug", "debug"],
+  ["info", "info"],
+  ["log", "info"],
+  ["warn", "warn"],
+  ["error", "error"]
+];
+function formatArg(arg) {
+  if (typeof arg === "string") return arg;
+  try {
+    const json = JSON.stringify(arg);
+    return json === void 0 ? String(arg) : json;
+  } catch {
+    return String(arg);
+  }
+}
+var refs = 0;
+var pushes = /* @__PURE__ */ new Set();
+var wrappers = /* @__PURE__ */ new Map();
+var originals = {};
+function consoleRef() {
+  return console;
+}
+function installWrappers() {
+  for (const [method, level] of CONSOLE_METHODS) {
+    const original = consoleRef()[method];
+    originals[method] = original;
+    const wrapper = (...args) => {
+      for (const push of pushes) {
+        try {
+          push({ level, message: args.map(formatArg).join(" ") });
+        } catch {
+        }
+      }
+      if (original) original(...args);
+    };
+    wrappers.set(method, wrapper);
+    consoleRef()[method] = wrapper;
+  }
+}
+function uninstallWrappers() {
+  for (const [method] of CONSOLE_METHODS) {
+    const current = consoleRef()[method];
+    if (current === wrappers.get(method)) {
+      const original = originals[method];
+      if (original) {
+        consoleRef()[method] = original;
+      } else {
+        delete consoleRef()[method];
+      }
+    }
+  }
+  wrappers.clear();
+  originals = {};
+}
+function interceptConsole(push) {
+  refs += 1;
+  pushes.add(push);
+  if (refs === 1) installWrappers();
+  return () => {
+    pushes.delete(push);
+    refs = Math.max(0, refs - 1);
+    if (refs === 0) uninstallWrappers();
+  };
+}
+var LogsProvider = class {
+  id = "logs";
+  buffer;
+  release = null;
+  constructor(size = DEFAULT_LOG_SIZE) {
+    this.buffer = new RingBuffer(size);
+  }
+  start() {
+    if (this.release) return;
+    this.release = interceptConsole(({ level, message }) => {
+      this.buffer.push({ level, message, timestamp: Date.now() });
+    });
+  }
+  stop() {
+    this.release?.();
+    this.release = null;
+  }
+  /** Pushes an external entry (logger adapter). */
+  addSource(entry) {
+    this.buffer.push({ ...entry, timestamp: Date.now() });
+  }
+  get(ctx) {
+    let entries = this.buffer.toArray();
+    const level = ctx.query?.level;
+    if (level) entries = entries.filter((e) => e.level === level);
+    const query = ctx.query?.query;
+    if (query) {
+      const needle = query.toLowerCase();
+      entries = entries.filter((e) => e.message.toLowerCase().includes(needle));
+    }
+    return { ok: true, data: { entries } };
+  }
+};
+
+// src/sse.ts
+function startSse(res) {
+  let closed = false;
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  res.flushHeaders?.();
+  return {
+    send(payload) {
+      if (closed || res.destroyed) return;
+      res.write(`data: ${JSON.stringify(payload)}
+
+`);
+    },
+    heartbeat() {
+      if (closed || res.destroyed) return;
+      res.write(":ping\n\n");
+    },
+    close() {
+      if (closed || res.destroyed) return;
+      closed = true;
+      res.end();
+    }
+  };
+}
+
+// src/server.ts
+var import_node_os3 = require("os");
+var import_node_path3 = require("path");
+var STATIC_ROOT = (0, import_node_path3.resolve)(__dirname, "..", "static");
+var SSE_HEARTBEAT_MS = 15e3;
+function serializeEnvelope(envelope) {
+  return JSON.stringify(maskSecrets(envelope));
+}
+function pathnameOf(req) {
+  const raw = req.originalUrl ?? req.url ?? "/";
+  try {
+    return new URL(raw, "http://localhost").pathname;
+  } catch {
+    return raw;
+  }
+}
+function normalizePath(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("/")) throw new Error(`NODEUI_PATH must start with "/", got "${value}"`);
+  return trimmed.replace(/\/+$/, "") || "/";
+}
+function positiveInt(value, fallback, name) {
+  const n = value === void 0 ? fallback : value;
+  if (!Number.isInteger(n) || n <= 0) throw new Error(`${name} must be a positive integer`);
+  return n;
+}
+function createNodeUI(options = {}) {
+  const env = options.env ?? process.env;
+  const activation = options.enabled !== void 0 ? {
+    active: options.enabled,
+    reason: options.enabled ? "explicitly enabled via options" : "explicitly disabled via options"
+  } : resolveActivation(env);
+  const path = normalizePath(options.path ?? env.NODEUI_PATH ?? "/nodeui");
+  const host = options.host ?? env.NODEUI_HOST ?? "127.0.0.1";
+  const config = {
+    path,
+    host,
+    port: options.port ?? (env.NODEUI_PORT ? Number(env.NODEUI_PORT) : 0),
+    requestLogSize: positiveInt(
+      options.requestLogSize,
+      env.NODEUI_REQUEST_LOG_SIZE ? Number(env.NODEUI_REQUEST_LOG_SIZE) : 500,
+      "NODEUI_REQUEST_LOG_SIZE"
+    ),
+    logSize: positiveInt(
+      options.logSize,
+      env.NODEUI_LOG_SIZE ? Number(env.NODEUI_LOG_SIZE) : DEFAULT_LOG_SIZE,
+      "NODEUI_LOG_SIZE"
+    ),
+    pollIntervalMs: positiveInt(
+      options.pollIntervalMs,
+      env.NODEUI_POLL_INTERVAL_MS ? Number(env.NODEUI_POLL_INTERVAL_MS) : 2e3,
+      "NODEUI_POLL_INTERVAL_MS"
+    ),
+    enabled: activation.active,
+    activationReason: activation.reason,
+    maskSecrets: options.maskSecrets ?? true,
+    inactivityTimeoutMs: positiveInt(
+      options.inactivityTimeoutMs,
+      env.NODEUI_INACTIVITY_TIMEOUT_MS ? Number(env.NODEUI_INACTIVITY_TIMEOUT_MS) : 6e4,
+      "NODEUI_INACTIVITY_TIMEOUT_MS"
+    ),
+    confirmTtlMs: positiveInt(
+      options.confirmTtlMs,
+      env.NODEUI_CONFIRM_TTL_MS ? Number(env.NODEUI_CONFIRM_TTL_MS) : 6e4,
+      "NODEUI_CONFIRM_TTL_MS"
+    ),
+    heapSnapshotDir: options.heapSnapshotDir ?? env.NODEUI_HEAP_SNAPSHOT_DIR ?? (0, import_node_os3.tmpdir)()
+  };
+  if (!isLoopbackAddress(config.host)) {
+    console.warn(
+      `[nodeui] NODEUI_HOST is set to non-loopback "${config.host}". The developer console will be reachable from other hosts; only do this deliberately.`
+    );
+  }
+  const ctx = { config, env, store: {} };
+  if (options.config !== void 0) {
+    ctx.store["app-config"] = options.config;
+  }
+  const registry = new ProviderRegistry();
+  registry.register(new HealthProvider());
+  registry.register(new MemoryProvider());
+  registry.register(new CpuProvider());
+  registry.register(new EventLoopLagProvider());
+  registry.register(new HeapSnapshotProvider());
+  const startupTracker = new StartupTracker();
+  startupTracker.mark("nodeui.init");
+  const startupProvider = {
+    id: "startup",
+    get: () => ({ ok: true, data: startupTracker.getData() })
+  };
+  registry.register(startupProvider);
+  const requestsProvider = new RequestsProvider(config.requestLogSize);
+  registry.register(requestsProvider);
+  const metricsProvider = new MetricsProvider();
+  registry.register(metricsProvider);
+  const logsProvider = new LogsProvider(config.logSize);
+  registry.register(logsProvider);
+  const envProvider = new EnvProvider();
+  registry.register(envProvider);
+  const routesProvider = new RoutesProvider();
+  registry.register(routesProvider);
+  const confirmations = new ConfirmationStore(config.confirmTtlMs);
+  const activeProviders = /* @__PURE__ */ new Set();
+  let inactivityTimer = null;
+  function stopAll() {
+    for (const id of activeProviders) {
+      registry.get(id)?.stop?.(ctx);
+    }
+    activeProviders.clear();
+    if (inactivityTimer) {
+      clearTimeout(inactivityTimer);
+      inactivityTimer = null;
+    }
+  }
+  function resetInactivityTimer() {
+    if (inactivityTimer) clearTimeout(inactivityTimer);
+    inactivityTimer = setTimeout(stopAll, config.inactivityTimeoutMs);
+    if (typeof inactivityTimer.unref === "function") inactivityTimer.unref();
+  }
+  function ensureActive(id) {
+    if (!activeProviders.has(id)) {
+      registry.get(id)?.start?.(ctx);
+      activeProviders.add(id);
+    }
+    resetInactivityTimer();
+  }
+  function sendJson(res, status, envelope) {
+    const body = serializeEnvelope(envelope);
+    res.writeHead(status, {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(body),
+      "Cache-Control": "no-store"
+    });
+    res.end(body);
+  }
+  function notFound(res) {
+    sendJson(res, 404, { ok: false, error: { code: "not-found", message: "Not found" } });
+  }
+  function isUnderPath(urlPath) {
+    return urlPath === path || urlPath.startsWith(`${path}/`);
+  }
+  async function servePanel(res, id, query) {
+    ensureActive(id);
+    const provider = registry.get(id);
+    if (!provider) return notFound(res);
+    const requestCtx = query ? { ...ctx, query } : ctx;
+    const result = await provider.get(requestCtx);
+    sendJson(res, result.ok ? 200 : 500, result);
+  }
+  function configData() {
+    return {
+      enabled: config.enabled,
+      activationReason: config.activationReason,
+      path: config.path,
+      host: config.host,
+      port: config.port,
+      requestLogSize: config.requestLogSize,
+      logSize: config.logSize,
+      pollIntervalMs: config.pollIntervalMs,
+      panels: registry.ids(),
+      masking: { enabled: config.maskSecrets, pattern: SECRET_KEY_PATTERN.source }
+    };
+  }
+  function issueConfirmation(res) {
+    const issued = confirmations.issue();
+    sendJson(res, 200, { ok: true, data: issued });
+  }
+  async function takeHeapSnapshot(req, res) {
+    const header = req.headers["x-nodeui-confirm"];
+    const nonce = Array.isArray(header) ? header[0] : header;
+    if (typeof nonce !== "string" || !confirmations.consume(nonce)) {
+      sendJson(res, 409, {
+        ok: false,
+        error: {
+          code: "confirmation-required",
+          message: `This mutating action needs a fresh confirmation nonce. Issue one via POST ${path}/api/confirmations and repeat the request with an x-nodeui-confirm header.`
+        }
+      });
+      return;
+    }
+    const heapProvider = registry.get("heap-snapshot");
+    if (!heapProvider || !("takeSnapshot" in heapProvider)) return notFound(res);
+    const result = await heapProvider.takeSnapshot(
+      ctx
+    );
+    sendJson(res, result.ok ? 200 : 500, result);
+  }
+  async function handleLive(req, res) {
+    const search = new URL(req.url ?? "/", "http://localhost").searchParams;
+    const requested = (search.get("panels") ?? "").split(",").filter(Boolean);
+    const panels = (requested.length > 0 ? requested.filter((id) => registry.get(id) !== void 0) : registry.ids()).filter((value, index, self) => self.indexOf(value) === index);
+    if (panels.length === 0) return notFound(res);
+    const stream = startSse(res);
+    const push = async () => {
+      for (const id of panels) {
+        ensureActive(id);
+        const provider = registry.get(id);
+        if (!provider) continue;
+        const result = await provider.get(ctx);
+        stream.send({ panel: id, envelope: result });
+      }
+    };
+    void push();
+    const pushTimer = setInterval(() => void push(), config.pollIntervalMs);
+    const heartbeatTimer = setInterval(() => stream.heartbeat(), SSE_HEARTBEAT_MS);
+    if (typeof pushTimer.unref === "function") pushTimer.unref();
+    if (typeof heartbeatTimer.unref === "function") heartbeatTimer.unref();
+    const cleanup = () => {
+      clearInterval(pushTimer);
+      clearInterval(heartbeatTimer);
+      stream.close();
+    };
+    req.on("close", cleanup);
+    res.on("close", cleanup);
+  }
+  async function handleApi(req, res, apiPath) {
+    const method = (req.method ?? "GET").toUpperCase();
+    if (method === "GET" && apiPath === "/config") {
+      sendJson(res, 200, { ok: true, data: configData() });
+      return;
+    }
+    if (method === "GET" && apiPath === "/live") {
+      return handleLive(req, res);
+    }
+    if (method === "GET") {
+      const panel = registry.get(apiPath.slice(1));
+      if (panel) {
+        const query = Object.fromEntries(new URL(req.url ?? "/", "http://localhost").searchParams);
+        return servePanel(res, panel.id, query);
+      }
+    }
+    if (method === "POST") {
+      if (apiPath === "/confirmations") {
+        issueConfirmation(res);
+        return;
+      }
+      if (apiPath === "/heap-snapshot") {
+        return takeHeapSnapshot(req, res);
+      }
+    }
+    notFound(res);
+  }
+  function serveStatic(req, res, urlPath) {
+    const relative = urlPath.slice(path.length);
+    const asset = resolveStaticAsset(STATIC_ROOT, relative);
+    if (!asset) {
+      sendJson(res, 404, { ok: false, error: { code: "not-found", message: "Not found" } });
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": asset.contentType,
+      "Content-Length": asset.length,
+      "Cache-Control": "no-cache"
+    });
+    asset.content.pipe(res);
+  }
+  function guardLoopback(req, res) {
+    if (isLoopbackAddress(config.host)) {
+      const remote = req.socket.remoteAddress;
+      if (!isLoopbackAddress(remote)) {
+        sendJson(res, 403, {
+          ok: false,
+          error: {
+            code: "forbidden",
+            message: "nodeui is loopback-only; requests from other hosts are rejected"
+          }
+        });
+        return false;
+      }
+    }
+    return true;
+  }
+  async function handleNodeUIPath(req, res, urlPath) {
+    if (!guardLoopback(req, res)) return;
+    const apiBase = `${path}/api`;
+    if (urlPath === apiBase || urlPath.startsWith(`${apiBase}/`)) {
+      await handleApi(req, res, urlPath.slice(apiBase.length));
+      return;
+    }
+    serveStatic(req, res, urlPath);
+  }
+  function captureRouter(req) {
+    if (ctx.store["express-router"] !== void 0) return;
+    const app = req.app;
+    if (!app) return;
+    let router;
+    try {
+      router = app._router;
+    } catch {
+      router = void 0;
+    }
+    if (router === void 0) {
+      try {
+        router = app.router;
+      } catch {
+        router = void 0;
+      }
+    }
+    if (router) {
+      ctx.store["express-router"] = router;
+    }
+  }
+  function recordAppRequest(req, res) {
+    const started = process.hrtime.bigint();
+    const timestampMs = Date.now();
+    res.on("finish", () => {
+      const durationMs = Number(process.hrtime.bigint() - started) / 1e6;
+      requestsProvider.record({
+        method: req.method ?? "?",
+        path: pathnameOf(req),
+        status: res.statusCode,
+        durationMs,
+        timestampMs,
+        ip: req.socket.remoteAddress ?? "unknown"
+      });
+      metricsProvider.record(res.statusCode);
+    });
+  }
+  const server = {
+    get config() {
+      return config;
+    },
+    get active() {
+      return config.enabled;
+    },
+    get activationReason() {
+      return config.activationReason;
+    },
+    middleware() {
+      return (req, res, next) => {
+        captureRouter(req);
+        if (!config.enabled) {
+          next();
+          return;
+        }
+        const urlPath = pathnameOf(req);
+        if (isUnderPath(urlPath)) {
+          void handleNodeUIPath(req, res, urlPath);
+          return;
+        }
+        recordAppRequest(req, res);
+        next();
+      };
+    },
+    async handle(req, res) {
+      captureRouter(req);
+      if (!config.enabled) {
+        notFound(res);
+        return;
+      }
+      const urlPath = pathnameOf(req);
+      if (isUnderPath(urlPath)) {
+        await handleNodeUIPath(req, res, urlPath);
+        return;
+      }
+      notFound(res);
+    },
+    mark(name) {
+      startupTracker.mark(name);
+    },
+    isProviderActive(id) {
+      return activeProviders.has(id);
+    },
+    addLogSource(entry) {
+      logsProvider.addSource(entry);
+    },
+    shutdown() {
+      stopAll();
+    }
+  };
+  return server;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfirmationStore,
+  CpuProvider,
+  DEFAULT_LOG_SIZE,
+  EnvProvider,
+  EventLoopLagProvider,
+  HealthProvider,
+  HeapSnapshotProvider,
+  LogsProvider,
+  MemoryProvider,
+  MetricsProvider,
+  ProviderRegistry,
+  RequestsProvider,
+  RingBuffer,
+  RoutesProvider,
+  SECRET_KEY_PATTERN,
+  SECRET_MASKED,
+  Sampler,
+  StartupTracker,
+  createNodeUI,
+  extractRoutes,
+  interceptConsole,
+  isLoopbackAddress,
+  maskSecrets,
+  resolveActivation,
+  resolveStaticAsset,
+  serializeEnvelope,
+  startSse
+});
+//# sourceMappingURL=index.cjs.map