@spotlightjs/spotlight 4.5.0 → 4.6.0

package/dist/server/parser/types.d.ts

@@ -0,0 +1,198 @@
+import { EventEnvelopeHeaders, Measurements, SerializedLog } from '@sentry/core';
+export type RawEventContext = {
+    /**
+     * The content-type header of the event
+     */
+    contentType: string;
+    /**
+     * The raw data in string form of the request.
+     * Use this function to parse and process the raw data it to whatever data structure
+     * you expect for the given `contentType`.
+     *
+     * Return the processed object or undefined if the event should be ignored.
+     */
+    data: string | Uint8Array;
+};
+export type TraceId = string;
+export type SpanId = string;
+export type FrameVars = {
+    [key: string]: string;
+};
+export type EventFrame = {
+    filename?: string;
+    abs_path?: string;
+    function?: string;
+    module?: string;
+    lineno?: number;
+    colno?: number;
+    pre_context?: string[];
+    post_context?: string[];
+    context_line?: string;
+    vars?: FrameVars;
+    instruction_addr?: string;
+    in_app?: boolean;
+};
+export type EventStacktrace = {
+    frames: EventFrame[];
+};
+export type EventExceptionValue = {
+    type: string;
+    value: string;
+    stacktrace?: EventStacktrace;
+};
+export type EventException = {
+    values: EventExceptionValue[];
+    value: undefined;
+} | {
+    values: undefined;
+    value: EventExceptionValue;
+};
+export type Breadcrumb = {
+    data?: Record<string, unknown>;
+    message?: string;
+    category: string;
+    timestamp: string;
+    type: string | "default";
+};
+export type Context = Record<string, string | number>;
+export type Sdk = {
+    name: string;
+    version: string;
+    lastSeen: number;
+};
+type CommonEventAttrs = {
+    event_id: string;
+    timestamp: number;
+    message?: SentryFormattedMessage;
+    breadcrumbs?: Breadcrumb[] | {
+        values: Breadcrumb[];
+    };
+    transaction?: string;
+    environment?: string;
+    platform?: string;
+    server_name?: string;
+    release?: string;
+    start_timestamp?: number;
+    contexts?: Contexts;
+    tags?: Tags;
+    extra?: Context;
+    request?: Record<string, Record<string, string> | string>;
+    modules?: Record<string, string>;
+    sdk?: Sdk;
+    measurements?: Measurements;
+};
+export type TraceContext = EventEnvelopeHeaders["trace"] & {
+    span_id?: string;
+    status?: "ok" | string;
+    description?: string;
+    parent_span_id?: string;
+    data?: Record<string, string>;
+    op?: string;
+};
+export type Contexts = {
+    trace?: TraceContext;
+} & {
+    [key: string]: Context;
+};
+export type Tags = {
+    [key: string]: string;
+};
+export type SentryFormattedMessage = string | {
+    formatted: string;
+    params?: [];
+};
+export type SentryErrorEvent = CommonEventAttrs & {
+    type?: "error" | "event" | "message" | "default";
+    exception?: EventException;
+};
+export type Span = {
+    trace_id?: TraceId;
+    span_id: SpanId;
+    parent_span_id?: string | null;
+    op?: string | null;
+    description?: string | null;
+    start_timestamp: number;
+    tags?: Tags | null;
+    timestamp: number;
+    status?: "ok" | string;
+    transaction?: SentryTransactionEvent;
+    children?: Span[];
+    data?: Record<string, unknown>;
+};
+export type SentryTransactionEvent = CommonEventAttrs & {
+    type: "transaction";
+    spans?: Span[];
+    start_timestamp: string;
+    contexts: Contexts & {
+        trace: TraceContext;
+    };
+};
+export type ProfileSample = {
+    elapsed_since_start_ns: string;
+    stack_id: number;
+    thread_id: string;
+};
+export type ProcessedProfileSample = {
+    start_timestamp: number;
+    stack_id: number;
+    thread_id: string;
+};
+export type SentryProfile = {
+    samples: ProfileSample[];
+    stacks: number[][];
+    frames: EventFrame[];
+    platform?: string;
+    thread_metadata?: Record<string, {
+        name?: string;
+        priority?: number;
+    }>;
+};
+export type SentryProcessedProfile = SentryProfile & {
+    samples: ProcessedProfileSample[];
+};
+export type AggregateCallData = {
+    name: string;
+    totalTime: number;
+    samples: number;
+    traceIds: Set<TraceId>;
+};
+export type SentryDeviceInfo = {
+    architecture: string;
+    is_emulator?: boolean;
+    locale?: string;
+    manufacturer?: string;
+    model?: string;
+};
+export type SentryOSInfo = {
+    name: string;
+    version: string;
+    build_number?: string;
+};
+export type SentryProfileTransactionInfo = {
+    name: string;
+    id: string;
+    trace_id: string;
+    active_thread_id: string;
+    relative_start_ns?: string;
+    relative_end_ns?: string;
+};
+export type SentryProfileV1Event = CommonEventAttrs & {
+    type: "profile";
+    device: SentryDeviceInfo;
+    os: SentryOSInfo;
+    transactions?: Array<SentryProfileTransactionInfo>;
+    transaction?: SentryProfileTransactionInfo;
+    version: "1";
+    profile: SentryProfile;
+};
+export type SentryLogEventItem = SerializedLog & {
+    id: string;
+    severity_number: number;
+    sdk: string | undefined;
+};
+export type SentryLogEvent = CommonEventAttrs & {
+    type: "log";
+    items: Array<SentryLogEventItem>;
+};
+export type SentryEvent = SentryErrorEvent | SentryTransactionEvent | SentryProfileV1Event | SentryLogEvent;
+export {};

package/dist/server/routes/clear.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const router: Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+export default router;

package/dist/server/routes/clear.js

@@ -0,0 +1,15 @@
+import { Hono } from "hono";
+import { getBuffer } from "../utils/getBuffer.js";
+import "../parser/helpers.js";
+import "uuidv7";
+import "node:http";
+import "@sentry/node";
+const router = new Hono();
+router.delete("/", (ctx) => {
+  getBuffer().clear();
+  return ctx.text("Cleared");
+});
+export {
+  router as default
+};
+//# sourceMappingURL=clear.js.map

package/dist/server/routes/clear.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear.js","sources":["../../../src/server/routes/clear.ts"],"sourcesContent":["import { Hono } from \"hono\";\nimport { getBuffer } from \"../utils/index.ts\";\n\nconst router = new Hono();\n\nrouter.delete(\"/\", ctx => {\n  getBuffer().clear();\n  return ctx.text(\"Cleared\");\n});\n\nexport default router;\n"],"names":[],"mappings":";;;;;;AAGA,MAAM,SAAS,IAAI,KAAA;AAEnB,OAAO,OAAO,KAAK,CAAA,QAAO;AACxB,YAAA,EAAY,MAAA;AACZ,SAAO,IAAI,KAAK,SAAS;AAC3B,CAAC;"}

package/dist/server/routes/contextlines/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const router: Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+export default router;

package/dist/server/routes/contextlines/index.js

@@ -0,0 +1,44 @@
+import { readFileSync } from "node:fs";
+import { Hono } from "hono";
+import { parseStackTrace, isValidSentryStackFrame, getGeneratedCodeFromServer, applySourceContextToFrame, addContextLinesToFrame } from "./utils.js";
+const router = new Hono();
+router.put("/", async (ctx) => {
+  const requestBody = await ctx.req.text();
+  const stacktrace = parseStackTrace(requestBody);
+  if (!stacktrace) {
+    return ctx.body(null, 500);
+  }
+  for (const frame of stacktrace.frames ?? []) {
+    if (!isValidSentryStackFrame(frame) || // let's ignore dependencies for now with this naive check
+    frame.filename.includes("/node_modules/")) {
+      continue;
+    }
+    const { filename } = frame;
+    if (filename.includes("://")) {
+      const generatedCode = await getGeneratedCodeFromServer(frame.filename);
+      if (!generatedCode) {
+        continue;
+      }
+      const inlineSourceMapMatch = generatedCode.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.*)/);
+      if (inlineSourceMapMatch?.[1]) {
+        const sourceMapBase64 = inlineSourceMapMatch[1];
+        const sourceMapContent = Buffer.from(sourceMapBase64, "base64").toString("utf-8");
+        applySourceContextToFrame(sourceMapContent, frame);
+      }
+    } else if (!filename.includes(":")) {
+      try {
+        const lines = readFileSync(filename, { encoding: "utf-8" }).split(/\r?\n/);
+        addContextLinesToFrame(lines, frame);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+    }
+  }
+  return ctx.json(stacktrace);
+});
+export {
+  router as default
+};
+//# sourceMappingURL=index.js.map

package/dist/server/routes/contextlines/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/server/routes/contextlines/index.ts"],"sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { Hono } from \"hono\";\nimport {\n  addContextLinesToFrame,\n  applySourceContextToFrame,\n  getGeneratedCodeFromServer,\n  isValidSentryStackFrame,\n  parseStackTrace,\n} from \"./utils.ts\";\n\nconst router = new Hono();\n\nrouter.put(\"/\", async ctx => {\n  const requestBody = await ctx.req.text();\n\n  const stacktrace = parseStackTrace(requestBody);\n\n  if (!stacktrace) {\n    return ctx.body(null, 500);\n  }\n\n  for (const frame of stacktrace.frames ?? []) {\n    if (\n      !isValidSentryStackFrame(frame) ||\n      // let's ignore dependencies for now with this naive check\n      frame.filename.includes(\"/node_modules/\")\n    ) {\n      continue;\n    }\n    const { filename } = frame;\n    // Dirty check to see if this looks like a regular file path or a URL\n    if (filename.includes(\"://\")) {\n      const generatedCode = await getGeneratedCodeFromServer(frame.filename);\n      if (!generatedCode) {\n        continue;\n      }\n\n      // Extract the inline source map from the minified code\n      const inlineSourceMapMatch = generatedCode.match(/\\/\\/# sourceMappingURL=data:application\\/json;base64,(.*)/);\n\n      if (inlineSourceMapMatch?.[1]) {\n        const sourceMapBase64 = inlineSourceMapMatch[1];\n        const sourceMapContent = Buffer.from(sourceMapBase64, \"base64\").toString(\"utf-8\");\n        applySourceContextToFrame(sourceMapContent, frame);\n      }\n    } else if (!filename.includes(\":\")) {\n      try {\n        const lines = readFileSync(filename, { encoding: \"utf-8\" }).split(/\\r?\\n/);\n        addContextLinesToFrame(lines, frame);\n      } catch (err) {\n        if ((err as NodeJS.ErrnoException).code !== \"ENOENT\") {\n          throw err;\n        }\n      }\n    }\n  }\n\n  return ctx.json(stacktrace);\n});\n\nexport default router;\n"],"names":[],"mappings":";;;AAUA,MAAM,SAAS,IAAI,KAAA;AAEnB,OAAO,IAAI,KAAK,OAAM,QAAO;AAC3B,QAAM,cAAc,MAAM,IAAI,IAAI,KAAA;AAElC,QAAM,aAAa,gBAAgB,WAAW;AAE9C,MAAI,CAAC,YAAY;AACf,WAAO,IAAI,KAAK,MAAM,GAAG;AAAA,EAC3B;AAEA,aAAW,SAAS,WAAW,UAAU,CAAA,GAAI;AAC3C,QACE,CAAC,wBAAwB,KAAK;AAAA,IAE9B,MAAM,SAAS,SAAS,gBAAgB,GACxC;AACA;AAAA,IACF;AACA,UAAM,EAAE,aAAa;AAErB,QAAI,SAAS,SAAS,KAAK,GAAG;AAC5B,YAAM,gBAAgB,MAAM,2BAA2B,MAAM,QAAQ;AACrE,UAAI,CAAC,eAAe;AAClB;AAAA,MACF;AAGA,YAAM,uBAAuB,cAAc,MAAM,2DAA2D;AAE5G,UAAI,uBAAuB,CAAC,GAAG;AAC7B,cAAM,kBAAkB,qBAAqB,CAAC;AAC9C,cAAM,mBAAmB,OAAO,KAAK,iBAAiB,QAAQ,EAAE,SAAS,OAAO;AAChF,kCAA0B,kBAAkB,KAAK;AAAA,MACnD;AAAA,IACF,WAAW,CAAC,SAAS,SAAS,GAAG,GAAG;AAClC,UAAI;AACF,cAAM,QAAQ,aAAa,UAAU,EAAE,UAAU,QAAA,CAAS,EAAE,MAAM,OAAO;AACzE,+BAAuB,OAAO,KAAK;AAAA,MACrC,SAAS,KAAK;AACZ,YAAK,IAA8B,SAAS,UAAU;AACpD,gBAAM;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,IAAI,KAAK,UAAU;AAC5B,CAAC;"}

package/dist/server/routes/contextlines/utils.d.ts

@@ -0,0 +1,20 @@
+type SourceContext = {
+    pre_context?: string[];
+    context_line?: string;
+    post_context?: string[];
+};
+type SentryStackFrame = {
+    filename?: string;
+    lineno?: number;
+    colno?: number;
+} & SourceContext;
+type ValidSentryStackFrame = Required<SentryStackFrame>;
+type SentryStackTrace = {
+    frames?: SentryStackFrame[];
+};
+export declare function getGeneratedCodeFromServer(filename: string): Promise<string | undefined>;
+export declare function parseStackTrace(requestBody: string): SentryStackTrace | undefined;
+export declare function applySourceContextToFrame(sourceMapContent: string, frame: ValidSentryStackFrame): import('@jridgewell/trace-mapping').OriginalMapping | import('@jridgewell/trace-mapping').InvalidOriginalMapping;
+export declare function addContextLinesToFrame(lines: string[], frame: ValidSentryStackFrame, linesOfContext?: number): void;
+export declare function isValidSentryStackFrame(frame: SentryStackFrame): frame is ValidSentryStackFrame;
+export {};

package/dist/server/routes/contextlines/utils.js

@@ -0,0 +1,83 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { TraceMap, originalPositionFor, LEAST_UPPER_BOUND, sourceContentFor } from "@jridgewell/trace-mapping";
+async function getGeneratedCodeFromServer(filename) {
+  try {
+    const generatedCodeResponse = await fetch(filename);
+    return generatedCodeResponse.text();
+  } catch {
+    return void 0;
+  }
+}
+function parseStackTrace(requestBody) {
+  try {
+    return JSON.parse(requestBody);
+  } catch {
+    return void 0;
+  }
+}
+function applySourceContextToFrame(sourceMapContent, frame) {
+  const tracer = new TraceMap(JSON.parse(sourceMapContent));
+  const originalPosition = originalPositionFor(tracer, {
+    line: frame.lineno,
+    column: frame.colno,
+    bias: LEAST_UPPER_BOUND
+  });
+  if (originalPosition.source && originalPosition.line && originalPosition.column) {
+    frame.lineno = originalPosition.line;
+    frame.colno = originalPosition.column;
+    const filePath = new URL(frame.filename).pathname.slice(1);
+    frame.filename = path.resolve(path.join(path.dirname(filePath), originalPosition.source));
+    const content = sourceContentFor(tracer, originalPosition.source);
+    const lines = content?.split(os.EOL) ?? [];
+    addContextLinesToFrame(lines, frame);
+  }
+  return originalPosition;
+}
+function addContextLinesToFrame(lines, frame, linesOfContext = 5) {
+  const maxLines = lines.length;
+  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);
+  frame.pre_context = lines.slice(Math.max(0, sourceLine - linesOfContext), sourceLine).map((line) => snipLine(line, 0));
+  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);
+  frame.post_context = lines.slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext).map((line) => snipLine(line, 0));
+}
+function snipLine(line, colno) {
+  let newLine = line;
+  const lineLength = newLine.length;
+  if (lineLength <= 150) {
+    return newLine;
+  }
+  if (colno > lineLength) {
+    colno = lineLength;
+  }
+  let start = Math.max(colno - 60, 0);
+  if (start < 5) {
+    start = 0;
+  }
+  let end = Math.min(start + 140, lineLength);
+  if (end > lineLength - 5) {
+    end = lineLength;
+  }
+  if (end === lineLength) {
+    start = Math.max(end - 140, 0);
+  }
+  newLine = newLine.slice(start, end);
+  if (start > 0) {
+    newLine = `'{snip} ${newLine}`;
+  }
+  if (end < lineLength) {
+    newLine += " {snip}";
+  }
+  return newLine;
+}
+function isValidSentryStackFrame(frame) {
+  return !!frame.filename && !!frame.lineno && !!frame.colno;
+}
+export {
+  addContextLinesToFrame,
+  applySourceContextToFrame,
+  getGeneratedCodeFromServer,
+  isValidSentryStackFrame,
+  parseStackTrace
+};
+//# sourceMappingURL=utils.js.map

package/dist/server/routes/contextlines/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../src/server/routes/contextlines/utils.ts"],"sourcesContent":["import * as os from \"node:os\";\nimport * as path from \"node:path\";\nimport { LEAST_UPPER_BOUND, TraceMap, originalPositionFor, sourceContentFor } from \"@jridgewell/trace-mapping\";\n\ntype SourceContext = {\n  pre_context?: string[];\n  context_line?: string;\n  post_context?: string[];\n};\n\ntype SentryStackFrame = {\n  filename?: string;\n  lineno?: number;\n  colno?: number;\n} & SourceContext;\n\ntype ValidSentryStackFrame = Required<SentryStackFrame>;\n\ntype SentryStackTrace = {\n  frames?: SentryStackFrame[];\n};\n\nexport async function getGeneratedCodeFromServer(filename: string): Promise<string | undefined> {\n  try {\n    const generatedCodeResponse = await fetch(filename);\n    return generatedCodeResponse.text();\n  } catch {\n    return undefined;\n  }\n}\n\nexport function parseStackTrace(requestBody: string): SentryStackTrace | undefined {\n  try {\n    return JSON.parse(requestBody) as SentryStackTrace;\n  } catch {\n    return undefined;\n  }\n}\n\nexport function applySourceContextToFrame(sourceMapContent: string, frame: ValidSentryStackFrame) {\n  const tracer = new TraceMap(JSON.parse(sourceMapContent));\n\n  const originalPosition = originalPositionFor(tracer, {\n    line: frame.lineno,\n    column: frame.colno,\n    bias: LEAST_UPPER_BOUND,\n  });\n\n  if (originalPosition.source && originalPosition.line && originalPosition.column) {\n    frame.lineno = originalPosition.line;\n    frame.colno = originalPosition.column;\n    const filePath = new URL(frame.filename).pathname.slice(1); // slice(1) is to not make it absolute path\n    frame.filename = path.resolve(path.join(path.dirname(filePath), originalPosition.source));\n\n    const content = sourceContentFor(tracer, originalPosition.source);\n    const lines = content?.split(os.EOL) ?? [];\n    addContextLinesToFrame(lines, frame);\n  }\n\n  return originalPosition;\n}\n\nexport function addContextLinesToFrame(lines: string[], frame: ValidSentryStackFrame, linesOfContext = 5): void {\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line: string) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line: string) => snipLine(line, 0));\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nfunction snipLine(line: string, colno: number): string {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += \" {snip}\";\n  }\n\n  return newLine;\n}\n\nexport function isValidSentryStackFrame(frame: SentryStackFrame): frame is ValidSentryStackFrame {\n  return !!frame.filename && !!frame.lineno && !!frame.colno;\n}\n"],"names":[],"mappings":";;;AAsBA,eAAsB,2BAA2B,UAA+C;AAC9F,MAAI;AACF,UAAM,wBAAwB,MAAM,MAAM,QAAQ;AAClD,WAAO,sBAAsB,KAAA;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEO,SAAS,gBAAgB,aAAmD;AACjF,MAAI;AACF,WAAO,KAAK,MAAM,WAAW;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEO,SAAS,0BAA0B,kBAA0B,OAA8B;AAChG,QAAM,SAAS,IAAI,SAAS,KAAK,MAAM,gBAAgB,CAAC;AAExD,QAAM,mBAAmB,oBAAoB,QAAQ;AAAA,IACnD,MAAM,MAAM;AAAA,IACZ,QAAQ,MAAM;AAAA,IACd,MAAM;AAAA,EAAA,CACP;AAED,MAAI,iBAAiB,UAAU,iBAAiB,QAAQ,iBAAiB,QAAQ;AAC/E,UAAM,SAAS,iBAAiB;AAChC,UAAM,QAAQ,iBAAiB;AAC/B,UAAM,WAAW,IAAI,IAAI,MAAM,QAAQ,EAAE,SAAS,MAAM,CAAC;AACzD,UAAM,WAAW,KAAK,QAAQ,KAAK,KAAK,KAAK,QAAQ,QAAQ,GAAG,iBAAiB,MAAM,CAAC;AAExF,UAAM,UAAU,iBAAiB,QAAQ,iBAAiB,MAAM;AAChE,UAAM,QAAQ,SAAS,MAAM,GAAG,GAAG,KAAK,CAAA;AACxC,2BAAuB,OAAO,KAAK;AAAA,EACrC;AAEA,SAAO;AACT;AAEO,SAAS,uBAAuB,OAAiB,OAA8B,iBAAiB,GAAS;AAC9G,QAAM,WAAW,MAAM;AACvB,QAAM,aAAa,KAAK,IAAI,KAAK,IAAI,WAAW,GAAG,MAAM,SAAS,CAAC,GAAG,CAAC;AAEvE,QAAM,cAAc,MACjB,MAAM,KAAK,IAAI,GAAG,aAAa,cAAc,GAAG,UAAU,EAC1D,IAAI,CAAC,SAAiB,SAAS,MAAM,CAAC,CAAC;AAE1C,QAAM,eAAe,SAAS,MAAM,KAAK,IAAI,WAAW,GAAG,UAAU,CAAC,GAAG,MAAM,SAAS,CAAC;AAEzF,QAAM,eAAe,MAClB,MAAM,KAAK,IAAI,aAAa,GAAG,QAAQ,GAAG,aAAa,IAAI,cAAc,EACzE,IAAI,CAAC,SAAiB,SAAS,MAAM,CAAC,CAAC;AAC5C;AAUA,SAAS,SAAS,MAAc,OAAuB;AACrD,MAAI,UAAU;AACd,QAAM,aAAa,QAAQ;AAC3B,MAAI,cAAc,KAAK;AACrB,WAAO;AAAA,EACT;AACA,MAAI,QAAQ,YAAY;AAEtB,YAAQ;AAAA,EACV;AAEA,MAAI,QAAQ,KAAK,IAAI,QAAQ,IAAI,CAAC;AAClC,MAAI,QAAQ,GAAG;AACb,YAAQ;AAAA,EACV;AAEA,MAAI,MAAM,KAAK,IAAI,QAAQ,KAAK,UAAU;AAC1C,MAAI,MAAM,aAAa,GAAG;AACxB,UAAM;AAAA,EACR;AACA,MAAI,QAAQ,YAAY;AACtB,YAAQ,KAAK,IAAI,MAAM,KAAK,CAAC;AAAA,EAC/B;AAEA,YAAU,QAAQ,MAAM,OAAO,GAAG;AAClC,MAAI,QAAQ,GAAG;AACb,cAAU,WAAW,OAAO;AAAA,EAC9B;AACA,MAAI,MAAM,YAAY;AACpB,eAAW;AAAA,EACb;AAEA,SAAO;AACT;AAEO,SAAS,wBAAwB,OAAyD;AAC/F,SAAO,CAAC,CAAC,MAAM,YAAY,CAAC,CAAC,MAAM,UAAU,CAAC,CAAC,MAAM;AACvD;"}

package/dist/server/routes/health.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const router: Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+export default router;

package/dist/server/routes/health.js

@@ -0,0 +1,7 @@
+import { Hono } from "hono";
+const router = new Hono();
+router.get("/", (ctx) => ctx.text("OK"));
+export {
+  router as default
+};
+//# sourceMappingURL=health.js.map

package/dist/server/routes/health.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.js","sources":["../../../src/server/routes/health.ts"],"sourcesContent":["import { Hono } from \"hono\";\n\nconst router = new Hono();\n\nrouter.get(\"/\", ctx => ctx.text(\"OK\"));\n\nexport default router;\n"],"names":[],"mappings":";AAEA,MAAM,SAAS,IAAI,KAAA;AAEnB,OAAO,IAAI,KAAK,CAAA,QAAO,IAAI,KAAK,IAAI,CAAC;"}

package/dist/server/routes/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const router: Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+export default router;

package/dist/server/routes/index.js

@@ -0,0 +1,19 @@
+import { Hono } from "hono";
+import { CONTEXT_LINES_ENDPOINT } from "../../shared/constants.js";
+import router$3 from "./clear.js";
+import router$6 from "./contextlines/index.js";
+import router$2 from "./health.js";
+import router$1 from "./mcp.js";
+import router$5 from "./open.js";
+import router$4 from "./stream/index.js";
+const router = new Hono();
+router.route("/mcp", router$1);
+router.route("/health", router$2);
+router.route("/clear", router$3);
+router.route("/", router$4);
+router.route("/open", router$5);
+router.route(CONTEXT_LINES_ENDPOINT, router$6);
+export {
+  router as default
+};
+//# sourceMappingURL=index.js.map

package/dist/server/routes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/server/routes/index.ts"],"sourcesContent":["import { Hono } from \"hono\";\nimport { CONTEXT_LINES_ENDPOINT } from \"../constants.ts\";\nimport clearRouter from \"./clear.ts\";\nimport contextLinesRouter from \"./contextlines/index.ts\";\nimport healthRouter from \"./health.ts\";\nimport mcpRouter from \"./mcp.ts\";\nimport openRouter from \"./open.ts\";\nimport streamRouter from \"./stream/index.ts\";\n\nconst router = new Hono();\nrouter.route(\"/mcp\", mcpRouter);\nrouter.route(\"/health\", healthRouter);\nrouter.route(\"/clear\", clearRouter);\nrouter.route(\"/\", streamRouter);\nrouter.route(\"/open\", openRouter);\nrouter.route(CONTEXT_LINES_ENDPOINT, contextLinesRouter);\n\nexport default router;\n"],"names":["mcpRouter","healthRouter","clearRouter","streamRouter","openRouter","contextLinesRouter"],"mappings":";;;;;;;;AASA,MAAM,SAAS,IAAI,KAAA;AACnB,OAAO,MAAM,QAAQA,QAAS;AAC9B,OAAO,MAAM,WAAWC,QAAY;AACpC,OAAO,MAAM,UAAUC,QAAW;AAClC,OAAO,MAAM,KAAKC,QAAY;AAC9B,OAAO,MAAM,SAASC,QAAU;AAChC,OAAO,MAAM,wBAAwBC,QAAkB;"}

package/dist/server/routes/mcp.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const router: Hono<import('hono/types').BlankEnv, import('hono/types').BlankSchema, "/">;
+export default router;

package/dist/server/routes/mcp.js

@@ -0,0 +1,20 @@
+import { StreamableHTTPTransport } from "@hono/mcp";
+import { Hono } from "hono";
+import { createMCPInstance } from "../mcp/mcp.js";
+const transport = new StreamableHTTPTransport();
+const mcp = createMCPInstance();
+const router = new Hono();
+router.all(
+  "/",
+  async (_ctx, next) => {
+    if (!mcp.isConnected()) {
+      await mcp.connect(transport);
+    }
+    await next();
+  },
+  (ctx) => transport.handleRequest(ctx)
+);
+export {
+  router as default
+};
+//# sourceMappingURL=mcp.js.map

package/dist/server/routes/mcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.js","sources":["../../../src/server/routes/mcp.ts"],"sourcesContent":["import { StreamableHTTPTransport } from \"@hono/mcp\";\nimport { Hono } from \"hono\";\nimport { createMCPInstance } from \"../mcp/mcp.ts\";\n\nconst transport = new StreamableHTTPTransport();\nconst mcp = createMCPInstance();\n\nconst router = new Hono();\n\nrouter.all(\n  \"/\",\n  async (_ctx, next) => {\n    if (!mcp.isConnected()) {\n      // Connecting the MCP with the transport\n      await mcp.connect(transport);\n    }\n\n    await next();\n  },\n  ctx => transport.handleRequest(ctx),\n);\n\nexport default router;\n"],"names":[],"mappings":";;;AAIA,MAAM,YAAY,IAAI,wBAAA;AACtB,MAAM,MAAM,kBAAA;AAEZ,MAAM,SAAS,IAAI,KAAA;AAEnB,OAAO;AAAA,EACL;AAAA,EACA,OAAO,MAAM,SAAS;AACpB,QAAI,CAAC,IAAI,eAAe;AAEtB,YAAM,IAAI,QAAQ,SAAS;AAAA,IAC7B;AAEA,UAAM,KAAA;AAAA,EACR;AAAA,EACA,CAAA,QAAO,UAAU,cAAc,GAAG;AACpC;"}

package/dist/server/routes/open.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import { HonoEnv } from '../types/index.ts';
+declare const router: Hono<HonoEnv, import('hono/types').BlankSchema, "/">;
+export default router;

package/dist/server/routes/open.js

@@ -0,0 +1,25 @@
+import { resolve } from "node:path";
+import { Hono } from "hono";
+import launchEditor from "launch-editor";
+import { logger } from "../logger.js";
+const router = new Hono();
+router.post("/", async (ctx) => {
+  const basePath = ctx.get("basePath") ?? process.cwd();
+  const requestBody = await ctx.req.text();
+  const targetPath = resolve(basePath, requestBody);
+  logger.debug(`Launching editor for ${targetPath}`);
+  launchEditor(
+    // filename:line:column
+    // both line and column are optional
+    targetPath,
+    // callback if failed to launch (optional)
+    (fileName, errorMsg) => {
+      logger.error(`Failed to launch editor for ${fileName}: ${errorMsg}`);
+    }
+  );
+  return ctx.body(null, 204);
+});
+export {
+  router as default
+};
+//# sourceMappingURL=open.js.map

package/dist/server/routes/open.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"open.js","sources":["../../../src/server/routes/open.ts"],"sourcesContent":["import { resolve } from \"node:path\";\nimport { Hono } from \"hono\";\nimport launchEditor from \"launch-editor\";\nimport { logger } from \"../logger.ts\";\nimport type { HonoEnv } from \"../types/index.ts\";\n\nconst router = new Hono<HonoEnv>();\n\n// ASK: Will this still be used in a desktop app? And if so, do we still have a base path and cwd?\nrouter.post(\"/\", async ctx => {\n  const basePath = ctx.get(\"basePath\") ?? process.cwd();\n\n  const requestBody = await ctx.req.text();\n  const targetPath = resolve(basePath, requestBody);\n  logger.debug(`Launching editor for ${targetPath}`);\n  launchEditor(\n    // filename:line:column\n    // both line and column are optional\n    targetPath,\n    // callback if failed to launch (optional)\n    (fileName, errorMsg) => {\n      logger.error(`Failed to launch editor for ${fileName}: ${errorMsg}`);\n    },\n  );\n  return ctx.body(null, 204);\n});\n\nexport default router;\n"],"names":[],"mappings":";;;;AAMA,MAAM,SAAS,IAAI,KAAA;AAGnB,OAAO,KAAK,KAAK,OAAM,QAAO;AAC5B,QAAM,WAAW,IAAI,IAAI,UAAU,KAAK,QAAQ,IAAA;AAEhD,QAAM,cAAc,MAAM,IAAI,IAAI,KAAA;AAClC,QAAM,aAAa,QAAQ,UAAU,WAAW;AAChD,SAAO,MAAM,wBAAwB,UAAU,EAAE;AACjD;AAAA;AAAA;AAAA,IAGE;AAAA;AAAA,IAEA,CAAC,UAAU,aAAa;AACtB,aAAO,MAAM,+BAA+B,QAAQ,KAAK,QAAQ,EAAE;AAAA,IACrE;AAAA,EAAA;AAEF,SAAO,IAAI,KAAK,MAAM,GAAG;AAC3B,CAAC;"}

package/dist/server/routes/stream/debugLogging.d.ts

@@ -0,0 +1,11 @@
+import { EventContainer } from '../../utils/index.ts';
+/**
+ * Logs incoming event details when debug mode is enabled
+ * Uses the container's parsed data if available
+ */
+export declare function logIncomingEvent(container: EventContainer): void;
+/**
+ * Logs outgoing event to client when debug mode is enabled
+ * Uses the container's already-parsed data if available
+ */
+export declare function logOutgoingEvent(container: EventContainer, clientId: string): void;

package/dist/server/routes/stream/debugLogging.js

@@ -0,0 +1,59 @@
+import { isDebugEnabled, logger } from "../../logger.js";
+import { isErrorEvent } from "../../parser/helpers.js";
+import "uuidv7";
+function logIncomingEvent(container) {
+  if (!isDebugEnabled()) return;
+  const contentType = container.getContentType();
+  if (contentType === "application/x-sentry-envelope") {
+    const parsedEnvelope = container.getParsedEnvelope();
+    if (!parsedEnvelope) {
+      const data = container.getData();
+      const size = data.length;
+      const firstNewline = data.indexOf("\n");
+      const headerPreview = firstNewline > 0 && firstNewline < 200 ? data.toString("utf-8", 0, firstNewline).replace(/\n/g, "\\n") : "header not found";
+      logger.debug(`→ envelope (parse error, ${size} bytes) | ${headerPreview}`);
+      return;
+    }
+    let logMessage = `→ ${formatEnvelopeMetadata(parsedEnvelope.envelope)}`;
+    for (const item of parsedEnvelope.envelope[1]) {
+      if (isErrorEvent(item[1])) {
+        logMessage += `
+  └ ${formatErrorDetails(item[1])}`;
+      }
+    }
+    logger.debug(logMessage);
+  } else {
+    logger.debug(`→ ${contentType || "unknown"}`);
+  }
+}
+function logOutgoingEvent(container, clientId) {
+  if (!isDebugEnabled()) return;
+  const typeInfo = container.getEventTypesString();
+  if (typeInfo === "envelope" && container.getContentType() === "application/x-sentry-envelope") {
+    const size = container.getData().length;
+    logger.debug(`← envelope (${size} bytes) to ${clientId}`);
+  } else {
+    logger.debug(`← ${typeInfo} to ${clientId}`);
+  }
+}
+function formatEnvelopeMetadata(envelope) {
+  const eventTypes = envelope[1].map((item) => item[0].type).filter(Boolean);
+  const typePrefix = eventTypes.length > 0 ? eventTypes.join("+") : "envelope";
+  const sdk = envelope[0].sdk?.name || "unknown";
+  const eventId = envelope[0].event_id;
+  return `${typePrefix} | sdk: ${sdk}${eventId ? ` | id: ${eventId}` : ""}`;
+}
+function formatErrorDetails(payload) {
+  const platform = payload.platform || "unknown";
+  const environment = payload.environment || "unknown";
+  const level = "level" in payload ? payload.level : "error";
+  const errorMsg = payload.exception?.values?.[0]?.value || String(payload.message) || "No error message";
+  const errorType = payload.exception?.values?.[0]?.type || "Error";
+  const truncatedMsg = errorMsg.substring(0, 80) + (errorMsg.length > 80 ? "..." : "");
+  return `${level} [${platform}/${environment}] ${errorType}: ${truncatedMsg}`;
+}
+export {
+  logIncomingEvent,
+  logOutgoingEvent
+};
+//# sourceMappingURL=debugLogging.js.map

package/dist/server/routes/stream/debugLogging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugLogging.js","sources":["../../../../src/server/routes/stream/debugLogging.ts"],"sourcesContent":["import { isDebugEnabled, logger } from \"../../logger.ts\";\nimport { type ParsedEnvelope, type SentryErrorEvent, type SentryEvent, isErrorEvent } from \"../../parser/index.ts\";\nimport type { EventContainer } from \"../../utils/index.ts\";\n\n/**\n * Logs incoming event details when debug mode is enabled\n * Uses the container's parsed data if available\n */\nexport function logIncomingEvent(container: EventContainer): void {\n  if (!isDebugEnabled()) return;\n\n  const contentType = container.getContentType();\n\n  if (contentType === \"application/x-sentry-envelope\") {\n    const parsedEnvelope = container.getParsedEnvelope();\n\n    if (!parsedEnvelope) {\n      // Still log something useful even if parsing failed\n      const data = container.getData();\n      const size = data.length;\n      // Only show first line of envelope header for safety (should be JSON metadata, not user data)\n      const firstNewline = data.indexOf(\"\\n\");\n      const headerPreview =\n        firstNewline > 0 && firstNewline < 200\n          ? data.toString(\"utf-8\", 0, firstNewline).replace(/\\n/g, \"\\\\n\")\n          : \"header not found\";\n      logger.debug(`→ envelope (parse error, ${size} bytes) | ${headerPreview}`);\n      return;\n    }\n\n    // Build complete log message with all details\n    let logMessage = `→ ${formatEnvelopeMetadata(parsedEnvelope.envelope)}`;\n\n    // Add error event details to the same log message\n    for (const item of parsedEnvelope.envelope[1]) {\n      if (isErrorEvent(item[1] as SentryEvent)) {\n        logMessage += `\\n  └ ${formatErrorDetails(item[1] as SentryErrorEvent)}`;\n      }\n    }\n\n    // Single atomic log statement\n    logger.debug(logMessage);\n  } else {\n    logger.debug(`→ ${contentType || \"unknown\"}`);\n  }\n}\n\n/**\n * Logs outgoing event to client when debug mode is enabled\n * Uses the container's already-parsed data if available\n */\nexport function logOutgoingEvent(container: EventContainer, clientId: string): void {\n  if (!isDebugEnabled()) return;\n\n  // Use the container's event type string (which uses cached parsed data)\n  const typeInfo = container.getEventTypesString();\n\n  // If it's an envelope that failed to parse, add size info\n  if (typeInfo === \"envelope\" && container.getContentType() === \"application/x-sentry-envelope\") {\n    const size = container.getData().length;\n    logger.debug(`← envelope (${size} bytes) to ${clientId}`);\n  } else {\n    logger.debug(`← ${typeInfo} to ${clientId}`);\n  }\n}\n\n/**\n * Formats envelope metadata for logging\n */\nfunction formatEnvelopeMetadata(envelope: ParsedEnvelope[\"envelope\"]): string {\n  const eventTypes = envelope[1].map(item => item[0].type).filter(Boolean);\n\n  const typePrefix = eventTypes.length > 0 ? eventTypes.join(\"+\") : \"envelope\";\n  const sdk = envelope[0].sdk?.name || \"unknown\";\n  const eventId = envelope[0].event_id;\n\n  return `${typePrefix} | sdk: ${sdk}${eventId ? ` | id: ${eventId}` : \"\"}`;\n}\n\n/**\n * Formats error event details for logging\n */\nfunction formatErrorDetails(payload: SentryErrorEvent): string {\n  const platform = payload.platform || \"unknown\";\n  const environment = payload.environment || \"unknown\";\n  const level = \"level\" in payload ? payload.level : \"error\";\n\n  const errorMsg = payload.exception?.values?.[0]?.value || String(payload.message) || \"No error message\";\n\n  const errorType = payload.exception?.values?.[0]?.type || \"Error\";\n\n  const truncatedMsg = errorMsg.substring(0, 80) + (errorMsg.length > 80 ? \"...\" : \"\");\n\n  return `${level} [${platform}/${environment}] ${errorType}: ${truncatedMsg}`;\n}\n"],"names":[],"mappings":";;;AAQO,SAAS,iBAAiB,WAAiC;AAChE,MAAI,CAAC,iBAAkB;AAEvB,QAAM,cAAc,UAAU,eAAA;AAE9B,MAAI,gBAAgB,iCAAiC;AACnD,UAAM,iBAAiB,UAAU,kBAAA;AAEjC,QAAI,CAAC,gBAAgB;AAEnB,YAAM,OAAO,UAAU,QAAA;AACvB,YAAM,OAAO,KAAK;AAElB,YAAM,eAAe,KAAK,QAAQ,IAAI;AACtC,YAAM,gBACJ,eAAe,KAAK,eAAe,MAC/B,KAAK,SAAS,SAAS,GAAG,YAAY,EAAE,QAAQ,OAAO,KAAK,IAC5D;AACN,aAAO,MAAM,4BAA4B,IAAI,aAAa,aAAa,EAAE;AACzE;AAAA,IACF;AAGA,QAAI,aAAa,KAAK,uBAAuB,eAAe,QAAQ,CAAC;AAGrE,eAAW,QAAQ,eAAe,SAAS,CAAC,GAAG;AAC7C,UAAI,aAAa,KAAK,CAAC,CAAgB,GAAG;AACxC,sBAAc;AAAA,MAAS,mBAAmB,KAAK,CAAC,CAAqB,CAAC;AAAA,MACxE;AAAA,IACF;AAGA,WAAO,MAAM,UAAU;AAAA,EACzB,OAAO;AACL,WAAO,MAAM,KAAK,eAAe,SAAS,EAAE;AAAA,EAC9C;AACF;AAMO,SAAS,iBAAiB,WAA2B,UAAwB;AAClF,MAAI,CAAC,iBAAkB;AAGvB,QAAM,WAAW,UAAU,oBAAA;AAG3B,MAAI,aAAa,cAAc,UAAU,eAAA,MAAqB,iCAAiC;AAC7F,UAAM,OAAO,UAAU,QAAA,EAAU;AACjC,WAAO,MAAM,eAAe,IAAI,cAAc,QAAQ,EAAE;AAAA,EAC1D,OAAO;AACL,WAAO,MAAM,KAAK,QAAQ,OAAO,QAAQ,EAAE;AAAA,EAC7C;AACF;AAKA,SAAS,uBAAuB,UAA8C;AAC5E,QAAM,aAAa,SAAS,CAAC,EAAE,IAAI,CAAA,SAAQ,KAAK,CAAC,EAAE,IAAI,EAAE,OAAO,OAAO;AAEvE,QAAM,aAAa,WAAW,SAAS,IAAI,WAAW,KAAK,GAAG,IAAI;AAClE,QAAM,MAAM,SAAS,CAAC,EAAE,KAAK,QAAQ;AACrC,QAAM,UAAU,SAAS,CAAC,EAAE;AAE5B,SAAO,GAAG,UAAU,WAAW,GAAG,GAAG,UAAU,UAAU,OAAO,KAAK,EAAE;AACzE;AAKA,SAAS,mBAAmB,SAAmC;AAC7D,QAAM,WAAW,QAAQ,YAAY;AACrC,QAAM,cAAc,QAAQ,eAAe;AAC3C,QAAM,QAAQ,WAAW,UAAU,QAAQ,QAAQ;AAEnD,QAAM,WAAW,QAAQ,WAAW,SAAS,CAAC,GAAG,SAAS,OAAO,QAAQ,OAAO,KAAK;AAErF,QAAM,YAAY,QAAQ,WAAW,SAAS,CAAC,GAAG,QAAQ;AAE1D,QAAM,eAAe,SAAS,UAAU,GAAG,EAAE,KAAK,SAAS,SAAS,KAAK,QAAQ;AAEjF,SAAO,GAAG,KAAK,KAAK,QAAQ,IAAI,WAAW,KAAK,SAAS,KAAK,YAAY;AAC5E;"}

package/dist/server/routes/stream/index.d.ts

@@ -0,0 +1,34 @@
+import { HonoEnv } from '../../types/env.ts';
+declare const router: import('hono/hono-base').HonoBase<HonoEnv, {
+    "/stream": {
+        $get: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: import('hono/utils/http-status').StatusCode;
+        };
+    };
+} & {
+    "/envelope/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import('hono/utils/http-status').StatusCode;
+        };
+    };
+} & {
+    [x: string]: {
+        [x: `$${Lowercase<string>}`]: {
+            input: {};
+            output: null;
+            outputFormat: "body";
+            status: 200;
+        };
+    };
+}, "/">;
+export default router;