autotel-devtools 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,889 @@
+#!/usr/bin/env node
+'use strict';
+
+var http = require('http');
+var fs = require('fs');
+var path = require('path');
+var url = require('url');
+var ws = require('ws');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/server/error-aggregator.ts
+var ErrorAggregator = class {
+  errorGroups = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = {
+      maxGroups: options.maxGroups ?? 100,
+      maxAffectedTraces: options.maxAffectedTraces ?? 10,
+      maxAffectedSpans: options.maxAffectedSpans ?? 5,
+      stackFramesForFingerprint: options.stackFramesForFingerprint ?? 5
+    };
+  }
+  /**
+   * Add an error occurrence to the aggregator
+   */
+  addError(occurrence) {
+    const fingerprint = this.generateFingerprint(occurrence);
+    const existing = this.errorGroups.get(fingerprint);
+    if (existing) {
+      existing.count++;
+      existing.lastSeen = occurrence.timestamp;
+      if (!existing.affectedTraces.includes(occurrence.traceId)) {
+        existing.affectedTraces.push(occurrence.traceId);
+        if (existing.affectedTraces.length > this.options.maxAffectedTraces) {
+          existing.affectedTraces.shift();
+        }
+      }
+      if (!existing.affectedSpans.includes(occurrence.spanName)) {
+        existing.affectedSpans.push(occurrence.spanName);
+        if (existing.affectedSpans.length > this.options.maxAffectedSpans) {
+          existing.affectedSpans.shift();
+        }
+      }
+      return existing;
+    }
+    const newGroup = {
+      fingerprint,
+      type: occurrence.error.type,
+      message: occurrence.error.message,
+      stackTrace: this.normalizeStackTrace(occurrence.error.stackTrace),
+      count: 1,
+      firstSeen: occurrence.timestamp,
+      lastSeen: occurrence.timestamp,
+      affectedTraces: [occurrence.traceId],
+      affectedSpans: [occurrence.spanName],
+      service: occurrence.service,
+      attributes: occurrence.attributes
+    };
+    if (this.errorGroups.size >= this.options.maxGroups) {
+      this.evictOldestGroup();
+    }
+    this.errorGroups.set(fingerprint, newGroup);
+    return newGroup;
+  }
+  /**
+   * Extract errors from a trace and add them to the aggregator
+   */
+  addErrorsFromTrace(trace) {
+    const addedGroups = [];
+    for (const span of trace.spans) {
+      if (span.status.code === "ERROR") {
+        const occurrence = this.extractErrorFromSpan(span, trace);
+        if (occurrence) {
+          const group = this.addError(occurrence);
+          addedGroups.push(group);
+        }
+      }
+    }
+    return addedGroups;
+  }
+  /**
+   * Extract error occurrence from a span
+   */
+  extractErrorFromSpan(span, trace) {
+    const exceptionEvent = span.events?.find((e) => e.name === "exception");
+    const errorType = span.attributes["exception.type"] || span.attributes["error.type"] || exceptionEvent?.attributes?.["exception.type"] || "Error";
+    const errorMessage = span.status.message || span.attributes["exception.message"] || span.attributes["error.message"] || "Unknown error";
+    const stackTrace = span.attributes["exception.stacktrace"] || span.attributes["exception.stack"] || this.extractStackFromEvents(span);
+    return {
+      traceId: trace.traceId,
+      spanId: span.spanId,
+      spanName: span.name,
+      service: trace.service,
+      timestamp: span.endTime,
+      error: {
+        type: errorType,
+        message: errorMessage,
+        stackTrace
+      },
+      attributes: this.extractRelevantAttributes(span.attributes)
+    };
+  }
+  /**
+   * Extract stack trace from span events (exception events)
+   */
+  extractStackFromEvents(span) {
+    if (!span.events) return void 0;
+    const exceptionEvent = span.events.find((e) => e.name === "exception");
+    if (exceptionEvent?.attributes) {
+      return exceptionEvent.attributes["exception.stacktrace"] || exceptionEvent.attributes["exception.stack"];
+    }
+    return void 0;
+  }
+  /**
+   * Extract relevant attributes for error context
+   */
+  extractRelevantAttributes(attributes) {
+    const relevant = {};
+    const keepKeys = [
+      "http.method",
+      "http.url",
+      "http.route",
+      "http.status_code",
+      "db.system",
+      "db.operation",
+      "rpc.method",
+      "rpc.service",
+      "code.function",
+      "code.filepath",
+      "user.id",
+      "operation.name"
+    ];
+    for (const key of keepKeys) {
+      if (key in attributes) {
+        relevant[key] = attributes[key];
+      }
+    }
+    return relevant;
+  }
+  /**
+   * Generate a fingerprint for error grouping
+   *
+   * Uses error type + first N stack frames (normalized)
+   */
+  generateFingerprint(occurrence) {
+    const parts = [occurrence.error.type];
+    if (occurrence.error.stackTrace) {
+      const frames = this.extractStackFrames(
+        occurrence.error.stackTrace,
+        this.options.stackFramesForFingerprint
+      );
+      parts.push(...frames);
+    } else {
+      parts.push(this.normalizeMessage(occurrence.error.message));
+    }
+    return this.simpleHash(parts.join("|"));
+  }
+  /**
+   * Extract and normalize stack frames from a stack trace
+   */
+  extractStackFrames(stackTrace, count) {
+    const lines = stackTrace.split("\n");
+    const frames = [];
+    for (const line of lines) {
+      if (frames.length >= count) break;
+      const trimmed = line.trim();
+      const nodeMatch = trimmed.match(/^at\s+(.+?)\s+\((.+?):(\d+):\d+\)$/);
+      if (nodeMatch) {
+        frames.push(`${nodeMatch[1]}@${this.normalizeFilePath(nodeMatch[2])}`);
+        continue;
+      }
+      const anonMatch = trimmed.match(/^at\s+(.+?):(\d+):\d+$/);
+      if (anonMatch) {
+        frames.push(`anonymous@${this.normalizeFilePath(anonMatch[1])}`);
+        continue;
+      }
+      const browserMatch = trimmed.match(/^(.+?)@(.+?):(\d+):\d+$/);
+      if (browserMatch) {
+        frames.push(
+          `${browserMatch[1]}@${this.normalizeFilePath(browserMatch[2])}`
+        );
+        continue;
+      }
+    }
+    return frames;
+  }
+  /**
+   * Normalize file path by removing absolute path prefixes and node_modules paths
+   */
+  normalizeFilePath(filePath) {
+    const nodeModulesMatch = filePath.match(
+      /node_modules\/(@[^/]+\/[^/]+|[^/]+)/
+    );
+    if (nodeModulesMatch) {
+      return `[npm]/${nodeModulesMatch[1]}`;
+    }
+    return filePath.replace(/^.*?\/src\//, "src/").replace(/^.*?\/dist\//, "dist/").replace(/^.*?\/lib\//, "lib/").replace(/^file:\/\//, "");
+  }
+  /**
+   * Normalize error message by removing dynamic parts
+   */
+  normalizeMessage(message) {
+    return message.replaceAll(
+      /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi,
+      "[UUID]"
+    ).replaceAll(/\b[0-9a-f]{16,}\b/gi, "[ID]").replaceAll(/\b\d+\b/g, "[N]").replaceAll(/"[^"]*"/g, '"[STR]"').replaceAll(/'[^']*'/g, "'[STR]'").slice(0, 200);
+  }
+  /**
+   * Normalize stack trace for display
+   */
+  normalizeStackTrace(stackTrace) {
+    if (!stackTrace) return void 0;
+    const lines = stackTrace.split("\n").slice(0, 10);
+    return lines.join("\n");
+  }
+  /**
+   * Simple hash function for fingerprinting
+   */
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16).padStart(8, "0");
+  }
+  /**
+   * Evict the oldest error group
+   */
+  evictOldestGroup() {
+    let oldest = null;
+    for (const [fingerprint, group] of this.errorGroups) {
+      if (!oldest || group.lastSeen < oldest.lastSeen) {
+        oldest = { fingerprint, lastSeen: group.lastSeen };
+      }
+    }
+    if (oldest) {
+      this.errorGroups.delete(oldest.fingerprint);
+    }
+  }
+  /**
+   * Get all error groups, sorted by most recent
+   */
+  getErrorGroups() {
+    return [...this.errorGroups.values()].sort(
+      (a, b) => b.lastSeen - a.lastSeen
+    );
+  }
+  /**
+   * Get error groups sorted by count (most frequent first)
+   */
+  getErrorGroupsByFrequency() {
+    return [...this.errorGroups.values()].sort(
+      (a, b) => b.count - a.count
+    );
+  }
+  /**
+   * Get a specific error group by fingerprint
+   */
+  getErrorGroup(fingerprint) {
+    return this.errorGroups.get(fingerprint);
+  }
+  /**
+   * Get error groups for a specific service
+   */
+  getErrorGroupsByService(service) {
+    return this.getErrorGroups().filter((g) => g.service === service);
+  }
+  /**
+   * Get total error count across all groups
+   */
+  getTotalErrorCount() {
+    let total = 0;
+    for (const group of this.errorGroups.values()) {
+      total += group.count;
+    }
+    return total;
+  }
+  /**
+   * Get error statistics
+   */
+  getStats() {
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1e3;
+    let recentErrors = 0;
+    const typeCount = /* @__PURE__ */ new Map();
+    for (const group of this.errorGroups.values()) {
+      if (group.lastSeen > oneHourAgo) {
+        recentErrors += group.count;
+      }
+      typeCount.set(group.type, (typeCount.get(group.type) || 0) + group.count);
+    }
+    const topErrorTypes = [...typeCount.entries()].map(([type, count]) => ({ type, count })).sort((a, b) => b.count - a.count).slice(0, 5);
+    return {
+      totalGroups: this.errorGroups.size,
+      totalErrors: this.getTotalErrorCount(),
+      recentErrors,
+      topErrorTypes
+    };
+  }
+  /**
+   * Clear all error groups
+   */
+  clear() {
+    this.errorGroups.clear();
+  }
+  /**
+   * Clear old error groups (not seen in given time window)
+   */
+  clearOlderThan(maxAgeMs) {
+    const cutoff = Date.now() - maxAgeMs;
+    let cleared = 0;
+    for (const [fingerprint, group] of this.errorGroups) {
+      if (group.lastSeen < cutoff) {
+        this.errorGroups.delete(fingerprint);
+        cleared++;
+      }
+    }
+    return cleared;
+  }
+};
+
+// src/server/telemetry-limits.ts
+var defaultLimit = 100;
+function parseLimit(value) {
+  if (!value) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function resolveTelemetryLimits(args = {}) {
+  const env = args.env ?? process.env;
+  const fallback = args.maxHistory ?? defaultLimit;
+  return {
+    maxTraceCount: args.maxTraceCount ?? parseLimit(env.AUTOTEL_MAX_TRACE_COUNT) ?? fallback,
+    maxLogCount: args.maxLogCount ?? parseLimit(env.AUTOTEL_MAX_LOG_COUNT) ?? fallback,
+    maxMetricCount: args.maxMetricCount ?? parseLimit(env.AUTOTEL_MAX_METRIC_COUNT) ?? fallback
+  };
+}
+function appendWithLimit(items, item, limit) {
+  if (limit <= 0) return [];
+  const next = [...items, item];
+  return next.length > limit ? next.slice(next.length - limit) : next;
+}
+function appendManyWithLimit(items, incoming, limit) {
+  if (limit <= 0 || incoming.length === 0) return limit <= 0 ? [] : items;
+  const next = [...items, ...incoming];
+  return next.length > limit ? next.slice(next.length - limit) : next;
+}
+
+// src/server/server.ts
+var DevtoolsServer = class {
+  wss;
+  clients = /* @__PURE__ */ new Set();
+  httpServer;
+  traces = [];
+  logs = [];
+  metrics = [];
+  errorAggregator = new ErrorAggregator();
+  limits;
+  verbose;
+  _port;
+  constructor(options = {}) {
+    this.limits = resolveTelemetryLimits(options);
+    this.verbose = options.verbose ?? false;
+    this._port = options.port ?? 4318;
+    this.httpServer = options.server ?? http.createServer();
+    this.wss = new ws.WebSocketServer({ server: this.httpServer, path: options.path ?? "/ws" });
+    this.wss.on("connection", (ws) => {
+      this.clients.add(ws);
+      this.log(`Client connected (${this.clients.size} total)`);
+      const data = this.getCurrentData();
+      if (data.traces.length > 0 || data.logs.length > 0 || data.errors.length > 0) {
+        ws.send(JSON.stringify(data));
+      }
+      ws.on("close", () => {
+        this.clients.delete(ws);
+        this.log(`Client disconnected (${this.clients.size} total)`);
+      });
+    });
+    if (!options.server) {
+      this.httpServer.listen(this._port, () => {
+        const addr = this.httpServer.address();
+        if (addr && typeof addr === "object") this._port = addr.port;
+        this.log(`WebSocket server listening on port ${this._port}`);
+      });
+    }
+  }
+  get port() {
+    const addr = this.httpServer.address();
+    if (addr && typeof addr === "object") return addr.port;
+    return this._port;
+  }
+  get clientCount() {
+    return this.clients.size;
+  }
+  addTrace(trace) {
+    const existing = this.traces.find((t) => t.traceId === trace.traceId);
+    if (existing) {
+      const existingSpanIds = new Set(existing.spans.map((s) => s.spanId));
+      for (const span of trace.spans) {
+        if (!existingSpanIds.has(span.spanId)) {
+          existing.spans.push(span);
+        }
+      }
+      existing.startTime = Math.min(existing.startTime, trace.startTime);
+      existing.endTime = Math.max(existing.endTime, trace.endTime);
+      existing.duration = existing.endTime - existing.startTime;
+      if (trace.status === "ERROR") existing.status = "ERROR";
+    } else {
+      this.traces = appendWithLimit(
+        this.traces,
+        trace,
+        this.limits.maxTraceCount
+      );
+    }
+    this.errorAggregator.addErrorsFromTrace(trace);
+    this.broadcast({ traces: [trace], metrics: [], logs: [], errors: this.errorAggregator.getErrorGroups() });
+  }
+  addTraces(traces) {
+    for (const trace of traces) this.addTrace(trace);
+  }
+  addLog(log) {
+    this.logs = appendWithLimit(this.logs, log, this.limits.maxLogCount);
+    this.broadcast({ traces: [], metrics: [], logs: [log], errors: [] });
+  }
+  addLogs(logs) {
+    this.logs = appendManyWithLimit(this.logs, logs, this.limits.maxLogCount);
+    this.broadcast({ traces: [], metrics: [], logs, errors: [] });
+  }
+  addMetric(metric) {
+    this.metrics = appendWithLimit(
+      this.metrics,
+      metric,
+      this.limits.maxMetricCount
+    );
+    this.broadcast({ traces: [], metrics: [metric], logs: [], errors: [] });
+  }
+  getCurrentData() {
+    return {
+      traces: this.traces,
+      metrics: this.metrics,
+      logs: this.logs,
+      errors: this.errorAggregator.getErrorGroups()
+    };
+  }
+  clearData() {
+    this.traces = [];
+    this.logs = [];
+    this.metrics = [];
+    this.errorAggregator.clear();
+  }
+  broadcast(data) {
+    const msg = JSON.stringify(data);
+    for (const client of this.clients) {
+      if (client.readyState === ws.WebSocket.OPEN) {
+        client.send(msg);
+      }
+    }
+  }
+  log(message) {
+    if (this.verbose) console.log(`[autotel-devtools] ${message}`);
+  }
+  async close() {
+    for (const client of this.clients) client.close();
+    this.clients.clear();
+    this.wss.close();
+    await new Promise((resolve3) => this.httpServer.close(() => resolve3()));
+  }
+};
+
+// src/server/resource-utils.ts
+function getResourceName(resource, fallback = "unknown") {
+  if (!resource) return fallback;
+  const candidates = [
+    resource["service.name"],
+    resource["service.namespace"],
+    resource["deployment.environment.name"],
+    resource["host.name"],
+    resource["container.name"],
+    resource["process.executable.name"]
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+  return fallback;
+}
+
+// src/server/otlp.ts
+function resolveOtlpValue(v) {
+  if (!v) return void 0;
+  if (v.stringValue !== void 0) return v.stringValue;
+  if (v.boolValue !== void 0) return v.boolValue;
+  if (v.intValue !== void 0) return typeof v.intValue === "string" ? Number(v.intValue) : v.intValue;
+  if (v.doubleValue !== void 0) return v.doubleValue;
+  if (v.bytesValue !== void 0) return v.bytesValue;
+  if (v.arrayValue?.values) return v.arrayValue.values.map(resolveOtlpValue);
+  if (v.kvlistValue?.values) return flattenAttributes(v.kvlistValue.values);
+  return void 0;
+}
+function flattenAttributes(attrs) {
+  const out = {};
+  if (!attrs) return out;
+  for (const { key, value } of attrs) {
+    out[key] = resolveOtlpValue(value);
+  }
+  return out;
+}
+function nanoToMs(nano) {
+  if (!nano) return 0;
+  return Number(BigInt(nano) / 1000000n);
+}
+var SPAN_KIND_MAP = {
+  0: "INTERNAL",
+  1: "INTERNAL",
+  2: "SERVER",
+  3: "CLIENT",
+  4: "PRODUCER",
+  5: "CONSUMER",
+  SPAN_KIND_INTERNAL: "INTERNAL",
+  SPAN_KIND_SERVER: "SERVER",
+  SPAN_KIND_CLIENT: "CLIENT",
+  SPAN_KIND_PRODUCER: "PRODUCER",
+  SPAN_KIND_CONSUMER: "CONSUMER"
+};
+function normalizeHexId(id) {
+  if (!id) return "";
+  const isBase64Like = /^[A-Za-z0-9+/=]+$/.test(id) && !/^[0-9a-f]+$/i.test(id);
+  const isLikelyBase64Id = isBase64Like && (id.length === 24 || id.length === 28 || id.length === 44 || id.length === 48);
+  if (isLikelyBase64Id) {
+    try {
+      const bytes = Buffer.from(id, "base64");
+      return bytes.toString("hex");
+    } catch {
+    }
+  }
+  return id;
+}
+function parseOtlpTraces(payload) {
+  if (!payload || typeof payload !== "object") return [];
+  const { resourceSpans } = payload;
+  if (!Array.isArray(resourceSpans) || resourceSpans.length === 0) return [];
+  const traceMap = /* @__PURE__ */ new Map();
+  for (const rs of resourceSpans) {
+    const resourceAttrs = flattenAttributes(rs.resource?.attributes);
+    const service = String(resourceAttrs["service.name"] || "unknown");
+    const scopeSpans = rs.scopeSpans || [];
+    for (const ss of scopeSpans) {
+      for (const span of ss.spans || []) {
+        const traceId = normalizeHexId(span.traceId);
+        if (!traceId) continue;
+        const startMs = nanoToMs(span.startTimeUnixNano);
+        const endMs = nanoToMs(span.endTimeUnixNano);
+        const statusCode = span.status?.code;
+        let status = "UNSET";
+        if (statusCode === 1 || statusCode === "STATUS_CODE_OK") status = "OK";
+        if (statusCode === 2 || statusCode === "STATUS_CODE_ERROR") status = "ERROR";
+        const spanData = {
+          traceId,
+          spanId: normalizeHexId(span.spanId),
+          parentSpanId: normalizeHexId(span.parentSpanId) || void 0,
+          name: span.name || "unknown",
+          kind: SPAN_KIND_MAP[span.kind ?? 0] || "INTERNAL",
+          startTime: startMs,
+          endTime: endMs,
+          duration: endMs - startMs,
+          attributes: { ...resourceAttrs, ...flattenAttributes(span.attributes) },
+          status: { code: status, message: span.status?.message },
+          events: (span.events || []).map((e) => ({
+            name: e.name || "",
+            timestamp: nanoToMs(e.timeUnixNano),
+            attributes: flattenAttributes(e.attributes)
+          }))
+        };
+        const existing = traceMap.get(traceId);
+        if (existing) {
+          existing.spans.push(spanData);
+        } else {
+          traceMap.set(traceId, { spans: [spanData], service });
+        }
+      }
+    }
+  }
+  const traces = [];
+  for (const [traceId, { spans, service }] of traceMap) {
+    const sorted = spans.sort((a, b) => a.startTime - b.startTime);
+    const rootSpan = sorted.find((s) => !s.parentSpanId) || sorted[0];
+    const startTime = Math.min(...sorted.map((s) => s.startTime));
+    const endTime = Math.max(...sorted.map((s) => s.endTime));
+    const hasError = sorted.some((s) => s.status.code === "ERROR");
+    traces.push({
+      traceId,
+      correlationId: traceId.slice(0, 16),
+      rootSpan,
+      spans: sorted,
+      startTime,
+      endTime,
+      duration: endTime - startTime,
+      status: hasError ? "ERROR" : "OK",
+      service
+    });
+  }
+  return traces;
+}
+function parseOtlpLogs(payload) {
+  if (!payload || typeof payload !== "object") return [];
+  const { resourceLogs } = payload;
+  if (!Array.isArray(resourceLogs)) return [];
+  const logs = [];
+  for (const rl of resourceLogs) {
+    const resourceAttrs = flattenAttributes(rl.resource?.attributes);
+    for (const sl of rl.scopeLogs || []) {
+      for (const rec of sl.logRecords || []) {
+        const timestamp = nanoToMs(rec.timeUnixNano || rec.observedTimeUnixNano);
+        const traceId = normalizeHexId(rec.traceId) || void 0;
+        const spanId = normalizeHexId(rec.spanId) || void 0;
+        const body = rec.body ? resolveOtlpValue(rec.body) : "";
+        logs.push({
+          id: `${traceId || "no-trace"}:${spanId || "no-span"}:${timestamp}:${rec.severityNumber || 0}`,
+          traceId,
+          spanId,
+          resourceName: getResourceName(resourceAttrs),
+          severityText: rec.severityText,
+          severityNumber: rec.severityNumber,
+          body: typeof body === "string" ? body : body,
+          timestamp,
+          attributes: flattenAttributes(rec.attributes),
+          resource: resourceAttrs
+        });
+      }
+    }
+  }
+  return logs;
+}
+function countOtlpMetrics(payload) {
+  if (!payload || typeof payload !== "object") return 0;
+  const { resourceMetrics } = payload;
+  if (!Array.isArray(resourceMetrics)) return 0;
+  let count = 0;
+  for (const rm of resourceMetrics) {
+    for (const sm of rm.scopeMetrics || []) {
+      count += (sm.metrics || []).length;
+    }
+  }
+  return count;
+}
+async function readJsonBody(req) {
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      try {
+        resolve3(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function sendJson(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) });
+  res.end(body);
+}
+
+// src/server/http.ts
+function findPackageRoot() {
+  let dir = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href))));
+  for (let i = 0; i < 5; i++) {
+    if (fs.existsSync(path.resolve(dir, "package.json"))) return dir;
+    dir = path.dirname(dir);
+  }
+  return dir;
+}
+var FULLPAGE_HTML = `<!DOCTYPE html><html><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>autotel-devtools</title><style>*{margin:0;padding:0;box-sizing:border-box}html,body{height:100%;width:100%;overflow:hidden}</style></head><body><script src="/widget.js?mode=fullpage"></script></body></html>`;
+var cachedWidgetJs = null;
+function getWidgetJs() {
+  if (!cachedWidgetJs) {
+    const pkgRoot = findPackageRoot();
+    const candidates = [
+      path.resolve(pkgRoot, "dist", "widget.global.js"),
+      path.resolve(pkgRoot, "widget.global.js")
+    ];
+    for (const candidate of candidates) {
+      try {
+        cachedWidgetJs = fs.readFileSync(candidate, "utf8");
+        break;
+      } catch {
+      }
+    }
+    if (!cachedWidgetJs) {
+      cachedWidgetJs = "// widget bundle not found - run pnpm build first";
+    }
+  }
+  return cachedWidgetJs;
+}
+function attachDevtoolsRoutes(httpServer, devtools) {
+  httpServer.on("request", async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = req.url || "/";
+    if (req.method === "GET" && url === "/") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Content-Length": Buffer.byteLength(FULLPAGE_HTML) });
+      res.end(FULLPAGE_HTML);
+      return;
+    }
+    if (req.method === "GET" && url.startsWith("/widget.js")) {
+      const js = getWidgetJs();
+      res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8", "Content-Length": Buffer.byteLength(js) });
+      res.end(js);
+      return;
+    }
+    if (req.method === "GET" && url === "/healthz") {
+      sendJson(res, 200, { ok: true, clients: devtools.clientCount });
+      return;
+    }
+    if (req.method === "POST" && url === "/v1/traces") {
+      try {
+        const payload = await readJsonBody(req);
+        const traces = parseOtlpTraces(payload);
+        devtools.addTraces(traces);
+        sendJson(res, 200, { acceptedTraces: traces.length });
+      } catch (e) {
+        sendJson(res, 400, { error: "Invalid OTLP JSON", message: e instanceof Error ? e.message : String(e) });
+      }
+      return;
+    }
+    if (req.method === "POST" && url === "/v1/logs") {
+      try {
+        const payload = await readJsonBody(req);
+        const logs = parseOtlpLogs(payload);
+        devtools.addLogs(logs);
+        sendJson(res, 200, { acceptedLogs: logs.length });
+      } catch (e) {
+        sendJson(res, 400, { error: "Invalid OTLP JSON", message: e instanceof Error ? e.message : String(e) });
+      }
+      return;
+    }
+    if (req.method === "POST" && url === "/v1/metrics") {
+      try {
+        const payload = await readJsonBody(req);
+        const count = countOtlpMetrics(payload);
+        sendJson(res, 200, { acceptedMetrics: count });
+      } catch (e) {
+        sendJson(res, 400, { error: "Invalid OTLP JSON", message: e instanceof Error ? e.message : String(e) });
+      }
+      return;
+    }
+    sendJson(res, 404, { error: "Not found" });
+  });
+}
+
+// src/cli.ts
+function printHelp() {
+  process.stdout.write(
+    `autotel-devtools - Standalone OTLP receiver with web devtools UI
+
+Usage: autotel-devtools [options]
+
+Options:
+  -p, --port <port>    Port to listen on (default: 4318, env: AUTOTEL_DEVTOOLS_PORT)
+  -H, --host <host>    Host to bind to (default: 127.0.0.1, env: AUTOTEL_DEVTOOLS_HOST)
+  -t, --title <title>  Dashboard title (env: AUTOTEL_DEVTOOLS_TITLE)
+  Env limits:          AUTOTEL_MAX_TRACE_COUNT, AUTOTEL_MAX_LOG_COUNT, AUTOTEL_MAX_METRIC_COUNT
+  -h, --help           Show this help message
+  -v, --version        Show version number
+
+Endpoints:
+  GET  /               Web devtools UI (fullpage)
+  GET  /widget.js      Widget bundle (embed in your app)
+  POST /v1/traces      Receive OTLP JSON trace data
+  POST /v1/logs        Receive OTLP JSON log data
+  POST /v1/metrics     Receive OTLP JSON metric data
+  WS   /ws             WebSocket stream for real-time updates
+  GET  /healthz        Health check
+
+Examples:
+  npx autotel-devtools
+  npx autotel-devtools -p 4319
+
+Then point your app:
+  OTEL_EXPORTER_OTLP_PROTOCOL=http/json OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318 node app.js
+
+View in browser:
+  http://localhost:4318
+
+Or embed widget in your app:
+  <script src="http://localhost:4318/widget.js"></script>
+
+`
+  );
+}
+function printVersion() {
+  try {
+    const dir = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href))));
+    const pkgPath = path.resolve(dir, "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    process.stdout.write(`${pkg.version}
+`);
+  } catch {
+    process.stdout.write("unknown\n");
+  }
+}
+function parseArgs(argv) {
+  const options = {
+    port: Number(process.env.AUTOTEL_DEVTOOLS_PORT || 4318),
+    host: process.env.AUTOTEL_DEVTOOLS_HOST || "127.0.0.1",
+    title: process.env.AUTOTEL_DEVTOOLS_TITLE
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    if (arg === "--help" || arg === "-h") {
+      printHelp();
+      return null;
+    }
+    if (arg === "--version" || arg === "-v") {
+      printVersion();
+      return null;
+    }
+    if ((arg === "--port" || arg === "-p") && next) {
+      options.port = Number(next);
+      i++;
+      continue;
+    }
+    if ((arg === "--host" || arg === "-H") && next) {
+      options.host = next;
+      i++;
+      continue;
+    }
+    if ((arg === "--title" || arg === "-t") && next) {
+      options.title = next;
+      i++;
+      continue;
+    }
+  }
+  return options;
+}
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (!options) {
+    process.exit(0);
+  }
+  const httpServer = http.createServer();
+  const wsServer = new DevtoolsServer({ server: httpServer, verbose: true });
+  attachDevtoolsRoutes(httpServer, wsServer);
+  httpServer.listen(options.port, options.host, () => {
+    const title = options.title || "autotel-devtools";
+    process.stdout.write(`
+  ${title}
+
+`);
+    process.stdout.write(`  UI:        http://${options.host}:${options.port}
+`);
+    process.stdout.write(`  Widget:    <script src="http://${options.host}:${options.port}/widget.js"></script>
+`);
+    process.stdout.write(`  WebSocket: ws://${options.host}:${options.port}/ws
+`);
+    process.stdout.write(`  OTLP:      http://${options.host}:${options.port}/v1/traces
+
+`);
+    process.stdout.write(`  Set OTEL_EXPORTER_OTLP_PROTOCOL=http/json
+`);
+    process.stdout.write(`  Set OTEL_EXPORTER_OTLP_ENDPOINT=http://${options.host}:${options.port}
+
+`);
+  });
+  const shutdown = () => {
+    wsServer.close().then(() => process.exit(0));
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  process.stderr.write(`[autotel-devtools] failed to start: ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map