@singhak/nodeui-cli 0.0.0-stage → 0.5.0

package/dist/index.cjs

@@ -0,0 +1,761 @@
+"use strict";
+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 __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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  PanelError: () => PanelError,
+  attach: () => attach,
+  attachEnv: () => attachEnv,
+  buildDigest: () => buildDigest,
+  fetchPanel: () => fetchPanel,
+  parseTarget: () => parseTarget,
+  preloadPath: () => preloadPath,
+  serveMcp: () => serveMcp,
+  startDashboard: () => startDashboard
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/attach.ts
+var import_node_child_process = require("child_process");
+var import_node_path = require("path");
+function preloadPath() {
+  return (0, import_node_path.join)(__dirname, "preload.cjs").replace(/\\/g, "/");
+}
+function attachEnv(base, options, preload = preloadPath()) {
+  const env = { ...base };
+  env.NODE_OPTIONS = [base.NODE_OPTIONS, `--require "${preload}"`].filter(Boolean).join(" ");
+  if (options.path) env.NODEUI_PATH = options.path;
+  if (options.token) env.NODEUI_TOKEN = options.token;
+  if (options.persist) env.NODEUI_PERSIST_FILE = options.persist;
+  if (options.otlp) env.NODEUI_OTLP_ENDPOINT = options.otlp;
+  if (options.bodies) env.NODEUI_CAPTURE_BODIES = "true";
+  if (options.force) env.NODEUI_ENABLED = "true";
+  return env;
+}
+function attach(command, options) {
+  const [cmd, ...args] = command;
+  if (!cmd) return Promise.reject(new Error("nothing to run; usage: nodeui attach -- node app.js"));
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process.spawn)(cmd, args, {
+      stdio: "inherit",
+      env: attachEnv(process.env, options),
+      shell: process.platform === "win32"
+    });
+    const onInt = () => {
+      child.kill("SIGINT");
+    };
+    const onTerm = () => {
+      child.kill("SIGTERM");
+    };
+    const cleanup = () => {
+      process.off("SIGINT", onInt);
+      process.off("SIGTERM", onTerm);
+    };
+    process.on("SIGINT", onInt);
+    process.on("SIGTERM", onTerm);
+    child.on("error", (err) => {
+      cleanup();
+      reject(err);
+    });
+    child.on("exit", (code, signal) => {
+      cleanup();
+      resolve(code ?? (signal ? 1 : 0));
+    });
+  });
+}
+
+// src/dashboard.ts
+var import_node_http = __toESM(require("http"));
+var import_node_https = __toESM(require("https"));
+var import_nodeui_core = require("@singhak/nodeui-core");
+
+// src/targets.ts
+var NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,39}$/;
+function parseTarget(spec) {
+  const eq = spec.indexOf("=");
+  const hasName = eq > 0 && !spec.slice(0, eq).includes("/") && !spec.slice(0, eq).includes(":");
+  const rawUrl = hasName ? spec.slice(eq + 1) : spec;
+  let url;
+  try {
+    url = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(rawUrl) ? rawUrl : `http://${rawUrl}`);
+  } catch {
+    throw new Error(`invalid service URL "${rawUrl}"`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`service URL must be http(s), got "${rawUrl}"`);
+  }
+  const name = hasName ? spec.slice(0, eq) : `${url.hostname}-${url.port || "80"}`;
+  if (!NAME_PATTERN.test(name)) {
+    throw new Error(`invalid service name "${name}" (letters, digits, ".", "-" and "_")`);
+  }
+  const token = url.searchParams.get("token") ?? void 0;
+  const path = url.pathname.replace(/\/+$/, "") || "/nodeui";
+  return { name, base: `${url.origin}${path}`, token };
+}
+var PanelError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "PanelError";
+  }
+  code;
+};
+async function fetchPanel(target, panel, timeoutMs = 3e3) {
+  const headers = { accept: "application/json" };
+  if (target.token) headers.authorization = `Bearer ${target.token}`;
+  let res;
+  try {
+    res = await fetch(`${target.base}/api/${panel}`, {
+      headers,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (err) {
+    throw new PanelError(
+      `cannot reach ${target.name} at ${target.base}: ${err instanceof Error ? err.message : String(err)}`,
+      "unreachable"
+    );
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new PanelError(`${target.name}: invalid response (HTTP ${res.status})`, "invalid");
+  }
+  if (!body.ok) {
+    throw new PanelError(body.error?.message ?? `HTTP ${res.status}`, body.error?.code ?? "error");
+  }
+  return body.data;
+}
+
+// src/dashboard.ts
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var PAGE = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>NodeUI services</title>
+<style>
+:root{--bg:#0f1115;--fg:#e6e8ee;--card:#181b22;--bd:#2a2f3a;--mut:#8b93a5;--ok:#3ecf8e;--warn:#f5a524;--bad:#f0616d}
+@media (prefers-color-scheme:light){:root{--bg:#f6f7f9;--fg:#15171c;--card:#fff;--bd:#dfe3ea;--mut:#5d6578}}
+body{margin:0;background:var(--bg);color:var(--fg);font:14px/1.5 system-ui,sans-serif}
+main{max-width:960px;margin:0 auto;padding:24px 16px}
+h1{font-size:20px;margin:0 0 4px}p.sub{color:var(--mut);margin:0 0 20px}
+.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(260px,1fr));gap:12px}
+a.card{display:block;background:var(--card);border:1px solid var(--bd);border-radius:10px;padding:14px;color:inherit;text-decoration:none}
+a.card:hover{border-color:var(--mut)}
+.name{font-weight:600;font-size:16px;display:flex;align-items:center;gap:8px}
+.dot{width:9px;height:9px;border-radius:50%;background:var(--mut)}
+.ok{background:var(--ok)}.degraded{background:var(--warn)}.critical,.down{background:var(--bad)}
+.url{color:var(--mut);font-size:12px;word-break:break-all;margin:2px 0 10px}
+dl{display:grid;grid-template-columns:auto 1fr;gap:2px 12px;margin:0}dt{color:var(--mut)}dd{margin:0;text-align:right}
+.reason{color:var(--bad);font-size:13px}
+</style></head><body><main>
+<h1>NodeUI services</h1><p class="sub">Local services, refreshed every 3 seconds. Select one to open its console.</p>
+<div class="grid" id="grid"></div></main>
+<script src="/_dashboard.js"></script></body></html>`;
+var SCRIPT = `
+const grid = document.getElementById('grid');
+function el(tag, cls, text) {
+  const e = document.createElement(tag);
+  if (cls) e.className = cls;
+  if (text !== undefined) e.textContent = text;
+  return e;
+}
+function row(dl, k, v) { dl.append(el('dt', '', k), el('dd', '', v)); }
+async function refresh() {
+  let list;
+  try { list = (await (await fetch('api/services')).json()).data; } catch { return; }
+  grid.replaceChildren(...list.map((s) => {
+    const card = el('a', 'card');
+    card.href = 's/' + encodeURIComponent(s.name) + '/';
+    const title = el('div', 'name');
+    title.append(el('span', 'dot ' + (s.up ? (s.health || 'ok') : 'down')), el('span', '', s.name));
+    card.append(title, el('div', 'url', s.url));
+    if (!s.up) { card.append(el('div', 'reason', s.reason || 'unreachable')); return card; }
+    const dl = el('dl');
+    row(dl, 'Health', s.health || 'unknown');
+    row(dl, 'Requests', String(s.requests ?? 0));
+    row(dl, 'Error rate', ((s.errorRate || 0) * 100).toFixed(1) + '%');
+    row(dl, 'p95', (s.p95Ms || 0).toFixed(1) + ' ms');
+    row(dl, 'Error groups', String(s.errorGroups ?? 0));
+    card.append(dl);
+    return card;
+  }));
+}
+refresh(); setInterval(refresh, 3000);
+`;
+async function status(target) {
+  const out = { name: target.name, url: target.base, up: false };
+  try {
+    const config = await fetchPanel(
+      target,
+      "config"
+    );
+    if (!config.enabled) {
+      out.reason = config.activationReason;
+      return out;
+    }
+    const [health, requests, errors] = await Promise.all([
+      fetchPanel(target, "health").catch(() => null),
+      fetchPanel(
+        target,
+        "requests"
+      ).catch(() => null),
+      fetchPanel(target, "errors").catch(() => null)
+    ]);
+    out.up = true;
+    out.health = health?.status;
+    out.requests = requests?.total;
+    out.errorRate = requests?.summary.errorRate;
+    out.p95Ms = requests?.summary.p95Ms;
+    out.errorGroups = errors?.groups.length;
+  } catch (err) {
+    out.reason = err instanceof Error ? err.message : String(err);
+  }
+  return out;
+}
+function json(res, code, body) {
+  res.writeHead(code, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff"
+  });
+  res.end(JSON.stringify(body));
+}
+function proxy(target, rest, search, req, res) {
+  const url = new URL(`${target.base}${rest}${search}`);
+  const headers = {};
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (v === void 0 || HOP_BY_HOP.has(k)) continue;
+    if (k === "host" || k === "origin" || k === "referer" || k === "cookie") continue;
+    headers[k] = v;
+  }
+  if (target.token) headers.authorization = `Bearer ${target.token}`;
+  const client = url.protocol === "https:" ? import_node_https.default : import_node_http.default;
+  const upstream = client.request(url, { method: req.method, headers }, (up) => {
+    const out = {};
+    for (const [k, v] of Object.entries(up.headers)) {
+      if (v === void 0 || HOP_BY_HOP.has(k) || k === "set-cookie") continue;
+      out[k] = v;
+    }
+    res.writeHead(up.statusCode ?? 502, out);
+    up.pipe(res);
+  });
+  upstream.on("error", (err) => {
+    if (res.headersSent) {
+      res.destroy();
+      return;
+    }
+    json(res, 502, {
+      ok: false,
+      error: { code: "bad-gateway", message: `cannot reach ${target.name}: ${err.message}` }
+    });
+  });
+  res.on("close", () => upstream.destroy());
+  req.pipe(upstream);
+}
+async function startDashboard(options) {
+  const byName = new Map(options.services.map((s) => [s.name, s]));
+  if (byName.size !== options.services.length) throw new Error("service names must be unique");
+  const guard = (0, import_nodeui_core.createGuard)({
+    host: "127.0.0.1",
+    allowedHosts: [],
+    allowedOrigins: [],
+    allowedRemoteAddresses: [],
+    trustProxy: false
+  });
+  const assets = (0, import_nodeui_core.uiAssetsDir)();
+  const server = import_node_http.default.createServer((req, res) => {
+    const verdict = guard(req);
+    if (!verdict.ok) {
+      json(res, verdict.status, {
+        ok: false,
+        error: { code: verdict.code, message: verdict.message }
+      });
+      return;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const path = url.pathname;
+    if (path === "/" && req.method === "GET") {
+      res.writeHead(200, {
+        "content-type": "text/html; charset=utf-8",
+        "content-security-policy": "default-src 'self'; style-src 'self' 'unsafe-inline'",
+        "x-content-type-options": "nosniff"
+      });
+      res.end(PAGE);
+      return;
+    }
+    if (path === "/_dashboard.js") {
+      res.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
+      res.end(SCRIPT);
+      return;
+    }
+    if (path === "/api/services") {
+      void Promise.all(options.services.map(status)).then(
+        (data) => json(res, 200, { ok: true, data })
+      );
+      return;
+    }
+    const match = /^\/s\/([^/]+)(\/.*)?$/.exec(path);
+    let target;
+    try {
+      target = match ? byName.get(decodeURIComponent(match[1] ?? "")) : void 0;
+    } catch {
+      target = void 0;
+    }
+    if (!match || !target) {
+      json(res, 404, { ok: false, error: { code: "not-found", message: "unknown service" } });
+      return;
+    }
+    const rest = match[2];
+    if (rest === void 0) {
+      res.writeHead(308, { location: `${path}/` });
+      res.end();
+      return;
+    }
+    if (rest.startsWith("/api/")) {
+      proxy(target, rest, url.search, req, res);
+      return;
+    }
+    const asset = (0, import_nodeui_core.resolveStaticAsset)(assets, rest === "/" ? "" : rest);
+    if (!asset) {
+      json(res, 404, { ok: false, error: { code: "not-found", message: "console not built" } });
+      return;
+    }
+    res.writeHead(200, {
+      "content-type": asset.contentType,
+      "content-length": asset.length,
+      "x-content-type-options": "nosniff"
+    });
+    asset.content.pipe(res);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port ?? 4e3, "127.0.0.1", resolve);
+  });
+  return {
+    server,
+    port: server.address().port,
+    close: () => new Promise((resolve) => {
+      server.closeAllConnections?.();
+      server.close(() => resolve());
+    })
+  };
+}
+
+// src/mcp.ts
+var import_node_readline = require("readline");
+
+// package.json
+var package_default = {
+  name: "@singhak/nodeui-cli",
+  version: "0.5.0",
+  description: "NodeUI command line: attach the console to any Node app without code changes, a multi-service dashboard, and an MCP server for AI agents.",
+  license: "Apache-2.0",
+  bin: {
+    nodeui: "dist/cli.cjs"
+  },
+  main: "./dist/index.cjs",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  files: [
+    "dist"
+  ],
+  keywords: [
+    "cli",
+    "npx",
+    "developer-tools",
+    "observability",
+    "debugging",
+    "mcp",
+    "nodejs"
+  ],
+  engines: {
+    node: ">=18.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/Singhak/nodeui.git"
+  },
+  homepage: "https://github.com/Singhak/nodeui#readme",
+  bugs: {
+    url: "https://github.com/Singhak/nodeui/issues"
+  },
+  scripts: {
+    prepublishOnly: "npm run build",
+    build: "tsup",
+    typecheck: "tsc -p tsconfig.typecheck.json",
+    test: "vitest run"
+  },
+  dependencies: {
+    "@singhak/nodeui-core": "^0.5.0"
+  },
+  devDependencies: {
+    "@types/node": "^22.19.0",
+    tsup: "^8.5.0",
+    typescript: "^5.9.3",
+    vitest: "^3.2.4"
+  },
+  author: "Anil Kumar",
+  type: "commonjs"
+};
+
+// src/digest.ts
+var ms = (n) => `${n.toFixed(n < 10 ? 1 : 0)} ms`;
+var clip = (s, n) => s.length > n ? `${s.slice(0, n)}\u2026` : s;
+var oneLine = (s) => s.replace(/\s+/g, " ").trim();
+function routeOf(r) {
+  return `${r.method} ${r.route ?? r.path}`;
+}
+function buildDigest(input) {
+  const out = [`# ${input.service}`];
+  const { health, requests, errors, queries, outgoing } = input;
+  if (health) {
+    out.push(
+      `Health: **${health.status}**${health.statusReason ? ` (${oneLine(health.statusReason)})` : ""}; up ${Math.round(health.uptimeSeconds)}s; event-loop lag ${health.eventLoopLagMs ?? "?"} ms; memory ${health.memoryUsedPercent ?? "?"}%.`
+    );
+    const failing = health.checks.filter((c) => c.status === "down");
+    for (const c of failing) out.push(`- dependency check \`${c.name}\` is down`);
+  }
+  const problems = [];
+  if (errors && errors.groups.length > 0) {
+    const groups = [...errors.groups].sort((a, b) => b.lastSeenMs - a.lastSeenMs).slice(0, 5);
+    problems.push("## Errors (most recent first)");
+    for (const g of groups) {
+      problems.push(
+        `- **${g.name}: ${clip(oneLine(g.message), 160)}** x${g.count}${g.lastRoute ? ` on \`${g.lastRoute}\`` : ""}${g.lastRequestId !== void 0 ? `, request #${g.lastRequestId}` : ""} [${g.source}]; top frame: \`${clip(oneLine(g.stack.split("\n")[1] ?? ""), 140)}\``
+      );
+    }
+  }
+  if (requests) {
+    const s = requests.summary;
+    out.push(
+      `Traffic: ${s.count} recent requests, ${(s.errorRate * 100).toFixed(1)}% 5xx, p50 ${ms(s.p50Ms)}, p95 ${ms(s.p95Ms)}, p99 ${ms(s.p99Ms)}.`
+    );
+    const failed = requests.entries.filter((r) => r.status >= 500).slice(-5);
+    if (failed.length > 0) {
+      problems.push("## Failing requests");
+      for (const r of failed) {
+        problems.push(`- #${r.id} ${routeOf(r)} -> ${r.status} in ${ms(r.durationMs)}`);
+      }
+    }
+    const slow = [...s.routes].sort((a, b) => b.p95Ms - a.p95Ms).slice(0, 3);
+    if (slow.length > 0) {
+      problems.push("## Slowest routes (by p95)");
+      for (const r of slow) {
+        problems.push(
+          `- ${r.method} ${r.path}: p95 ${ms(r.p95Ms)}, avg ${ms(r.avgMs)}, ${r.count} calls, ${r.errors} errors`
+        );
+      }
+    }
+  }
+  if (queries && (queries.slow > 0 || queries.nPlusOneGroups > 0 || queries.failed > 0)) {
+    problems.push(
+      `## Database: ${queries.slow} slow (>= ${queries.slowQueryMs} ms), ${queries.nPlusOneGroups} N+1 suspects, ${queries.failed} failed`
+    );
+    const interesting = queries.entries.filter((q) => q.slow || q.nPlusOne || q.error).slice(-5);
+    for (const q of interesting) {
+      const flags = [q.slow && "slow", q.nPlusOne && `N+1 x${q.repeats ?? "?"}`, q.error && "error"].filter(Boolean).join(", ");
+      problems.push(
+        `- [${flags}] ${ms(q.durationMs)}${q.requestId !== void 0 ? `, request #${q.requestId}` : ""}: \`${clip(oneLine(q.sql), 160)}\``
+      );
+    }
+  }
+  if (outgoing && outgoing.failed > 0) {
+    problems.push(`## Outgoing calls: ${outgoing.failed} failed`);
+    for (const o of outgoing.entries.filter((e) => e.error || (e.status ?? 0) >= 500).slice(-5)) {
+      problems.push(
+        `- ${o.method} ${o.url} -> ${o.error ?? o.status}${o.requestId !== void 0 ? `, request #${o.requestId}` : ""}`
+      );
+    }
+  }
+  out.push(
+    problems.length > 0 ? problems.join("\n") : "No errors, failing requests, slow or N+1 queries, or failing outgoing calls were observed."
+  );
+  return out.join("\n\n");
+}
+
+// src/mcp.ts
+var SERVER_INFO = { name: "nodeui", version: package_default.version };
+var DEFAULT_PROTOCOL = "2025-03-26";
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 200;
+var num = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+var limitOf = (v) => Math.min(Math.max(Math.trunc(num(v, DEFAULT_LIMIT)), 1), MAX_LIMIT);
+var text = (v) => JSON.stringify(v, null, 1);
+var optional = (p) => p.catch(() => null);
+var limitProp = {
+  limit: { type: "integer", description: `Max items, newest last (default ${DEFAULT_LIMIT}).` }
+};
+var TOOLS = [
+  {
+    name: "nodeui_overview",
+    description: "START HERE. Prioritised digest of the running app: health, traffic, grouped errors with stack frames, failing and slow requests, slow/N+1 queries, failing outgoing calls.",
+    properties: {},
+    async run(_args, t) {
+      const [health, requests, errors, queries, outgoing] = await Promise.all([
+        optional(fetchPanel(t, "health")),
+        optional(fetchPanel(t, "requests")),
+        optional(fetchPanel(t, "errors")),
+        optional(fetchPanel(t, "queries")),
+        optional(fetchPanel(t, "outgoing"))
+      ]);
+      return buildDigest({ service: t.name, health, requests, errors, queries, outgoing });
+    }
+  },
+  {
+    name: "nodeui_errors",
+    description: "Errors grouped by fingerprint with count, first/last seen, full stack and the last linked request id.",
+    properties: limitProp,
+    async run(args, t) {
+      const data = await fetchPanel(t, "errors");
+      return text(data.groups.slice(0, limitOf(args.limit)));
+    }
+  },
+  {
+    name: "nodeui_requests",
+    description: "Recent HTTP requests handled by the app (method, route pattern, status, duration, query/headers when captured). Filter by minimum status or minimum duration.",
+    properties: {
+      ...limitProp,
+      minStatus: { type: "integer", description: "Only requests with status >= this (e.g. 500)." },
+      minDurationMs: { type: "number", description: "Only requests at least this slow." }
+    },
+    async run(args, t) {
+      const data = await fetchPanel(t, "requests");
+      const minStatus = num(args.minStatus, 0);
+      const minMs = num(args.minDurationMs, 0);
+      const rows = data.entries.filter((r) => r.status >= minStatus && r.durationMs >= minMs);
+      return text({ summary: data.summary, entries: rows.slice(-limitOf(args.limit)) });
+    }
+  },
+  {
+    name: "nodeui_request",
+    description: "One request in full: its details plus everything it caused (outgoing HTTP calls, database queries, log lines) joined by request id.",
+    properties: { id: { type: "integer", description: "Request id, from nodeui_requests." } },
+    async run(args, t) {
+      const id = num(args.id, NaN);
+      if (!Number.isFinite(id)) throw new PanelError("id is required", "bad-args");
+      const [requests, outgoing, queries, logs] = await Promise.all([
+        fetchPanel(t, "requests"),
+        optional(fetchPanel(t, "outgoing")),
+        optional(fetchPanel(t, "queries")),
+        optional(fetchPanel(t, "logs"))
+      ]);
+      const request = requests.entries.find((r) => r.id === id);
+      if (!request) throw new PanelError(`request #${id} is not in the recent buffer`, "not-found");
+      return text({
+        request,
+        outgoing: outgoing?.entries.filter((e) => e.requestId === id) ?? [],
+        queries: queries?.entries.filter((e) => e.requestId === id) ?? [],
+        logs: logs?.entries.filter((e) => e.requestId === id) ?? []
+      });
+    }
+  },
+  {
+    name: "nodeui_queries",
+    description: "Database statements (parameters never recorded) with duration, rows, and slow / N+1 flags.",
+    properties: {
+      ...limitProp,
+      onlyProblems: { type: "boolean", description: "Only slow, N+1 or failed queries." }
+    },
+    async run(args, t) {
+      const data = await fetchPanel(t, "queries");
+      const rows = args.onlyProblems === true ? data.entries.filter((q) => q.slow || q.nPlusOne || q.error) : data.entries;
+      return text({
+        slowQueryMs: data.slowQueryMs,
+        nPlusOneGroups: data.nPlusOneGroups,
+        entries: rows.slice(-limitOf(args.limit))
+      });
+    }
+  },
+  {
+    name: "nodeui_outgoing",
+    description: "Outgoing HTTP calls the app made (host/path, status, duration, error).",
+    properties: {
+      ...limitProp,
+      onlyFailed: { type: "boolean", description: "Only calls with an error or status >= 500." }
+    },
+    async run(args, t) {
+      const data = await fetchPanel(t, "outgoing");
+      const rows = args.onlyFailed === true ? data.entries.filter((e) => e.error || (e.status ?? 0) >= 500) : data.entries;
+      return text(rows.slice(-limitOf(args.limit)));
+    }
+  },
+  {
+    name: "nodeui_logs",
+    description: "Recent application log lines (secrets masked), optionally only warn/error.",
+    properties: {
+      ...limitProp,
+      minLevel: { type: "string", enum: ["debug", "info", "warn", "error"] }
+    },
+    async run(args, t) {
+      const order = ["debug", "info", "warn", "error"];
+      const min = order.indexOf(typeof args.minLevel === "string" ? args.minLevel : "debug");
+      const data = await fetchPanel(t, "logs");
+      const rows = data.entries.filter((l) => order.indexOf(l.level) >= Math.max(min, 0));
+      return text(rows.slice(-limitOf(args.limit)));
+    }
+  },
+  {
+    name: "nodeui_routes",
+    description: "The registered route table (method, path, handler).",
+    properties: {},
+    async run(_args, t) {
+      return text((await fetchPanel(t, "routes")).routes);
+    }
+  }
+];
+function toolDefinitions(multi) {
+  return TOOLS.map((t) => ({
+    name: t.name,
+    description: t.description + " Read-only.",
+    inputSchema: {
+      type: "object",
+      properties: multi ? { service: { type: "string", description: "Service name." }, ...t.properties } : t.properties,
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: true, openWorldHint: false }
+  }));
+}
+function serveMcp(options) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const services = options.services;
+  const multi = services.length > 1;
+  const send = (msg) => {
+    output.write(`${JSON.stringify(msg)}
+`);
+  };
+  const reply = (id, result) => send({ jsonrpc: "2.0", id, result });
+  const fail = (id, code, message) => send({ jsonrpc: "2.0", id, error: { code, message } });
+  async function call(params) {
+    const tool = TOOLS.find((t) => t.name === params?.name);
+    if (!tool) return { isError: true, content: [{ type: "text", text: "unknown tool" }] };
+    const args = params?.arguments ?? {};
+    const wanted = typeof args.service === "string" ? args.service : void 0;
+    const target = wanted ? services.find((s) => s.name === wanted) : multi ? void 0 : services[0];
+    try {
+      if (!target) {
+        throw new PanelError(
+          `specify "service": one of ${services.map((s) => s.name).join(", ")}`,
+          "bad-args"
+        );
+      }
+      return { content: [{ type: "text", text: await tool.run(args, target) }] };
+    } catch (err) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }]
+      };
+    }
+  }
+  async function handle(req) {
+    const isNotification = req.id === void 0;
+    switch (req.method) {
+      case "initialize":
+        reply(req.id, {
+          protocolVersion: typeof req.params?.protocolVersion === "string" ? req.params.protocolVersion : DEFAULT_PROTOCOL,
+          capabilities: { tools: {} },
+          serverInfo: SERVER_INFO,
+          instructions: "Read-only view of a running Node app. Call nodeui_overview first, then drill into errors, requests, queries."
+        });
+        for (const s of services) {
+          void Promise.all([
+            optional(fetchPanel(s, "outgoing")),
+            optional(fetchPanel(s, "queries"))
+          ]);
+        }
+        return;
+      case "ping":
+        reply(req.id, {});
+        return;
+      case "tools/list":
+        reply(req.id, { tools: toolDefinitions(multi) });
+        return;
+      case "tools/call":
+        reply(req.id, await call(req.params));
+        return;
+      default:
+        if (!isNotification) fail(req.id, -32601, `method not found: ${req.method}`);
+    }
+  }
+  const rl = (0, import_node_readline.createInterface)({ input });
+  const pending = /* @__PURE__ */ new Set();
+  rl.on("line", (line) => {
+    if (!line.trim()) return;
+    let req;
+    try {
+      req = JSON.parse(line);
+    } catch {
+      fail(null, -32700, "parse error");
+      return;
+    }
+    const p = handle(req).catch((err) => {
+      if (req.id !== void 0)
+        fail(req.id, -32603, err instanceof Error ? err.message : "error");
+    }).finally(() => pending.delete(p));
+    pending.add(p);
+  });
+  const done = new Promise((resolve) => {
+    rl.on("close", () => {
+      void Promise.all(pending).then(() => resolve());
+    });
+  });
+  return { done };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PanelError,
+  attach,
+  attachEnv,
+  buildDigest,
+  fetchPanel,
+  parseTarget,
+  preloadPath,
+  serveMcp,
+  startDashboard
+});
+//# sourceMappingURL=index.cjs.map