@tracebird/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1484 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "util";
+import { resolve as resolve2 } from "path";
+
+// src/commands/live.ts
+import { join as join5 } from "path";
+import { buildRun } from "@tracebird/core";
+
+// src/server.ts
+import {
+  createServer as createHttpServer
+} from "http";
+import { parseOtlp } from "@tracebird/core";
+
+// src/otlp/protobuf.ts
+import protobuf from "protobufjs";
+var common = {
+  AnyValue: {
+    oneofs: {
+      value: {
+        oneof: [
+          "stringValue",
+          "boolValue",
+          "intValue",
+          "doubleValue",
+          "arrayValue",
+          "kvlistValue",
+          "bytesValue"
+        ]
+      }
+    },
+    fields: {
+      stringValue: { type: "string", id: 1 },
+      boolValue: { type: "bool", id: 2 },
+      intValue: { type: "int64", id: 3 },
+      doubleValue: { type: "double", id: 4 },
+      arrayValue: { type: "ArrayValue", id: 5 },
+      kvlistValue: { type: "KeyValueList", id: 6 },
+      bytesValue: { type: "bytes", id: 7 }
+    }
+  },
+  ArrayValue: { fields: { values: { rule: "repeated", type: "AnyValue", id: 1 } } },
+  KeyValueList: { fields: { values: { rule: "repeated", type: "KeyValue", id: 1 } } },
+  KeyValue: {
+    fields: { key: { type: "string", id: 1 }, value: { type: "AnyValue", id: 2 } }
+  },
+  InstrumentationScope: {
+    fields: {
+      name: { type: "string", id: 1 },
+      version: { type: "string", id: 2 },
+      attributes: { rule: "repeated", type: "KeyValue", id: 3 }
+    }
+  }
+};
+var KV = "opentelemetry.proto.common.v1.KeyValue";
+var descriptor = {
+  nested: {
+    opentelemetry: {
+      nested: {
+        proto: {
+          nested: {
+            common: { nested: { v1: { nested: common } } },
+            resource: {
+              nested: {
+                v1: {
+                  nested: {
+                    Resource: {
+                      fields: { attributes: { rule: "repeated", type: KV, id: 1 } }
+                    }
+                  }
+                }
+              }
+            },
+            trace: {
+              nested: {
+                v1: {
+                  nested: {
+                    ResourceSpans: {
+                      fields: {
+                        resource: { type: "opentelemetry.proto.resource.v1.Resource", id: 1 },
+                        scopeSpans: { rule: "repeated", type: "ScopeSpans", id: 2 },
+                        schemaUrl: { type: "string", id: 3 }
+                      }
+                    },
+                    ScopeSpans: {
+                      fields: {
+                        scope: {
+                          type: "opentelemetry.proto.common.v1.InstrumentationScope",
+                          id: 1
+                        },
+                        spans: { rule: "repeated", type: "Span", id: 2 },
+                        schemaUrl: { type: "string", id: 3 }
+                      }
+                    },
+                    Span: {
+                      fields: {
+                        traceId: { type: "bytes", id: 1 },
+                        spanId: { type: "bytes", id: 2 },
+                        traceState: { type: "string", id: 3 },
+                        parentSpanId: { type: "bytes", id: 4 },
+                        name: { type: "string", id: 5 },
+                        kind: { type: "int32", id: 6 },
+                        startTimeUnixNano: { type: "fixed64", id: 7 },
+                        endTimeUnixNano: { type: "fixed64", id: 8 },
+                        attributes: { rule: "repeated", type: KV, id: 9 },
+                        events: { rule: "repeated", type: "Event", id: 11 },
+                        status: { type: "Status", id: 15 }
+                      },
+                      nested: {
+                        Event: {
+                          fields: {
+                            timeUnixNano: { type: "fixed64", id: 1 },
+                            name: { type: "string", id: 2 },
+                            attributes: { rule: "repeated", type: KV, id: 3 }
+                          }
+                        }
+                      }
+                    },
+                    Status: {
+                      fields: {
+                        message: { type: "string", id: 2 },
+                        code: { type: "int32", id: 3 }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            collector: {
+              nested: {
+                trace: {
+                  nested: {
+                    v1: {
+                      nested: {
+                        ExportTraceServiceRequest: {
+                          fields: {
+                            resourceSpans: {
+                              rule: "repeated",
+                              type: "opentelemetry.proto.trace.v1.ResourceSpans",
+                              id: 1
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+var root = protobuf.Root.fromJSON(descriptor);
+var RequestType = root.lookupType(
+  "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest"
+);
+function bytesToHex(bytes) {
+  if (!bytes) return void 0;
+  const arr = Array.isArray(bytes) ? bytes : bytes instanceof Uint8Array ? Array.from(bytes) : [];
+  if (arr.length === 0) return void 0;
+  return arr.map((b) => (b & 255).toString(16).padStart(2, "0")).join("");
+}
+function decodeProtobufTraces(body) {
+  const message = RequestType.decode(body);
+  const obj = RequestType.toObject(message, {
+    longs: String,
+    enums: Number,
+    bytes: Array,
+    defaults: false,
+    arrays: true,
+    objects: true
+  });
+  for (const rs of obj.resourceSpans ?? []) {
+    for (const ss of rs.scopeSpans ?? []) {
+      for (const span2 of ss.spans ?? []) {
+        span2.traceId = bytesToHex(span2.traceId) ?? "";
+        span2.spanId = bytesToHex(span2.spanId) ?? "";
+        const parent = bytesToHex(span2.parentSpanId);
+        if (parent) span2.parentSpanId = parent;
+        else delete span2.parentSpanId;
+      }
+    }
+  }
+  return obj;
+}
+
+// src/server.ts
+var MAX_BODY_BYTES = 50 * 1024 * 1024;
+function readBody(req) {
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error("payload too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve3(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+function decodeExport(contentType, body) {
+  if (contentType.includes("application/x-protobuf") || contentType.includes("application/protobuf")) {
+    return decodeProtobufTraces(body);
+  }
+  const text = body.toString("utf8").trim();
+  return text ? JSON.parse(text) : {};
+}
+function sendProtobuf(res, status) {
+  res.writeHead(status, { "content-type": "application/x-protobuf" });
+  res.end();
+}
+function sendJson(res, status, payload) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+async function handleTraces(req, res, onExport) {
+  const contentType = req.headers["content-type"] ?? "application/json";
+  let body;
+  try {
+    body = await readBody(req);
+  } catch {
+    sendJson(res, 413, { error: "payload too large" });
+    return;
+  }
+  let request;
+  try {
+    request = decodeExport(contentType, body);
+  } catch (err) {
+    sendJson(res, 400, { error: `failed to decode OTLP payload: ${err.message}` });
+    return;
+  }
+  const spans = parseOtlp(request);
+  try {
+    await onExport?.(spans, request);
+  } catch (err) {
+    sendJson(res, 500, { error: `export handler failed: ${err.message}` });
+    return;
+  }
+  const isProtobuf = contentType.includes("application/x-protobuf") || contentType.includes("application/protobuf");
+  if (isProtobuf) sendProtobuf(res, 200);
+  else sendJson(res, 200, {});
+}
+function createServer(options = {}) {
+  return createHttpServer((req, res) => {
+    void (async () => {
+      const url = (req.url ?? "/").split("?")[0];
+      if (req.method === "POST" && url === "/v1/traces") {
+        await handleTraces(req, res, options.onExport);
+        return;
+      }
+      if (req.method === "GET" && (url === "/health" || url === "/healthz")) {
+        sendJson(res, 200, { status: "ok" });
+        return;
+      }
+      if (options.extraHandler) {
+        const handled = await options.extraHandler(req, res);
+        if (handled) return;
+      }
+      sendJson(res, 404, { error: "not found" });
+    })().catch((err) => {
+      if (!res.headersSent) sendJson(res, 500, { error: err.message });
+    });
+  });
+}
+function listen(server, port, host) {
+  return new Promise((resolve3, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      const addr = server.address();
+      const boundPort = typeof addr === "object" && addr ? addr.port : port;
+      resolve3(boundPort);
+    });
+  });
+}
+
+// src/storage/session-store.ts
+import { createWriteStream, mkdirSync, readFileSync } from "fs";
+import { dirname } from "path";
+import {
+  parseSession,
+  runMatches,
+  serializeRun,
+  StatusCode
+} from "@tracebird/core";
+function statusLabel(code) {
+  if (code === StatusCode.Error) return "error";
+  if (code === StatusCode.Ok) return "ok";
+  return "unset";
+}
+function countNodes(node) {
+  return 1 + node.children.reduce((sum, child) => sum + countNodes(child), 0);
+}
+var SessionStore = class _SessionStore {
+  runs = [];
+  byId = /* @__PURE__ */ new Map();
+  stream;
+  filePath;
+  constructor(filePath) {
+    if (filePath) {
+      mkdirSync(dirname(filePath), { recursive: true });
+      this.filePath = filePath;
+      this.stream = createWriteStream(filePath, { flags: "a" });
+    }
+  }
+  /** Load an existing session file read-only (for `tracebird open`). */
+  static load(filePath) {
+    const store = new _SessionStore();
+    const text = readFileSync(filePath, "utf8");
+    for (const run of parseSession(text)) store.addRun(run, { persist: false });
+    return store;
+  }
+  addRun(run, options = {}) {
+    this.runs.push(run);
+    this.byId.set(run.id, run);
+    if (options.persist !== false) this.stream?.write(serializeRun(run) + "\n");
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  all() {
+    return this.runs;
+  }
+  /** Run summaries, newest first, optionally filtered by text and status. */
+  list(filter = {}) {
+    const status = filter.status ?? "all";
+    const query = filter.query ?? "";
+    return this.runs.filter((run) => status === "all" || statusLabel(run.status.code) === status).filter((run) => runMatches(run, query)).map((run) => ({
+      id: run.id,
+      traceId: run.traceId,
+      summary: run.summary,
+      startTimeUnixNano: run.startTimeUnixNano,
+      durationMs: run.durationMs,
+      status: statusLabel(run.status.code),
+      tokens: run.tokens,
+      costUsd: run.costUsd,
+      ...run.service ? { service: run.service } : {},
+      nodeCount: countNodes(run.root)
+    })).sort((a, b) => a.startTimeUnixNano < b.startTimeUnixNano ? 1 : -1);
+  }
+  get size() {
+    return this.runs.length;
+  }
+  async close() {
+    const stream = this.stream;
+    if (!stream) return;
+    await new Promise((resolve3, reject) => {
+      stream.end((err) => err ? reject(err) : resolve3());
+    });
+  }
+};
+
+// src/trace-buffer.ts
+var TraceBuffer = class {
+  idleMs;
+  onComplete;
+  traces = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.idleMs = options.idleMs ?? 1500;
+    this.onComplete = options.onComplete;
+  }
+  add(spans) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const span2 of spans) {
+      const list = grouped.get(span2.traceId) ?? [];
+      list.push(span2);
+      grouped.set(span2.traceId, list);
+    }
+    for (const [traceId, group] of grouped) {
+      const entry = this.traces.get(traceId);
+      if (entry) {
+        entry.spans.push(...group);
+        clearTimeout(entry.timer);
+        entry.timer = this.schedule(traceId);
+      } else {
+        this.traces.set(traceId, { spans: group, timer: this.schedule(traceId) });
+      }
+    }
+  }
+  schedule(traceId) {
+    const timer = setTimeout(() => this.flush(traceId), this.idleMs);
+    timer.unref?.();
+    return timer;
+  }
+  /** Flush a single trace now, if buffered. */
+  flush(traceId) {
+    const entry = this.traces.get(traceId);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    this.traces.delete(traceId);
+    this.onComplete(traceId, entry.spans);
+  }
+  /** Flush every buffered trace (e.g. on shutdown). */
+  flushAll() {
+    for (const traceId of [...this.traces.keys()]) this.flush(traceId);
+  }
+  get pending() {
+    return this.traces.size;
+  }
+};
+
+// src/render/tree.ts
+import { StatusCode as StatusCode2 } from "@tracebird/core";
+
+// src/render/format.ts
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "\u2014";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(2).replace(/\.?0+$/, "")}s`;
+  const mins = Math.floor(seconds / 60);
+  const rem = Math.round(seconds % 60);
+  return `${mins}m ${rem}s`;
+}
+function formatTokens(tokens) {
+  return tokens == null ? void 0 : `${tokens.toLocaleString("en-US")} tok`;
+}
+function formatCost(usd) {
+  if (usd == null) return void 0;
+  if (usd === 0) return "$0";
+  if (usd < 0.01) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(2)}`;
+}
+
+// src/render/tree.ts
+var ICON = {
+  run: "\u23FA",
+  agent: "\u25C6",
+  llm: "\u2726",
+  tool: "\u2699",
+  step: "\u25AB"
+};
+function metrics(node) {
+  const parts = [formatDuration(node.durationMs)];
+  if (node.kind === "llm") {
+    const llm = node;
+    const tok = formatTokens(llm.usage.total ?? llm.usage.input);
+    if (tok) parts.push(tok);
+    const cost = formatCost(llm.costUsd);
+    if (cost) parts.push(cost);
+    if (llm.model) parts.push(llm.model);
+  }
+  if (node.kind === "tool" && node.isError) parts.push("ERROR");
+  return parts.join("  ");
+}
+function label(node) {
+  return `${ICON[node.kind]} ${node.name}   ${metrics(node)}`;
+}
+function renderChildren(nodes, prefix, lines) {
+  nodes.forEach((node, i) => {
+    const last = i === nodes.length - 1;
+    lines.push(`${prefix}${last ? "\u2514\u2500 " : "\u251C\u2500 "}${label(node)}`);
+    renderChildren(node.children, prefix + (last ? "   " : "\u2502  "), lines);
+  });
+}
+function renderRunTree(run) {
+  const header = [run.summary, formatDuration(run.durationMs)];
+  const tok = formatTokens(run.tokens.total);
+  if (tok) header.push(tok);
+  const cost = formatCost(run.costUsd);
+  if (cost) header.push(cost);
+  if (run.status.code === StatusCode2.Error) header.push("ERROR");
+  const lines = [header.join("  \xB7  ")];
+  renderChildren(run.root.children, "", lines);
+  return lines.join("\n");
+}
+
+// src/api.ts
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+import { diffRuns } from "@tracebird/core";
+
+// src/export.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join } from "path";
+import { serializeSession } from "@tracebird/core";
+function exportJsonl(runs) {
+  return serializeSession(runs);
+}
+function inlineAssets(uiDir, html) {
+  const withJs = html.replace(
+    /<script\b[^>]*\bsrc="(\.?\/?assets\/[^"]+\.js)"[^>]*><\/script>/g,
+    (_match, src) => {
+      const code = readFileSync2(join(uiDir, src.replace(/^\.?\//, "")), "utf8").replace(
+        /<\/(script)/gi,
+        "<\\/$1"
+      );
+      return `<script type="module">${code}</script>`;
+    }
+  );
+  return withJs.replace(
+    /<link\b[^>]*\bhref="(\.?\/?assets\/[^"]+\.css)"[^>]*>/g,
+    (_match, href) => {
+      const css = readFileSync2(join(uiDir, href.replace(/^\.?\//, "")), "utf8");
+      return `<style>${css}</style>`;
+    }
+  );
+}
+function buildHtmlSnapshot(uiDir, runs) {
+  const store = new SessionStore();
+  for (const run of runs) store.addRun(run, { persist: false });
+  const snapshot = {
+    session: { live: false, filePath: null, count: runs.length },
+    runs: store.list(),
+    runsById: Object.fromEntries(runs.map((r) => [r.id, r]))
+  };
+  const json2 = JSON.stringify(snapshot).replace(/<\//g, "<\\/");
+  const inject = `<script>window.__TRACEBIRD_SNAPSHOT__=${json2}</script>`;
+  const html = inlineAssets(uiDir, readFileSync2(join(uiDir, "index.html"), "utf8"));
+  if (html.includes('<script type="module">')) {
+    return html.replace('<script type="module">', `${inject}<script type="module">`);
+  }
+  return html.replace("</head>", `${inject}</head>`);
+}
+
+// src/api.ts
+function json(res, status, payload) {
+  res.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" });
+  res.end(JSON.stringify(payload));
+}
+function handleApi(ctx, req, res) {
+  const url = (req.url ?? "/").split("?")[0];
+  if (!url.startsWith("/api/")) return false;
+  if (req.method !== "GET") {
+    json(res, 405, { error: "method not allowed" });
+    return true;
+  }
+  if (url === "/api/session") {
+    json(res, 200, {
+      live: ctx.live,
+      filePath: ctx.store.filePath ?? null,
+      count: ctx.store.size
+    });
+    return true;
+  }
+  if (url === "/api/runs") {
+    const params = new URL(req.url ?? "", "http://localhost").searchParams;
+    const query = params.get("q") ?? void 0;
+    const statusParam = params.get("status");
+    const status = statusParam === "ok" || statusParam === "error" || statusParam === "unset" ? statusParam : "all";
+    json(res, 200, ctx.store.list({ query, status }));
+    return true;
+  }
+  if (url === "/api/diff") {
+    const params = new URL(req.url ?? "", "http://localhost").searchParams;
+    const aId = params.get("a");
+    const bId = params.get("b");
+    if (!aId || !bId) {
+      json(res, 400, { error: "diff requires ?a=<runId>&b=<runId>" });
+      return true;
+    }
+    const a = ctx.store.get(aId);
+    const b = ctx.store.get(bId);
+    if (!a || !b) {
+      json(res, 404, { error: `run not found: ${!a ? aId : bId}` });
+      return true;
+    }
+    json(res, 200, diffRuns(a, b));
+    return true;
+  }
+  if (url === "/api/export") {
+    const params = new URL(req.url ?? "", "http://localhost").searchParams;
+    const id = params.get("id");
+    const format = params.get("format") === "jsonl" ? "jsonl" : "html";
+    let runs;
+    let name;
+    if (id) {
+      const run = ctx.store.get(id);
+      if (!run) {
+        json(res, 404, { error: `run not found: ${id}` });
+        return true;
+      }
+      runs = [run];
+      name = `tracebird-run-${run.traceId.slice(0, 8) || "export"}`;
+    } else {
+      runs = ctx.store.all();
+      name = "tracebird-session";
+    }
+    if (format === "jsonl") {
+      res.writeHead(200, {
+        "content-type": "application/x-ndjson; charset=utf-8",
+        "content-disposition": `attachment; filename="${name}.jsonl"`
+      });
+      res.end(exportJsonl(runs));
+      return true;
+    }
+    if (!ctx.uiDir || !existsSync(join2(ctx.uiDir, "index.html"))) {
+      json(res, 503, { error: "UI assets not available for HTML export" });
+      return true;
+    }
+    res.writeHead(200, {
+      "content-type": "text/html; charset=utf-8",
+      "content-disposition": `attachment; filename="${name}.html"`
+    });
+    res.end(buildHtmlSnapshot(ctx.uiDir, runs));
+    return true;
+  }
+  const match = /^\/api\/runs\/([^/]+)$/.exec(url);
+  if (match) {
+    const id = decodeURIComponent(match[1]);
+    const run = ctx.store.get(id);
+    if (!run) json(res, 404, { error: `run not found: ${id}` });
+    else json(res, 200, run);
+    return true;
+  }
+  json(res, 404, { error: "unknown api route" });
+  return true;
+}
+
+// src/static-files.ts
+import { createReadStream, existsSync as existsSync2, statSync } from "fs";
+import { join as join3, normalize, extname } from "path";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".map": "application/json; charset=utf-8"
+};
+function serveStatic(rootDir, req, res) {
+  if (!existsSync2(rootDir)) return false;
+  if (req.method !== "GET" && req.method !== "HEAD") return false;
+  const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
+  const rel = normalize(urlPath).replace(/^(\.\.[/\\])+/, "");
+  let filePath = join3(rootDir, rel);
+  if (!filePath.startsWith(rootDir)) filePath = join3(rootDir, "index.html");
+  if (!existsSync2(filePath) || statSync(filePath).isDirectory()) {
+    filePath = join3(rootDir, "index.html");
+  }
+  if (!existsSync2(filePath)) return false;
+  const type = MIME[extname(filePath)] ?? "application/octet-stream";
+  res.writeHead(200, { "content-type": type });
+  if (req.method === "HEAD") {
+    res.end();
+    return true;
+  }
+  createReadStream(filePath).pipe(res);
+  return true;
+}
+
+// src/app.ts
+function createAppHandler(ctx, uiDir, sse) {
+  const apiCtx = { ...ctx, uiDir };
+  return (req, res) => {
+    const url = (req.url ?? "/").split("?")[0];
+    if (sse && req.method === "GET" && url === "/api/stream") {
+      sse.handle(req, res);
+      return true;
+    }
+    if (handleApi(apiCtx, req, res)) return true;
+    if (serveStatic(uiDir, req, res)) return true;
+    return false;
+  };
+}
+
+// src/ui-dir.ts
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath } from "url";
+function resolveUiDir() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    join4(here, "ui"),
+    // dist/ui (published / built)
+    join4(here, "..", "..", "ui", "dist")
+    // packages/cli/dist → packages/ui/dist
+  ];
+  return candidates.find((dir) => existsSync3(join4(dir, "index.html"))) ?? candidates[0];
+}
+
+// src/open-browser.ts
+import { spawn } from "child_process";
+function openBrowser(url) {
+  const platform = process.platform;
+  const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", '""', url] : [url];
+  try {
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => void 0);
+    child.unref();
+  } catch {
+  }
+}
+
+// src/sse.ts
+var SseHub = class {
+  clients = /* @__PURE__ */ new Set();
+  heartbeat;
+  /** Register a long-lived SSE connection. */
+  handle(req, res) {
+    res.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache, no-transform",
+      connection: "keep-alive",
+      "x-accel-buffering": "no"
+    });
+    res.write("retry: 2000\n\n");
+    this.clients.add(res);
+    req.on("close", () => this.clients.delete(res));
+    if (!this.heartbeat) {
+      this.heartbeat = setInterval(() => this.write(":ping\n\n"), 15e3);
+      this.heartbeat.unref?.();
+    }
+  }
+  /** Push a named event with a JSON payload to every connected client. */
+  broadcast(event, data = {}) {
+    this.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+  }
+  write(text) {
+    for (const res of this.clients) {
+      try {
+        res.write(text);
+      } catch {
+        this.clients.delete(res);
+      }
+    }
+  }
+  get size() {
+    return this.clients.size;
+  }
+  close() {
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    for (const res of this.clients) {
+      try {
+        res.end();
+      } catch {
+      }
+    }
+    this.clients.clear();
+  }
+};
+
+// src/commands/live.ts
+async function runLive(options) {
+  const store = new SessionStore(join5(options.outDir, `session-${Date.now()}.jsonl`));
+  const sse = new SseHub();
+  const buffer = new TraceBuffer({
+    onComplete: (_traceId, spans) => {
+      const run = buildRun(spans);
+      store.addRun(run);
+      process.stdout.write("\n" + renderRunTree(run) + "\n");
+      sse.broadcast("run", { id: run.id });
+    }
+  });
+  const server = createServer({
+    onExport: (spans) => {
+      buffer.add(spans);
+      sse.broadcast("activity", { spans: spans.length });
+    },
+    extraHandler: createAppHandler({ store, live: true }, resolveUiDir(), sse)
+  });
+  const boundPort = await listen(server, options.port, options.host);
+  const endpoint = `http://${options.host}:${boundPort}`;
+  process.stdout.write(
+    [
+      "",
+      "  tracebird \u2014 listening for OpenTelemetry traces",
+      "",
+      `  UI              ${endpoint}`,
+      `  OTLP endpoint   ${endpoint}/v1/traces`,
+      `  Session file    ${store.filePath}`,
+      "",
+      "  Point your agent at this receiver:",
+      `    export OTEL_EXPORTER_OTLP_ENDPOINT=${endpoint}`,
+      "",
+      "  Waiting for your first agent run\u2026  (Ctrl-C to stop)",
+      ""
+    ].join("\n") + "\n"
+  );
+  if (options.open) openBrowser(endpoint);
+  await new Promise((resolveShutdown) => {
+    const shutdown = () => {
+      process.stdout.write("\n  Stopping\u2026\n");
+      buffer.flushAll();
+      sse.close();
+      server.close(() => {
+        void store.close().then(() => resolveShutdown());
+      });
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+
+// src/commands/open.ts
+import { existsSync as existsSync4 } from "fs";
+import { resolve } from "path";
+async function runOpen(options) {
+  const file = resolve(options.file);
+  if (!existsSync4(file)) {
+    process.stderr.write(`tracebird: session file not found: ${file}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  let store;
+  try {
+    store = SessionStore.load(file);
+  } catch (err) {
+    process.stderr.write(`tracebird: failed to load session: ${err.message}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const server = createServer({
+    extraHandler: createAppHandler({ store, live: false }, resolveUiDir())
+  });
+  const boundPort = await listen(server, options.port, options.host);
+  const endpoint = `http://${options.host}:${boundPort}`;
+  process.stdout.write(
+    [
+      "",
+      `  tracebird \u2014 serving ${store.size} run(s) from`,
+      `    ${file}`,
+      "",
+      `  UI   ${endpoint}`,
+      "",
+      "  (Ctrl-C to stop)",
+      ""
+    ].join("\n") + "\n"
+  );
+  if (options.open) openBrowser(endpoint);
+  await new Promise((resolveShutdown) => {
+    const shutdown = () => {
+      process.stdout.write("\n  Stopping\u2026\n");
+      server.close(() => resolveShutdown());
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+
+// src/commands/demo.ts
+import { buildRuns, parseOtlp as parseOtlp2 } from "@tracebird/core";
+
+// ../../libs/fixtures/src/otlp/builders.ts
+function toAnyValue(v) {
+  if (typeof v === "string") return { stringValue: v };
+  if (typeof v === "boolean") return { boolValue: v };
+  return Number.isInteger(v) ? { intValue: String(v) } : { doubleValue: v };
+}
+function attrs(record) {
+  return Object.entries(record).map(([key, v]) => ({ key, value: toAnyValue(v) }));
+}
+function span(input) {
+  return {
+    traceId: input.traceId,
+    spanId: input.spanId,
+    ...input.parentSpanId ? { parentSpanId: input.parentSpanId } : {},
+    name: input.name,
+    kind: input.kind ?? 1,
+    startTimeUnixNano: input.startTimeUnixNano,
+    endTimeUnixNano: input.endTimeUnixNano,
+    attributes: attrs(input.attributes ?? {}),
+    status: {
+      code: input.statusCode ?? 0,
+      ...input.statusMessage ? { message: input.statusMessage } : {}
+    }
+  };
+}
+function traceRequest(input) {
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: attrs({ "service.name": input.serviceName })
+        },
+        scopeSpans: [
+          {
+            scope: {
+              name: input.scopeName,
+              ...input.scopeVersion ? { version: input.scopeVersion } : {}
+            },
+            spans: input.spans
+          }
+        ]
+      }
+    ]
+  };
+}
+function at(baseNano, offsetMs) {
+  return (baseNano + BigInt(offsetMs) * 1000000n).toString();
+}
+
+// ../../libs/fixtures/src/otlp/weather-happy-path.ts
+var BASE = 1733000000000000000n;
+var TRACE = "0af7651916cd43dd8448eb211c80319c";
+var ROOT = "1111111111111111";
+var LLM1 = "2222222222222222";
+var TOOL1 = "3333333333333333";
+var TOOL2 = "4444444444444444";
+var LLM2 = "5555555555555555";
+var weatherHappyPath = traceRequest({
+  serviceName: "weather-assistant",
+  scopeName: "opentelemetry.instrumentation.openai",
+  scopeVersion: "0.30.0",
+  spans: [
+    span({
+      traceId: TRACE,
+      spanId: ROOT,
+      name: "invoke_agent weather-assistant",
+      startTimeUnixNano: at(BASE, 0),
+      endTimeUnixNano: at(BASE, 1300),
+      statusCode: 1,
+      attributes: {
+        "gen_ai.operation.name": "invoke_agent",
+        "gen_ai.agent.name": "weather-assistant",
+        "gen_ai.system": "openai"
+      }
+    }),
+    span({
+      traceId: TRACE,
+      spanId: LLM1,
+      parentSpanId: ROOT,
+      name: "chat gpt-4o",
+      startTimeUnixNano: at(BASE, 10),
+      endTimeUnixNano: at(BASE, 520),
+      statusCode: 1,
+      attributes: {
+        "gen_ai.operation.name": "chat",
+        "gen_ai.system": "openai",
+        "gen_ai.request.model": "gpt-4o",
+        "gen_ai.response.model": "gpt-4o-2024-08-06",
+        "gen_ai.request.temperature": 0.7,
+        "gen_ai.usage.input_tokens": 58,
+        "gen_ai.usage.output_tokens": 34,
+        "gen_ai.prompt.0.role": "system",
+        "gen_ai.prompt.0.content": "You are a helpful weather assistant. Use tools to look up live data before answering.",
+        "gen_ai.prompt.1.role": "user",
+        "gen_ai.prompt.1.content": "What should I wear in Paris today?",
+        "gen_ai.completion.0.role": "assistant",
+        "gen_ai.completion.0.content": "",
+        "gen_ai.completion.0.tool_calls.0.id": "call_weather",
+        "gen_ai.completion.0.tool_calls.0.name": "get_weather",
+        "gen_ai.completion.0.tool_calls.0.arguments": '{"location":"Paris"}',
+        "gen_ai.completion.0.tool_calls.1.id": "call_forecast",
+        "gen_ai.completion.0.tool_calls.1.name": "get_forecast",
+        "gen_ai.completion.0.tool_calls.1.arguments": '{"location":"Paris","hours":12}'
+      }
+    }),
+    span({
+      traceId: TRACE,
+      spanId: TOOL1,
+      parentSpanId: ROOT,
+      name: "execute_tool get_weather",
+      startTimeUnixNano: at(BASE, 530),
+      endTimeUnixNano: at(BASE, 548),
+      statusCode: 1,
+      attributes: {
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": "get_weather",
+        "gen_ai.tool.call.id": "call_weather",
+        "gen_ai.tool.call.arguments": '{"location":"Paris"}',
+        "gen_ai.tool.call.result": '{"tempC":18,"condition":"sunny","humidity":0.41}'
+      }
+    }),
+    span({
+      traceId: TRACE,
+      spanId: TOOL2,
+      parentSpanId: ROOT,
+      name: "execute_tool get_forecast",
+      startTimeUnixNano: at(BASE, 532),
+      endTimeUnixNano: at(BASE, 560),
+      statusCode: 1,
+      attributes: {
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": "get_forecast",
+        "gen_ai.tool.call.id": "call_forecast",
+        "gen_ai.tool.call.arguments": '{"location":"Paris","hours":12}',
+        "gen_ai.tool.call.result": '{"highC":21,"lowC":12,"rain":false}'
+      }
+    }),
+    span({
+      traceId: TRACE,
+      spanId: LLM2,
+      parentSpanId: ROOT,
+      name: "chat gpt-4o",
+      startTimeUnixNano: at(BASE, 580),
+      endTimeUnixNano: at(BASE, 1290),
+      statusCode: 1,
+      attributes: {
+        "gen_ai.operation.name": "chat",
+        "gen_ai.system": "openai",
+        "gen_ai.request.model": "gpt-4o",
+        "gen_ai.response.model": "gpt-4o-2024-08-06",
+        "gen_ai.request.temperature": 0.7,
+        "gen_ai.usage.input_tokens": 140,
+        "gen_ai.usage.output_tokens": 42,
+        "gen_ai.prompt.0.role": "system",
+        "gen_ai.prompt.0.content": "You are a helpful weather assistant. Use tools to look up live data before answering.",
+        "gen_ai.prompt.1.role": "user",
+        "gen_ai.prompt.1.content": "What should I wear in Paris today?",
+        "gen_ai.prompt.2.role": "tool",
+        "gen_ai.prompt.2.content": '{"tempC":18,"condition":"sunny","humidity":0.41}',
+        "gen_ai.prompt.3.role": "tool",
+        "gen_ai.prompt.3.content": '{"highC":21,"lowC":12,"rain":false}',
+        "gen_ai.completion.0.role": "assistant",
+        "gen_ai.completion.0.content": "It's 18\xB0C and sunny in Paris, with a high of 21\xB0C and no rain expected. A light jacket or long sleeves will be perfect \u2014 you won't need an umbrella."
+      }
+    })
+  ]
+});
+
+// ../../libs/fixtures/src/otlp/tool-error.ts
+var BASE2 = 1733000100000000000n;
+var TRACE2 = "b2c3d4e5f60718293a4b5c6d7e8f9012";
+var ROOT2 = "aa00000000000001";
+var LLM12 = "aa00000000000002";
+var TOOL12 = "aa00000000000003";
+var LLM22 = "aa00000000000004";
+var toolError = traceRequest({
+  serviceName: "weather-assistant",
+  scopeName: "opentelemetry.instrumentation.openai",
+  scopeVersion: "0.30.0",
+  spans: [
+    span({
+      traceId: TRACE2,
+      spanId: ROOT2,
+      name: "invoke_agent weather-assistant",
+      startTimeUnixNano: at(BASE2, 0),
+      endTimeUnixNano: at(BASE2, 900),
+      statusCode: 1,
+      attributes: {
+        "gen_ai.operation.name": "invoke_agent",
+        "gen_ai.agent.name": "weather-assistant",
+        "gen_ai.system": "openai"
+      }
+    }),
+    span({
+      traceId: TRACE2,
+      spanId: LLM12,
+      parentSpanId: ROOT2,
+      name: "chat gpt-4o",
+      startTimeUnixNano: at(BASE2, 8),
+      endTimeUnixNano: at(BASE2, 410),
+      statusCode: 1,
+      attributes: {
+        "gen_ai.operation.name": "chat",
+        "gen_ai.system": "openai",
+        "gen_ai.request.model": "gpt-4o",
+        "gen_ai.response.model": "gpt-4o-2024-08-06",
+        "gen_ai.usage.input_tokens": 52,
+        "gen_ai.usage.output_tokens": 16,
+        "gen_ai.prompt.0.role": "user",
+        "gen_ai.prompt.0.content": "What's the weather in Atlantis?",
+        "gen_ai.completion.0.role": "assistant",
+        "gen_ai.completion.0.content": "",
+        "gen_ai.completion.0.tool_calls.0.id": "call_weather",
+        "gen_ai.completion.0.tool_calls.0.name": "get_weather",
+        "gen_ai.completion.0.tool_calls.0.arguments": '{"location":"Atlantis"}'
+      }
+    }),
+    span({
+      traceId: TRACE2,
+      spanId: TOOL12,
+      parentSpanId: ROOT2,
+      name: "execute_tool get_weather",
+      startTimeUnixNano: at(BASE2, 420),
+      endTimeUnixNano: at(BASE2, 438),
+      statusCode: 2,
+      statusMessage: 'UnknownLocationError: no such location "Atlantis"',
+      attributes: {
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": "get_weather",
+        "gen_ai.tool.call.id": "call_weather",
+        "gen_ai.tool.call.arguments": '{"location":"Atlantis"}',
+        "error.type": "UnknownLocationError",
+        "gen_ai.tool.call.result": '{"error":"no such location \\"Atlantis\\""}'
+      }
+    }),
+    span({
+      traceId: TRACE2,
+      spanId: LLM22,
+      parentSpanId: ROOT2,
+      name: "chat gpt-4o",
+      startTimeUnixNano: at(BASE2, 450),
+      endTimeUnixNano: at(BASE2, 890),
+      statusCode: 1,
+      attributes: {
+        "gen_ai.operation.name": "chat",
+        "gen_ai.system": "openai",
+        "gen_ai.request.model": "gpt-4o",
+        "gen_ai.response.model": "gpt-4o-2024-08-06",
+        "gen_ai.usage.input_tokens": 88,
+        "gen_ai.usage.output_tokens": 28,
+        "gen_ai.prompt.0.role": "user",
+        "gen_ai.prompt.0.content": "What's the weather in Atlantis?",
+        "gen_ai.prompt.1.role": "tool",
+        "gen_ai.prompt.1.content": '{"error":"no such location \\"Atlantis\\""}',
+        "gen_ai.completion.0.role": "assistant",
+        "gen_ai.completion.0.content": `I couldn't find a place called "Atlantis" to look up the weather. Could you double-check the spelling or give me a nearby city?`
+      }
+    })
+  ]
+});
+
+// ../../libs/fixtures/src/otlp/diff-pair.ts
+var TICKET = "Customer reports the checkout page returns a 500 error intermittently on mobile Safari. They have tried twice. No charge was made.";
+var SYSTEM = "You are a support triage agent. Read the ticket and assign a priority from P1 (urgent) to P4 (low).";
+function triageRun(opts) {
+  return traceRequest({
+    serviceName: "support-triage",
+    scopeName: "opentelemetry.instrumentation.openai",
+    scopeVersion: "0.30.0",
+    spans: [
+      span({
+        traceId: opts.trace,
+        spanId: opts.rootId,
+        name: "invoke_agent support-triage",
+        startTimeUnixNano: at(opts.base, 0),
+        endTimeUnixNano: at(opts.base, opts.endMs),
+        statusCode: 1,
+        attributes: {
+          "gen_ai.operation.name": "invoke_agent",
+          "gen_ai.agent.name": "support-triage",
+          "gen_ai.system": "openai"
+        }
+      }),
+      span({
+        traceId: opts.trace,
+        spanId: opts.llmId,
+        parentSpanId: opts.rootId,
+        name: `chat ${opts.model}`,
+        startTimeUnixNano: at(opts.base, 6),
+        endTimeUnixNano: at(opts.base, opts.endMs - 4),
+        statusCode: 1,
+        attributes: {
+          "gen_ai.operation.name": "chat",
+          "gen_ai.system": "openai",
+          "gen_ai.request.model": opts.model,
+          "gen_ai.response.model": opts.responseModel,
+          "gen_ai.request.temperature": 0.2,
+          "gen_ai.usage.input_tokens": 96,
+          "gen_ai.usage.output_tokens": opts.outputTokens,
+          "gen_ai.prompt.0.role": "system",
+          "gen_ai.prompt.0.content": SYSTEM,
+          "gen_ai.prompt.1.role": "user",
+          "gen_ai.prompt.1.content": TICKET,
+          "gen_ai.completion.0.role": "assistant",
+          "gen_ai.completion.0.content": opts.completion
+        }
+      })
+    ]
+  });
+}
+var diffPairA = triageRun({
+  base: 1733000200000000000n,
+  trace: "c1000000000000000000000000000a01",
+  rootId: "c100000000000a01",
+  llmId: "c100000000000a02",
+  model: "gpt-4o",
+  responseModel: "gpt-4o-2024-08-06",
+  outputTokens: 54,
+  endMs: 640,
+  completion: "Priority: P1. A 500 error at checkout blocks revenue and affects all mobile Safari users intermittently. Escalate to the payments team immediately."
+});
+var diffPairB = triageRun({
+  base: 1733000300000000000n,
+  trace: "c2000000000000000000000000000b01",
+  rootId: "c200000000000b01",
+  llmId: "c200000000000b02",
+  model: "gpt-4o-mini",
+  responseModel: "gpt-4o-mini-2024-07-18",
+  outputTokens: 48,
+  endMs: 410,
+  completion: "Priority: P2. Checkout returns a 500 on mobile Safari intermittently, but no charge was made and a retry path exists. Route to the web team for investigation."
+});
+
+// ../../libs/fixtures/src/otlp/openinference.ts
+var BASE3 = 1733000400000000000n;
+var TRACE3 = "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1";
+var ROOT3 = "d1000000000000a1";
+var LLM = "d1000000000000a2";
+var TOOL = "d1000000000000a3";
+var openinferenceAgent = traceRequest({
+  serviceName: "docs-assistant",
+  scopeName: "openinference.instrumentation.openai",
+  scopeVersion: "0.1.0",
+  spans: [
+    span({
+      traceId: TRACE3,
+      spanId: ROOT3,
+      name: "agent",
+      startTimeUnixNano: at(BASE3, 0),
+      endTimeUnixNano: at(BASE3, 900),
+      statusCode: 1,
+      attributes: { "openinference.span.kind": "AGENT" }
+    }),
+    span({
+      traceId: TRACE3,
+      spanId: LLM,
+      parentSpanId: ROOT3,
+      name: "ChatCompletion",
+      startTimeUnixNano: at(BASE3, 10),
+      endTimeUnixNano: at(BASE3, 460),
+      statusCode: 1,
+      attributes: {
+        "openinference.span.kind": "LLM",
+        "llm.model_name": "gpt-4o",
+        "llm.provider": "openai",
+        "llm.token_count.prompt": 42,
+        "llm.token_count.completion": 18,
+        "llm.input_messages.0.message.role": "system",
+        "llm.input_messages.0.message.content": "You answer questions about the docs.",
+        "llm.input_messages.1.message.role": "user",
+        "llm.input_messages.1.message.content": "How do I enable telemetry?",
+        "llm.output_messages.0.message.role": "assistant",
+        "llm.output_messages.0.message.content": "",
+        "llm.output_messages.0.message.tool_calls.0.tool_call.function.name": "search_docs",
+        "llm.output_messages.0.message.tool_calls.0.tool_call.function.arguments": '{"query":"enable telemetry"}'
+      }
+    }),
+    span({
+      traceId: TRACE3,
+      spanId: TOOL,
+      parentSpanId: ROOT3,
+      name: "search_docs",
+      startTimeUnixNano: at(BASE3, 470),
+      endTimeUnixNano: at(BASE3, 500),
+      statusCode: 1,
+      attributes: {
+        "openinference.span.kind": "TOOL",
+        "tool.name": "search_docs",
+        "input.value": '{"query":"enable telemetry"}',
+        "output.value": '{"hits":["Set OTEL_EXPORTER_OTLP_ENDPOINT=\u2026"]}'
+      }
+    })
+  ]
+});
+
+// ../../libs/fixtures/src/otlp/vercel-ai-sdk.ts
+var BASE4 = 1733000500000000000n;
+var TRACE4 = "e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1";
+var ROOT4 = "e1000000000000b1";
+var GEN = "e1000000000000b2";
+var TOOL3 = "e1000000000000b3";
+var vercelAiSdk = traceRequest({
+  serviceName: "ai-sdk-app",
+  scopeName: "ai",
+  scopeVersion: "4.0.0",
+  spans: [
+    span({
+      traceId: TRACE4,
+      spanId: ROOT4,
+      name: "ai.generateText",
+      startTimeUnixNano: at(BASE4, 0),
+      endTimeUnixNano: at(BASE4, 1100),
+      statusCode: 1,
+      attributes: {
+        "ai.model.id": "gpt-4o",
+        "ai.model.provider": "openai.chat",
+        "ai.usage.promptTokens": 64,
+        "ai.usage.completionTokens": 30
+      }
+    }),
+    span({
+      traceId: TRACE4,
+      spanId: GEN,
+      parentSpanId: ROOT4,
+      name: "ai.generateText.doGenerate",
+      startTimeUnixNano: at(BASE4, 20),
+      endTimeUnixNano: at(BASE4, 540),
+      statusCode: 1,
+      attributes: {
+        "ai.model.id": "gpt-4o",
+        "ai.model.provider": "openai.chat",
+        "ai.usage.promptTokens": 64,
+        "ai.usage.completionTokens": 30,
+        "ai.prompt.messages": '[{"role":"user","content":"What is the weather in San Francisco?"}]',
+        "ai.response.text": "Let me check the current conditions in San Francisco."
+      }
+    }),
+    span({
+      traceId: TRACE4,
+      spanId: TOOL3,
+      parentSpanId: ROOT4,
+      name: "ai.toolCall",
+      startTimeUnixNano: at(BASE4, 560),
+      endTimeUnixNano: at(BASE4, 600),
+      statusCode: 1,
+      attributes: {
+        "ai.toolCall.name": "getWeather",
+        "ai.toolCall.args": '{"city":"San Francisco"}',
+        "ai.toolCall.result": '{"tempC":17,"condition":"foggy"}'
+      }
+    })
+  ]
+});
+
+// ../../libs/fixtures/src/otlp/claude-code.ts
+var BASE5 = 1733000600000000000n;
+var TRACE5 = "f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1";
+var ROOT5 = "f1000000000000c1";
+var LLM3 = "f1000000000000c2";
+var TOOL4 = "f1000000000000c3";
+var claudeCodeSession = traceRequest({
+  serviceName: "claude-code",
+  scopeName: "com.anthropic.claude_code",
+  scopeVersion: "2.0.0",
+  spans: [
+    span({
+      traceId: TRACE5,
+      spanId: ROOT5,
+      name: "claude_code.interaction",
+      startTimeUnixNano: at(BASE5, 0),
+      endTimeUnixNano: at(BASE5, 4200),
+      statusCode: 1,
+      attributes: {
+        "user_prompt": "Add a --json flag to the parser CLI",
+        "interaction.sequence": 1
+      }
+    }),
+    span({
+      traceId: TRACE5,
+      spanId: LLM3,
+      parentSpanId: ROOT5,
+      name: "claude_code.llm_request",
+      startTimeUnixNano: at(BASE5, 30),
+      endTimeUnixNano: at(BASE5, 2600),
+      statusCode: 1,
+      attributes: {
+        "gen_ai.system": "anthropic",
+        "gen_ai.request.model": "claude-sonnet-4",
+        "input_tokens": 1840,
+        "output_tokens": 420,
+        "cache_read_tokens": 12e3,
+        "gen_ai.response.finish_reasons": "tool_use",
+        "user_prompt": "Add a --json flag to the parser CLI"
+      }
+    }),
+    span({
+      traceId: TRACE5,
+      spanId: TOOL4,
+      parentSpanId: ROOT5,
+      name: "claude_code.tool",
+      startTimeUnixNano: at(BASE5, 2650),
+      endTimeUnixNano: at(BASE5, 2710),
+      statusCode: 1,
+      attributes: {
+        "tool_name": "Edit",
+        "file_path": "packages/cli/src/parser.ts",
+        "tool_output": "Applied 1 edit to packages/cli/src/parser.ts"
+      }
+    })
+  ]
+});
+
+// ../../libs/fixtures/src/index.ts
+var otlpFixtures = {
+  weatherHappyPath,
+  toolError,
+  diffPairA,
+  diffPairB,
+  openinferenceAgent,
+  vercelAiSdk,
+  claudeCodeSession
+};
+
+// src/commands/demo.ts
+async function runDemo(options) {
+  const store = new SessionStore();
+  for (const payload of Object.values(otlpFixtures)) {
+    for (const run of buildRuns(parseOtlp2(payload))) store.addRun(run, { persist: false });
+  }
+  const server = createServer({
+    extraHandler: createAppHandler({ store, live: false }, resolveUiDir())
+  });
+  const boundPort = await listen(server, options.port, options.host);
+  const endpoint = `http://${options.host}:${boundPort}`;
+  process.stdout.write(
+    [
+      "",
+      `  tracebird \u2014 demo mode, ${store.size} sample run(s) loaded`,
+      "",
+      `  UI   ${endpoint}`,
+      "",
+      "  Try the Diff tab (the two support-triage runs differ on one decision),",
+      "  and drag the scrubber to time-travel through a run.",
+      "",
+      "  (Ctrl-C to stop)",
+      ""
+    ].join("\n") + "\n"
+  );
+  if (options.open) openBrowser(endpoint);
+  await new Promise((resolveShutdown) => {
+    const shutdown = () => {
+      process.stdout.write("\n  Stopping\u2026\n");
+      server.close(() => resolveShutdown());
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+
+// src/cli.ts
+var HELP = `tracebird \u2014 a local-first, time-travel debugger for AI agent runs.
+
+Usage:
+  tracebird [live]                 Start the OTLP receiver + UI (default).
+  tracebird demo                   Serve the UI with bundled sample runs (no agent needed).
+  tracebird open <file.jsonl>      Load a saved session and serve the UI.
+  tracebird --help                 Show this help.
+
+Options:
+  --port <n>     Port for the OTLP receiver / UI server (default 4318).
+  --host <addr>  Address to bind (default 127.0.0.1).
+  --out <dir>    Directory for captured sessions (default ./.tracebird).
+  --no-open      Do not open the browser on start.
+
+Point your agent's OpenTelemetry exporter at the receiver:
+  export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+`;
+async function main(argv) {
+  const noOpen = argv.includes("--no-open");
+  const cleaned = argv.filter((a) => a !== "--no-open");
+  const { values, positionals } = parseArgs({
+    args: cleaned,
+    allowPositionals: true,
+    options: {
+      port: { type: "string" },
+      host: { type: "string" },
+      out: { type: "string" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help) {
+    process.stdout.write(HELP);
+    return;
+  }
+  const command = positionals[0] ?? "live";
+  const port = values.port ? Number(values.port) : 4318;
+  const host = values.host ?? "127.0.0.1";
+  const outDir = resolve2(values.out ?? ".tracebird");
+  const open = !noOpen;
+  switch (command) {
+    case "live":
+      await runLive({ port, host, outDir, open });
+      break;
+    case "demo":
+      await runDemo({ port, host, open });
+      break;
+    case "open": {
+      const file = positionals[1];
+      if (!file) {
+        process.stderr.write("Usage: tracebird open <file.jsonl>\n");
+        process.exitCode = 1;
+        break;
+      }
+      await runOpen({ file, port, host, open });
+      break;
+    }
+    case "help":
+      process.stdout.write(HELP);
+      break;
+    default:
+      process.stderr.write(`Unknown command: ${command}
+
+${HELP}`);
+      process.exitCode = 1;
+  }
+}
+main(process.argv.slice(2)).catch((err) => {
+  process.stderr.write(`tracebird: ${err.message}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map