@expo/event-log 0.0.1-init

package/dist/expo-event-log-cli.mjs

@@ -0,0 +1,1406 @@
+#!/usr/bin/env node
+import { fileURLToPath as e } from "node:url";
+
+import { c as t, p as n, a as s, m as o, r, b as i, d as a, t as c, L as l, l as p } from "./chunks/tap-chunk.mjs";
+
+import u from "node:fs";
+
+import { createInterface as f } from "node:readline";
+
+import { parseArgs as d } from "node:util";
+
+import m from "node:crypto";
+
+import h from "node:path";
+
+import g from "typescript";
+
+import { spawn as v } from "node:child_process";
+
+import y from "node:http";
+
+const w = {
+  since: {
+    type: "string"
+  },
+  filter: {
+    type: "string",
+    multiple: !0
+  },
+  tail: {
+    type: "boolean"
+  }
+};
+
+async function* readJsonlStream(e) {
+  const t = f({
+    input: e
+  });
+  for await (const e of t) {
+    if (!e) {
+      continue;
+    }
+    const t = s(e);
+    if (t) {
+      yield t;
+    }
+  }
+}
+
+function parseSharedTapOptions(e) {
+  return {
+    since: e.since,
+    filter: e.filter?.flatMap(e => e.split(",")).map(e => e.trim()).filter(Boolean),
+    follow: !0 === e.tail
+  };
+}
+
+function parseHelp(e) {
+  return !0 === d({
+    args: e,
+    allowPositionals: !0,
+    strict: !1,
+    options: {
+      help: {
+        type: "boolean",
+        short: "h"
+      }
+    }
+  }).values.help;
+}
+
+function parsePort(e) {
+  if (null == e) {
+    return;
+  }
+  const t = function parseInteger(e, t) {
+    if (!/^\d+$/.test(e)) {
+      throw new Error(`Invalid ${t}: ${e}`);
+    }
+    const n = Number(e);
+    if (!Number.isSafeInteger(n)) {
+      throw new Error(`Invalid ${t}: ${e}`);
+    }
+    return n;
+  }(e, "port");
+  if (t < 0 || t > 65535) {
+    throw new Error(`Invalid port: ${e}`);
+  }
+  return t;
+}
+
+function parseNonNegativeNumber(e, t) {
+  if (null == e) {
+    return;
+  }
+  const n = Number(e);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new Error(`Invalid ${t}: ${e}`);
+  }
+  return n;
+}
+
+function matchesTapOptions(e, t, n) {
+  if (null != t && e._t < t) {
+    return !1;
+  }
+  return o(e._e, n);
+}
+
+function durationUnitToMs(e) {
+  if ("ms" === e || "msec" === e || "msecs" === e || "millisecond" === e || "milliseconds" === e) {
+    return 1;
+  }
+  if ("s" === e || "sec" === e || "secs" === e || "second" === e || "seconds" === e) {
+    return 1e3;
+  }
+  if ("m" === e || "min" === e || "mins" === e || "minute" === e || "minutes" === e) {
+    return 6e4;
+  }
+  if ("h" === e || "hr" === e || "hrs" === e || "hour" === e || "hours" === e) {
+    return 36e5;
+  }
+  throw new Error(`Invalid duration unit: ${e}`);
+}
+
+function runCleanCli(e = []) {
+  const t = function parseJsonFlag(e) {
+    return d({
+      args: e,
+      allowPositionals: !0,
+      options: {
+        json: {
+          type: "boolean"
+        },
+        help: {
+          type: "boolean",
+          short: "h"
+        }
+      }
+    }).values;
+  }(e);
+  if (t.json) {
+    r();
+  }
+  const n = i();
+  process.stdout.write(t.json ? `${JSON.stringify({
+    removed: n
+  })}\n` : `Removed ${n} stale sessions.\n`);
+}
+
+const b = [ ":started", ":done", ":failed" ];
+
+async function convertToChromeTrace(e, t = {}) {
+  const n = new TraceConverter(t);
+  for await (const t of async function* toAsyncIterable$1(e) {
+    if (Symbol.asyncIterator in e) {
+      yield* e;
+    } else {
+      yield* e;
+    }
+  }(e)) {
+    n.add(t);
+  }
+  return n.toTraceFile();
+}
+
+class TraceConverter {
+  traceEvents=[];
+  #e=new Map;
+  #t=1;
+  #n;
+  #s;
+  #o="0.1.0";
+  constructor(e = {}) {
+    this.#n = e.pid ?? 1;
+    this.#s = e.processName ?? "event log";
+    this.traceEvents.push({
+      ph: "M",
+      name: "process_name",
+      pid: this.#n,
+      args: {
+        name: this.#s
+      }
+    });
+  }
+  add(e) {
+    if ("root:init" === e._e) {
+      if ("string" == typeof e.version) {
+        this.#o = e.version;
+      }
+      if ("event log" === this.#s && "string" == typeof e.version) {
+        this.#s = `event log (v${e.version})`;
+      }
+      this.traceEvents.push({
+        ph: "M",
+        name: "process_name",
+        pid: this.#n,
+        args: {
+          name: this.#s
+        }
+      });
+      return;
+    }
+    const t = function splitEventName$2(e) {
+      const t = e.indexOf(":");
+      if (t < 1) {
+        return null;
+      }
+      return {
+        category: e.slice(0, t),
+        name: e.slice(t + 1)
+      };
+    }(e._e);
+    if (!t) {
+      return;
+    }
+    const n = this.#r(t.category, "string" == typeof e._w ? e._w : void 0);
+    const s = function extractArgs$1(e) {
+      const t = {};
+      for (const n of Object.keys(e)) {
+        if ("_e" === n || "_t" === n || "_d" === n) {
+          continue;
+        }
+        t[n] = e[n];
+      }
+      return Object.keys(t).length ? t : void 0;
+    }(e);
+    if ("number" == typeof e._d) {
+      this.traceEvents.push({
+        ph: "X",
+        name: stripSuffix$2(t.name),
+        cat: t.category,
+        pid: this.#n,
+        tid: n,
+        ts: Math.round(1e3 * (e._t - e._d)),
+        dur: Math.round(1e3 * e._d),
+        args: s
+      });
+    } else {
+      this.traceEvents.push({
+        ph: "i",
+        name: stripSuffix$2(t.name),
+        cat: t.category,
+        pid: this.#n,
+        tid: n,
+        ts: Math.round(1e3 * e._t),
+        s: e._e.endsWith(":progress") ? "t" : "g",
+        args: s
+      });
+    }
+  }
+  toTraceFile() {
+    return {
+      traceEvents: this.traceEvents,
+      metadata: {
+        source: "expo-event-log",
+        version: this.#o,
+        convertedAt: (new Date).toISOString()
+      }
+    };
+  }
+  #r(e, t) {
+    const n = t ? `${e}:${t}` : e;
+    let s = this.#e.get(n);
+    if (null == s) {
+      s = this.#t++;
+      this.#e.set(n, s);
+      this.traceEvents.push({
+        ph: "M",
+        name: "thread_name",
+        pid: this.#n,
+        tid: s,
+        args: {
+          name: t ? `${e} ${t}` : e
+        }
+      });
+    }
+    return s;
+  }
+}
+
+function stripSuffix$2(e) {
+  for (const t of b) {
+    if (e.endsWith(t)) {
+      return e.slice(0, -t.length);
+    }
+  }
+  return e;
+}
+
+const S = [ ":started", ":done", ":failed" ];
+
+async function convertToOpenTelemetry(e, t = {}) {
+  const n = new OpenTelemetryConverter(t);
+  for await (const t of async function* toAsyncIterable(e) {
+    if (Symbol.asyncIterator in e) {
+      yield* e;
+    } else {
+      yield* e;
+    }
+  }(e)) {
+    n.add(t);
+  }
+  return n.toFile();
+}
+
+class OpenTelemetryConverter {
+  #i=m.randomBytes(16).toString("hex");
+  #a=createSpanId();
+  #c=[];
+  #l=[];
+  #s;
+  #o="0.1.0";
+  #p;
+  #u;
+  constructor(e) {
+    this.options = e;
+    this.#s = e.processName ?? "event log";
+  }
+  add(e) {
+    const t = unixNano(e._t);
+    this.#p = null == this.#p || BigInt(t) < BigInt(this.#p) ? t : this.#p;
+    this.#u = null == this.#u || BigInt(t) > BigInt(this.#u) ? t : this.#u;
+    if ("root:init" === e._e) {
+      if ("string" == typeof e.version) {
+        this.#o = e.version;
+      }
+      if ("event log" === this.#s && "string" == typeof e.version) {
+        this.#s = `event log (v${e.version})`;
+      }
+      return;
+    }
+    if ("number" == typeof e._d) {
+      this.#c.push(this.#f(e));
+    } else {
+      this.#l.push(this.#d(e));
+    }
+  }
+  toFile() {
+    const e = this.#p ?? unixNano(Date.now());
+    const t = this.#u ?? e;
+    return {
+      resourceSpans: [ {
+        resource: {
+          attributes: attributes({
+            "service.name": this.#s,
+            "service.version": this.#o,
+            "process.pid": this.options.pid,
+            "telemetry.sdk.name": "@expo/event-log",
+            "telemetry.sdk.language": "nodejs"
+          })
+        },
+        scopeSpans: [ {
+          scope: {
+            name: "@expo/event-log"
+          },
+          spans: [ {
+            traceId: this.#i,
+            spanId: this.#a,
+            name: this.#s,
+            startTimeUnixNano: e,
+            endTimeUnixNano: t,
+            attributes: attributes({
+              "event_log.kind": "session"
+            }),
+            events: this.#l.length ? this.#l : void 0
+          }, ...this.#c ]
+        } ]
+      } ]
+    };
+  }
+  #f(e) {
+    const t = splitEventName$1(e._e);
+    const n = unixNano(e._t - e._d);
+    const s = unixNano(e._t);
+    return {
+      traceId: this.#i,
+      spanId: createSpanId(),
+      parentSpanId: this.#a,
+      name: t ? stripSuffix$1(t.name) : e._e,
+      startTimeUnixNano: n,
+      endTimeUnixNano: s,
+      attributes: eventAttributes(e, t)
+    };
+  }
+  #d(e) {
+    const t = splitEventName$1(e._e);
+    return {
+      timeUnixNano: unixNano(e._t),
+      name: t ? stripSuffix$1(t.name) : e._e,
+      attributes: eventAttributes(e, t)
+    };
+  }
+}
+
+function eventAttributes(e, t) {
+  const n = {
+    "event.name": e._e
+  };
+  if (t) {
+    n["event.category"] = t.category;
+    n["event.action"] = t.name;
+  }
+  if ("string" == typeof e._w) {
+    n["event.worker.id"] = e._w;
+  }
+  for (const t of Object.keys(e)) {
+    if ("_e" === t || "_t" === t || "_d" === t || "_w" === t) {
+      continue;
+    }
+    n[`event_log.${t}`] = e[t];
+  }
+  return attributes(n);
+}
+
+function attributes(e) {
+  const t = [];
+  for (const [n, s] of Object.entries(e)) {
+    const e = anyValue(s);
+    if (e) {
+      t.push({
+        key: n,
+        value: e
+      });
+    }
+  }
+  return t;
+}
+
+function anyValue(e) {
+  if ("string" == typeof e) {
+    return {
+      stringValue: e
+    };
+  }
+  if ("boolean" == typeof e) {
+    return {
+      boolValue: e
+    };
+  }
+  if ("number" == typeof e) {
+    if (!Number.isFinite(e)) {
+      return null;
+    }
+    return Number.isInteger(e) ? {
+      intValue: String(e)
+    } : {
+      doubleValue: e
+    };
+  }
+  if (Array.isArray(e)) {
+    return {
+      arrayValue: {
+        values: e.flatMap(e => {
+          const t = anyValue(e);
+          return t ? [ t ] : [];
+        })
+      }
+    };
+  }
+  if (e && "object" == typeof e) {
+    return {
+      kvlistValue: {
+        values: attributes(e)
+      }
+    };
+  }
+  return null;
+}
+
+function createSpanId() {
+  return m.randomBytes(8).toString("hex");
+}
+
+function unixNano(e) {
+  return String(BigInt(Math.round(1e6 * e)));
+}
+
+function splitEventName$1(e) {
+  const t = e.indexOf(":");
+  if (t < 1) {
+    return null;
+  }
+  return {
+    category: e.slice(0, t),
+    name: e.slice(t + 1)
+  };
+}
+
+function stripSuffix$1(e) {
+  for (const t of S) {
+    if (e.endsWith(t)) {
+      return e.slice(0, -t.length);
+    }
+  }
+  return e;
+}
+
+async function runExportCli(e) {
+  if (parseHelp(e)) {
+    !function printExportHelp() {
+      process.stdout.write([ "Usage: event-log export [selector]", "", "Options:", "  selector                 Match by PID, command, or cwd", "  --input <file>          Read JSONL events from a file", "  -o, --output <file>      Write output to a file", "  --format <format>        chrome-trace or opentelemetry", "  --json                   Print JSON output", "  --since <time>           Duration, Unix time, or ISO date", "  --filter <pattern>       category[:kind], wildcards allowed", "  --tail                   Follow live events after replaying history", "  --timeout <duration>     Stop tailing after an absolute duration", "                           Tail also stops after 30s without new events", "" ].join("\n"));
+    }();
+    return;
+  }
+  const s = function parseExportOptions(e) {
+    const t = d({
+      args: e,
+      allowPositionals: !0,
+      options: {
+        ...w,
+        input: {
+          type: "string"
+        },
+        output: {
+          type: "string",
+          short: "o"
+        },
+        format: {
+          type: "string"
+        },
+        json: {
+          type: "boolean"
+        },
+        timeout: {
+          type: "string"
+        },
+        help: {
+          type: "boolean",
+          short: "h"
+        }
+      }
+    });
+    const n = parseSharedTapOptions(t.values);
+    const s = function parseDuration(e) {
+      if (null == e || "" === e) {
+        return;
+      }
+      const t = e.trim().toLowerCase();
+      if (!t) {
+        return;
+      }
+      let n = 0;
+      let s = 0;
+      const o = /(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?/gy;
+      while (s < t.length) {
+        o.lastIndex = s;
+        const r = o.exec(t);
+        if (!r) {
+          throw new Error(`Invalid duration: ${e}`);
+        }
+        const i = Number(r[1]);
+        if (!Number.isFinite(i)) {
+          throw new Error(`Invalid duration: ${e}`);
+        }
+        n += i * durationUnitToMs(r[2] ?? "ms");
+        s = o.lastIndex;
+        while (" " === t[s] || "," === t[s]) {
+          s++;
+        }
+      }
+      return n;
+    }(t.values.timeout);
+    const o = t.values.format ?? "chrome-trace";
+    if (!function isExportFormat(e) {
+      return "chrome-trace" === e || "opentelemetry" === e;
+    }(o)) {
+      throw new Error(`Unsupported format: ${o}`);
+    }
+    if (t.positionals[0] && t.values.input) {
+      throw new Error("Use either a session selector or --input, not both");
+    }
+    if (null != s && !n.follow) {
+      throw new Error("Use --timeout only with --tail");
+    }
+    return {
+      selector: t.positionals[0],
+      inputFile: t.values.input,
+      output: t.values.output,
+      format: o,
+      since: n.since,
+      filter: n.filter,
+      follow: n.follow,
+      timeout: s,
+      idleTimeout: 3e4,
+      json: t.values.json ?? !1
+    };
+  }(e);
+  if (s.json) {
+    r();
+  }
+  let o;
+  let i;
+  let l;
+  if (s.selector) {
+    const e = await a(s.selector);
+    i = function formatSessionProcessName(e) {
+      return e.version ? `${e.command} (v${e.version}, PID ${e.pid})` : `${e.command} (PID ${e.pid})`;
+    }(e);
+    l = e.pid;
+    o = c(e.sessionDir, {
+      follow: s.follow,
+      timeout: s.timeout,
+      idleTimeout: s.follow ? s.idleTimeout : void 0
+    });
+  } else if (s.inputFile) {
+    o = async function* readJsonlFile(e) {
+      yield* readJsonlStream(u.createReadStream(e, {
+        encoding: "utf8"
+      }));
+    }(s.inputFile);
+  } else {
+    o = async function* readJsonlStdin() {
+      yield* readJsonlStream(process.stdin);
+    }();
+  }
+  const p = async function* filterEvents(e, s) {
+    const o = t(s.filter);
+    const r = n(s.since);
+    for await (const t of e) {
+      if (matchesTapOptions(t, r, o)) {
+        yield t;
+      }
+    }
+  }(o, s);
+  const f = "opentelemetry" === s.format ? await convertToOpenTelemetry(p, {
+    pid: l,
+    processName: i
+  }) : await convertToChromeTrace(p, {
+    pid: l,
+    processName: i
+  });
+  const m = JSON.stringify(f, null, 2);
+  if (s.output) {
+    u.writeFileSync(s.output, `${m}\n`);
+  } else {
+    process.stdout.write(`${m}\n`);
+  }
+}
+
+function extractEventRegistry(e = {}) {
+  const t = e.project ?? function findTsconfig(e) {
+    let t = e;
+    while (1) {
+      const e = h.join(t, "tsconfig.json");
+      if (u.existsSync(e)) {
+        return e;
+      }
+      const n = h.dirname(t);
+      if (n === t) {
+        return null;
+      }
+      t = n;
+    }
+  }(process.cwd());
+  if (!t) {
+    throw new Error("Could not find tsconfig.json");
+  }
+  const n = g.readConfigFile(t, g.sys.readFile);
+  if (n.error) {
+    throw new Error(function formatDiagnostic(e) {
+      return g.flattenDiagnosticMessageText(e.messageText, "\n");
+    }(n.error));
+  }
+  const s = g.parseJsonConfigFileContent(n.config, g.sys, h.dirname(t));
+  const o = g.createProgram(s.fileNames, s.options);
+  const r = o.getTypeChecker();
+  const i = function findEventRegistry(e, t) {
+    const n = t.getAmbientModules().find(e => '"@expo/event-log"' === e.getName());
+    const s = n?.exports?.get("EventRegistry");
+    if (s) {
+      return t.getDeclaredTypeOfSymbol(s);
+    }
+    for (const n of e.getSourceFiles()) {
+      if (isEventLogEntrypoint(n.fileName)) {
+        const e = t.getSymbolAtLocation(n);
+        const s = e?.exports?.get("EventRegistry");
+        if (s) {
+          return t.getDeclaredTypeOfSymbol(s);
+        }
+      }
+    }
+    for (const n of e.getSourceFiles()) {
+      if (!/[\\/](@expo[\\/]event-log|event-log)[\\/]/.test(n.fileName)) {
+        continue;
+      }
+      let e;
+      n.forEachChild(function visit(t) {
+        if (g.isInterfaceDeclaration(t) && "EventRegistry" === t.name.text) {
+          e = t;
+        }
+        t.forEachChild(visit);
+      });
+      if (e) {
+        const n = t.getSymbolAtLocation(e.name);
+        if (n) {
+          return t.getDeclaredTypeOfSymbol(n);
+        }
+      }
+    }
+    return null;
+  }(o, r);
+  if (!i) {
+    throw new Error("Could not resolve EventRegistry");
+  }
+  const a = i.getProperties().map(e => function serializeRegistryEntry(e, t) {
+    const n = e.getName().replace(/^"|"$/g, "");
+    const s = e.valueDeclaration ?? e.declarations?.[0];
+    const o = s ? t.getTypeOfSymbolAtLocation(e, s) : void 0;
+    const r = {};
+    const i = [];
+    for (const e of o?.getProperties() ?? []) {
+      const n = e.valueDeclaration ?? e.declarations?.[0];
+      if (!n) {
+        continue;
+      }
+      if (0 !== (e.flags & g.SymbolFlags.Optional)) {
+        i.push(e.getName());
+      }
+      r[e.getName()] = t.typeToString(t.getTypeOfSymbolAtLocation(e, n));
+    }
+    const a = n.indexOf(":");
+    return {
+      key: n,
+      category: a > -1 ? n.slice(0, a) : "",
+      name: a > -1 ? n.slice(a + 1) : n,
+      fields: r,
+      optionalFields: i
+    };
+  }(e, r)).sort((e, t) => e.key.localeCompare(t.key));
+  return "json" === e.format ? JSON.stringify(a, null, 2) : function formatDts(e) {
+    const t = [ "// Auto-generated by @expo/event-log extract", "// Do not edit manually.", "", "declare module '@expo/event-log' {", "  interface EventRegistry {" ];
+    for (const n of e) {
+      t.push(`    '${n.key}': {`);
+      for (const [e, s] of Object.entries(n.fields)) {
+        const o = n.optionalFields.includes(e) ? "?" : "";
+        t.push(`      ${e}${o}: ${s};`);
+      }
+      t.push("    };");
+    }
+    t.push("  }", "}");
+    return t.join("\n");
+  }(a);
+}
+
+function runExtractCli(e) {
+  if (parseHelp(e)) {
+    !function printExtractHelp() {
+      process.stdout.write([ "Usage: event-log extract", "", "Options:", "  -p, --project <file>     tsconfig.json path", "  -o, --output <file>      Write output to a file", "  --format <format>        dts or json", "  --json                   Print JSON schema", "" ].join("\n"));
+    }();
+    return;
+  }
+  const t = d({
+    args: e,
+    options: {
+      format: {
+        type: "string"
+      },
+      json: {
+        type: "boolean"
+      },
+      output: {
+        type: "string",
+        short: "o"
+      },
+      project: {
+        type: "string",
+        short: "p"
+      },
+      help: {
+        type: "boolean",
+        short: "h"
+      }
+    }
+  });
+  if (t.values.json && "dts" === t.values.format) {
+    throw new Error("Use either --json or --format dts, not both");
+  }
+  if (t.values.json) {
+    r();
+  }
+  const n = t.values.json ? "json" : t.values.format ?? "dts";
+  if ("dts" !== n && "json" !== n) {
+    throw new Error(`Unsupported format: ${n}`);
+  }
+  const s = {
+    format: n,
+    output: t.values.output,
+    project: t.values.project
+  };
+  const o = extractEventRegistry(s);
+  if (s.output) {
+    u.writeFileSync(s.output, `${o}\n`);
+  } else {
+    process.stdout.write(`${o}\n`);
+  }
+}
+
+function isEventLogEntrypoint(e) {
+  return /(?:^|[\\/])(?:src[\\/]index\.ts|dist[\\/]event-log\.d\.ts)$/.test(e);
+}
+
+const T = [ ":started", ":done", ":failed" ];
+
+class InspectTrace {
+  events=[];
+  #e=new Map;
+  #t=1;
+  #n;
+  #s;
+  constructor(e) {
+    this.#n = e.pid ?? 1;
+    this.#s = e.processName;
+    this.#m({
+      ph: "M",
+      name: "process_name",
+      pid: this.#n,
+      args: {
+        name: this.#s
+      }
+    });
+  }
+  add(e) {
+    const t = this.events.length;
+    if ("root:init" === e._e) {
+      this.#m({
+        ph: "M",
+        name: "process_name",
+        pid: this.#n,
+        args: {
+          name: this.#s
+        }
+      });
+      return this.events.slice(t);
+    }
+    const n = function splitEventName(e) {
+      const t = e.indexOf(":");
+      if (t < 1) {
+        return null;
+      }
+      return {
+        category: e.slice(0, t),
+        name: e.slice(t + 1)
+      };
+    }(e._e);
+    if (!n) {
+      return [];
+    }
+    const s = this.#r(n.category, "string" == typeof e._w ? e._w : void 0);
+    const o = function extractArgs(e) {
+      const t = {};
+      for (const n of Object.keys(e)) {
+        if ("_e" === n || "_t" === n || "_d" === n) {
+          continue;
+        }
+        t[n] = e[n];
+      }
+      return Object.keys(t).length ? t : void 0;
+    }(e);
+    if ("number" == typeof e._d) {
+      this.#m({
+        ph: "X",
+        name: stripSuffix(n.name),
+        cat: n.category,
+        pid: this.#n,
+        tid: s,
+        ts: Math.round(1e3 * (e._t - e._d)),
+        dur: Math.round(1e3 * e._d),
+        args: o
+      });
+    } else {
+      this.#m({
+        ph: "i",
+        name: stripSuffix(n.name),
+        cat: n.category,
+        pid: this.#n,
+        tid: s,
+        ts: Math.round(1e3 * e._t),
+        s: e._e.endsWith(":progress") ? "t" : "g",
+        args: o
+      });
+    }
+    return this.events.slice(t);
+  }
+  #r(e, t) {
+    const n = t ? `${e}:${t}` : e;
+    let s = this.#e.get(n);
+    if (null == s) {
+      s = this.#t++;
+      this.#e.set(n, s);
+      this.#m({
+        ph: "M",
+        name: "thread_name",
+        pid: this.#n,
+        tid: s,
+        args: {
+          name: t ? `${e} ${t}` : e
+        }
+      });
+    }
+    return s;
+  }
+  #m(e) {
+    this.events.push(e);
+  }
+}
+
+function stripSuffix(e) {
+  for (const t of T) {
+    if (e.endsWith(t)) {
+      return e.slice(0, -t.length);
+    }
+  }
+  return e;
+}
+
+function runInspectCli(e) {
+  if (parseHelp(function argsBeforeSeparator(e) {
+    const t = e.indexOf("--");
+    return t >= 0 ? e.slice(0, t) : e;
+  }(e))) {
+    !function printInspectHelp() {
+      process.stdout.write([ "Usage: event-log inspect [options] -- <command> [args...]", "", "Options:", "  --port <port>           Inspector port, defaults to 9229", "  --host <host>           Inspector host, defaults to 127.0.0.1", "  --wait                  Wait for a DevTools client before spawning", "  --linger <seconds>      Keep inspector open after child exits", "  --no-banner             Do not print inspector connection info", "" ].join("\n"));
+    }();
+    return Promise.resolve(0);
+  }
+  return async function runInspectSidecar(e) {
+    const t = e.port ?? 9229;
+    const n = e.host ?? "127.0.0.1";
+    const s = e.linger ?? 5;
+    const o = new InspectTrace({
+      processName: e.command
+    });
+    const r = await CdpTraceServer.listen({
+      host: n,
+      port: t,
+      command: e.command
+    });
+    if (!1 !== e.banner) {
+      process.stderr.write(`Debugger listening on ${r.url}\nOpen chrome://inspect to connect.\n`);
+    }
+    if (e.wait) {
+      await r.waitForClient();
+    }
+    const i = function spawnInspectedProcess(e, t) {
+      const n = v(e, t, {
+        stdio: [ "inherit", "inherit", "inherit", "pipe" ],
+        env: {
+          ...process.env,
+          [l]: "3"
+        }
+      });
+      return {
+        process: n,
+        eventStream: n.stdio[3]
+      };
+    }(e.command, e.args);
+    const forward = e => i.process.kill(e);
+    process.once("SIGINT", () => forward("SIGINT"));
+    process.once("SIGTERM", () => forward("SIGTERM"));
+    process.once("SIGHUP", () => forward("SIGHUP"));
+    const a = function readEvents(e, t) {
+      const n = f({
+        input: e
+      });
+      n.on("line", e => {
+        try {
+          t(JSON.parse(e));
+        } catch {}
+      });
+      return new Promise(e => n.on("close", e));
+    }(i.eventStream, e => {
+      r.add(o.add(e));
+    });
+    const c = await function waitForChild(e) {
+      return new Promise(t => {
+        e.on("exit", (e, n) => {
+          if ("number" == typeof e) {
+            t(e);
+          } else {
+            t(n ? 128 : 1);
+          }
+        });
+      });
+    }(i.process);
+    await a;
+    r.add(o.events);
+    if (s > 0) {
+      await new Promise(e => setTimeout(e, 1e3 * s));
+    }
+    await r.close();
+    return c;
+  }(function parseInspectOptions(e) {
+    const t = e.indexOf("--");
+    const n = t >= 0 ? e.slice(0, t) : [];
+    const s = t >= 0 ? e.slice(t + 1) : e;
+    const o = d({
+      args: n,
+      options: {
+        port: {
+          type: "string"
+        },
+        host: {
+          type: "string"
+        },
+        wait: {
+          type: "boolean"
+        },
+        linger: {
+          type: "string"
+        },
+        help: {
+          type: "boolean",
+          short: "h"
+        },
+        "no-banner": {
+          type: "boolean"
+        }
+      }
+    });
+    if (!s.length) {
+      throw new Error("inspect requires -- <command> [args...]");
+    }
+    return {
+      port: parsePort(o.values.port) ?? 9229,
+      host: o.values.host ?? "127.0.0.1",
+      wait: o.values.wait ?? !1,
+      linger: parseNonNegativeNumber(o.values.linger, "linger") ?? 5,
+      banner: o.values["no-banner"] ? !1 : !0,
+      command: s[0],
+      args: s.slice(1)
+    };
+  }(e));
+}
+
+class CdpTraceServer {
+  id=m.randomUUID();
+  #h;
+  #g=new Set;
+  #v=new Map;
+  #y=[];
+  #w=[];
+  #b=!1;
+  constructor(e, t, n, s) {
+    this.host = t;
+    this.port = n;
+    this.command = s;
+    this.#h = e;
+  }
+  static listen(e) {
+    const t = y.createServer();
+    const n = new CdpTraceServer(t, e.host, e.port, e.command);
+    t.on("request", (e, t) => n.#S(e, t));
+    t.on("upgrade", (e, t) => n.#T(e, t));
+    return new Promise((s, o) => {
+      t.once("error", o);
+      t.listen(e.port, e.host, () => {
+        t.off("error", o);
+        const e = t.address();
+        if (e && "object" == typeof e) {
+          n.port = e.port;
+        }
+        s(n);
+      });
+    });
+  }
+  get url() {
+    return `ws://${this.host}:${this.port}/${this.id}`;
+  }
+  add(e) {
+    if (!e.length) {
+      return;
+    }
+    if (!this.#b || !this.#g.size) {
+      this.#y.push(...e);
+      if (this.#y.length > 1e4) {
+        this.#y.splice(0, this.#y.length - 1e4);
+      }
+      return;
+    }
+    this.#N("Tracing.dataCollected", {
+      value: e
+    });
+  }
+  waitForClient() {
+    if (this.#g.size) {
+      return Promise.resolve();
+    }
+    return new Promise(e => this.#w.push(e));
+  }
+  close() {
+    for (const e of this.#g) {
+      e.destroy();
+    }
+    return new Promise(e => this.#h.close(() => e()));
+  }
+  #S(e, t) {
+    const n = {
+      id: this.id,
+      type: "node",
+      title: this.command,
+      description: "@expo/event-log inspect",
+      webSocketDebuggerUrl: this.url,
+      devtoolsFrontendUrl: `/devtools/inspector.html?ws=${this.host}:${this.port}/${this.id}`
+    };
+    t.setHeader("content-type", "application/json");
+    t.end(JSON.stringify([ n ]));
+  }
+  #T(e, t) {
+    const n = e.headers["sec-websocket-key"];
+    if ("string" != typeof n) {
+      t.destroy();
+      return;
+    }
+    const s = m.createHash("sha1").update(`${n}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
+    t.write([ "HTTP/1.1 101 Switching Protocols", "Upgrade: websocket", "Connection: Upgrade", `Sec-WebSocket-Accept: ${s}`, "", "" ].join("\r\n"));
+    this.#g.add(t);
+    for (const e of this.#w.splice(0)) {
+      e();
+    }
+    t.on("data", e => this.#x(t, Buffer.from(e)));
+    t.on("close", () => {
+      this.#g.delete(t);
+      this.#v.delete(t);
+    });
+    t.on("error", () => {
+      this.#g.delete(t);
+      this.#v.delete(t);
+    });
+  }
+  #x(e, t) {
+    const n = this.#v.get(e);
+    const s = n ? Buffer.concat([ n, t ]) : t;
+    let o = 0;
+    while (o < s.length) {
+      const t = readFrame(s, o);
+      if (!t) {
+        this.#v.set(e, s.subarray(o));
+        return;
+      }
+      o = t.nextOffset;
+      if (8 === t.opcode) {
+        e.end();
+      } else if (1 === t.opcode) {
+        this.#E(e, t.payload.toString("utf8"));
+      }
+    }
+    this.#v.delete(e);
+  }
+  #E(e, t) {
+    let n;
+    try {
+      n = JSON.parse(t);
+    } catch {
+      return;
+    }
+    if ("Tracing.start" === n.method) {
+      this.#b = !0;
+      this.#I(e, n.id);
+      if (this.#y.length) {
+        this.#N("Tracing.dataCollected", {
+          value: this.#y.splice(0)
+        });
+      }
+    } else if ("Tracing.end" === n.method) {
+      this.#b = !1;
+      this.#I(e, n.id);
+      this.#N("Tracing.tracingComplete", {});
+    } else {
+      this.#I(e, n.id);
+    }
+  }
+  #I(e, t) {
+    if (null != t) {
+      writeFrame(e, JSON.stringify({
+        id: t,
+        result: {}
+      }));
+    }
+  }
+  #N(e, t) {
+    const n = JSON.stringify({
+      method: e,
+      params: t
+    });
+    for (const e of this.#g) {
+      writeFrame(e, n);
+    }
+  }
+}
+
+function readFrame(e, t) {
+  if (t + 2 > e.length) {
+    return null;
+  }
+  const n = e[t + 1];
+  const s = 15 & e[t];
+  const o = !!(128 & n);
+  let r = 127 & n;
+  let i = t + 2;
+  if (126 === r) {
+    if (i + 2 > e.length) {
+      return null;
+    }
+    r = e.readUInt16BE(i);
+    i += 2;
+  } else if (127 === r) {
+    if (i + 8 > e.length) {
+      return null;
+    }
+    const t = e.readBigUInt64BE(i);
+    if (t > BigInt(Number.MAX_SAFE_INTEGER)) {
+      return null;
+    }
+    r = Number(t);
+    i += 8;
+  }
+  const a = i;
+  if (o) {
+    i += 4;
+  }
+  if (i + r > e.length) {
+    return null;
+  }
+  const c = Buffer.from(e.subarray(i, i + r));
+  if (o) {
+    const t = e.subarray(a, a + 4);
+    for (let e = 0; e < c.length; e++) {
+      c[e] ^= t[e % 4];
+    }
+  }
+  return {
+    opcode: s,
+    payload: c,
+    nextOffset: i + r
+  };
+}
+
+function writeFrame(e, t) {
+  const n = Buffer.from(t);
+  let s;
+  if (n.length < 126) {
+    s = Buffer.from([ 129, n.length ]);
+  } else if (n.length < 65536) {
+    s = Buffer.allocUnsafe(4);
+    s[0] = 129;
+    s[1] = 126;
+    s.writeUInt16BE(n.length, 2);
+  } else {
+    s = Buffer.allocUnsafe(10);
+    s[0] = 129;
+    s[1] = 127;
+    s.writeBigUInt64BE(BigInt(n.length), 2);
+  }
+  e.write(Buffer.concat([ s, n ]));
+}
+
+function escapeTsv(e) {
+  return String(e).replace(/\\/g, "\\\\").replace(/\t/g, "\\t").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+
+async function runTapCli(e) {
+  if (parseHelp(e)) {
+    !function printTapHelp() {
+      process.stdout.write([ "Usage: event-log tap [selector]", "", "Options:", "  selector                 Match by PID, command, or cwd", "  --since <time>           Duration, Unix time, or ISO date", "  --filter <pattern>       category[:kind], wildcards allowed", "  --format pretty          Print a readable line per event", "  --tail                   Follow live events after replaying history", "" ].join("\n"));
+    }();
+    return;
+  }
+  const t = function parseTapOptions(e) {
+    const t = d({
+      args: e,
+      allowPositionals: !0,
+      options: {
+        ...w,
+        format: {
+          type: "string"
+        },
+        json: {
+          type: "boolean"
+        },
+        help: {
+          type: "boolean",
+          short: "h"
+        }
+      }
+    });
+    const n = parseSharedTapOptions(t.values);
+    if (t.values.json && "pretty" === t.values.format) {
+      throw new Error("Use either --json or --format pretty, not both");
+    }
+    return {
+      selector: t.positionals[0],
+      since: n.since,
+      follow: n.follow,
+      filter: n.filter,
+      json: t.values.json ?? !1,
+      pretty: t.values.json ? !1 : "pretty" === t.values.format
+    };
+  }(e);
+  if (t.json) {
+    r();
+  }
+  const n = await a(t.selector);
+  for await (const e of c(n.sessionDir, t)) {
+    if (t.pretty) {
+      process.stdout.write(`${new Date(e._t).toISOString()} ${e._e} ${JSON.stringify(e)}\n`);
+    } else {
+      process.stdout.write(`${JSON.stringify(e)}\n`);
+    }
+  }
+}
+
+async function main(e = process.argv.slice(2)) {
+  const [t, ...n] = e;
+  if (!t || "--help" === t || "-h" === t) {
+    !function printHelp() {
+      process.stdout.write([ "Usage: event-log <command>", "", "Commands:", "  ps [selector]                 List sessions; selector matches PID, command, or cwd", "    --json", "", "  tap [selector]                Replay session events as JSONL", "    --since <time> --filter <category[:kind]> --tail --format pretty", "", "  export [selector]             Export events to Chrome Trace or OTLP JSON", "    --input <file> -o <file> --format <format> --filter <category[:kind]> --tail", "", "  inspect [options] -- <cmd>    Run a command with inspector sidecar", "    --port <port> --host <host> --wait --linger <seconds> --no-banner", "", "  extract                       Extract merged EventRegistry schema", "    --project <file> --output <file> --format dts|json --json", "", "  clean                         Remove stale sessions", "    --json", "", "Run event-log <command> --help for full command help.", "" ].join("\n"));
+    }();
+    return 0;
+  }
+  switch (t) {
+   case "extract":
+    runExtractCli(n);
+    return 0;
+
+   case "ps":
+    if (parseHelp(n)) {
+      !function printPsHelp() {
+        process.stdout.write([ "Usage: event-log ps [selector]", "", "Options:", "  selector                Match by PID, command, or cwd", "  --json                  Print sessions as JSON", "" ].join("\n"));
+      }();
+      return 0;
+    }
+    await async function runPsCli(e = []) {
+      const t = d({
+        args: e,
+        allowPositionals: !0,
+        options: {
+          json: {
+            type: "boolean"
+          },
+          help: {
+            type: "boolean",
+            short: "h"
+          }
+        }
+      });
+      if (t.values.json) {
+        r();
+      }
+      const n = await p({
+        selector: t.positionals[0]
+      });
+      if (t.values.json) {
+        process.stdout.write(`${JSON.stringify(n, null, 2)}\n`);
+        return;
+      }
+      process.stdout.write("PID\tSTATUS\tSTARTED\tCOMMAND\tCWD\n");
+      for (const e of n) {
+        process.stdout.write(`${escapeTsv(e.pid)}\t${escapeTsv(e.alive ? "alive" : "exited")}\t${escapeTsv(new Date(e.startedAt).toISOString())}\t${escapeTsv(e.command)}\t${escapeTsv(e.cwd)}\n`);
+      }
+    }(n);
+    return 0;
+
+   case "tap":
+    await runTapCli(n);
+    return 0;
+
+   case "clean":
+    if (parseHelp(n)) {
+      !function printCleanHelp() {
+        process.stdout.write([ "Usage: event-log clean", "", "Options:", "  --json", "" ].join("\n"));
+      }();
+      return 0;
+    }
+    runCleanCli(n);
+    return 0;
+
+   case "export":
+    await runExportCli(n);
+    return 0;
+
+   case "inspect":
+    return runInspectCli(n);
+
+   default:
+    throw new Error(`Unknown command: ${t}`);
+  }
+}
+
+if (function isCliEntrypoint() {
+  try {
+    return process.argv[1] === e(import.meta.url);
+  } catch {
+    return !1;
+  }
+}()) {
+  main().then(e => {
+    process.exitCode = e;
+  }).catch(e => {
+    process.stderr.write(`${e instanceof Error ? e.message : String(e)}\n`);
+    process.exitCode = 1;
+  });
+}
+
+export { main };
+//# sourceMappingURL=expo-event-log-cli.mjs.map