@sentry/roach 0.0.0-stage → 0.2.0

package/src/streams.ts

@@ -0,0 +1,115 @@
+/**
+ * Recorded event streams (`text/event-stream`).
+ *
+ * A model stream sends a tool call or a text in many small deltas, so an id
+ * that the model repeats can be split over two events. Before the proxy
+ * writes changing values as placeholders (`values.ts`), it merges the
+ * deltas of each Anthropic Messages content block into one event. A client
+ * joins the deltas anyway, so it gets the same content.
+ *
+ * Thinking blocks keep their recorded text. A signature covers that text,
+ * and the provider refuses a changed thinking block in a later request.
+ * So a later request sends back the values of the recording run in its
+ * thinking blocks, and `request-key.ts` must not fill placeholders from
+ * them.
+ */
+
+/** The text field of each delta type that the proxy merges. */
+const DELTA_FIELDS: Record<string, string> = {
+  input_json_delta: "partial_json",
+  text_delta: "text",
+  thinking_delta: "thinking",
+};
+/** The content block types of thinking, in a stream and in a request. */
+export const THINKING_BLOCK_TYPES = new Set(["redacted_thinking", "thinking"]);
+const THINKING_TYPES = new Set([
+  ...THINKING_BLOCK_TYPES,
+  "signature_delta",
+  "thinking_delta",
+]);
+
+interface StreamEvent {
+  text: string;
+  data?: Record<string, unknown>;
+}
+
+/** Whether a content type is an event stream. */
+export const isEventStream = (contentType: string | undefined) =>
+  /^text\/event-stream\b/i.test(contentType ?? "");
+
+function parseEvent(text: string): StreamEvent {
+  const line = text.split("\n").find((entry) => entry.startsWith("data:"));
+  if (!line) return { text };
+  try {
+    const data: unknown = JSON.parse(line.slice(5).trim());
+    return data && typeof data === "object" && !Array.isArray(data)
+      ? { text, data: data as Record<string, unknown> }
+      : { text };
+  } catch {
+    return { text };
+  }
+}
+
+/** The type and text field of a delta event that the proxy can merge. */
+function mergeableDelta(event: StreamEvent) {
+  if (event.data?.type !== "content_block_delta") return undefined;
+  const delta = event.data.delta as Record<string, unknown> | undefined;
+  const field = DELTA_FIELDS[String(delta?.type)];
+  if (!delta || !field || typeof delta[field] !== "string") return undefined;
+  return { delta, field, index: event.data.index };
+}
+
+function splitEvents(body: string): StreamEvent[] {
+  return body
+    .replace(/\r\n/g, "\n")
+    .split(/\n\n+/)
+    .filter((text) => text.trim() !== "")
+    .map(parseEvent);
+}
+
+const joinEvents = (events: StreamEvent[]) =>
+  events.map((event) => `${event.text}\n\n`).join("");
+
+/** Merge the deltas of each content block into one event. */
+export function mergeStreamDeltas(body: string): string {
+  const events: StreamEvent[] = [];
+  for (const event of splitEvents(body)) {
+    const current = mergeableDelta(event);
+    const previousEvent = events.at(-1);
+    const previous = previousEvent && mergeableDelta(previousEvent);
+    if (
+      current &&
+      previous &&
+      previous.index === current.index &&
+      previous.delta.type === current.delta.type
+    ) {
+      previous.delta[previous.field] =
+        `${previous.delta[previous.field] as string}${current.delta[current.field] as string}`;
+      previousEvent.text = `event: content_block_delta\ndata: ${JSON.stringify(previousEvent.data)}`;
+      continue;
+    }
+    events.push(event);
+  }
+  return joinEvents(events);
+}
+
+function isThinking(event: StreamEvent): boolean {
+  const delta = event.data?.delta as { type?: unknown } | undefined;
+  const block = event.data?.content_block as { type?: unknown } | undefined;
+  return (
+    THINKING_TYPES.has(String(delta?.type)) ||
+    THINKING_TYPES.has(String(block?.type))
+  );
+}
+
+/** Change each event of a stream, but keep thinking events as they are. */
+export function mapStreamEvents(
+  body: string,
+  change: (text: string) => string,
+): string {
+  return joinEvents(
+    splitEvents(body).map((event) =>
+      isThinking(event) ? event : { text: change(event.text) },
+    ),
+  );
+}

package/src/types.ts

@@ -0,0 +1,130 @@
+/**
+ * The public contract of Roach: rules, modes, runs, sessions, and the
+ * results of a run. The client, the service, and the vitest integration
+ * share it. See `README.md`.
+ */
+import type { ValuePatterns } from "./values.ts";
+
+/** The path prefix of the control API. */
+export const CONTROL_PATH = "/__roach";
+
+/**
+ * - `auto`: replay a request that has a recording. Send other requests live
+ *   and record them.
+ * - `replay`: replay a request that has a recording. Fail other requests
+ *   with HTTP 412. Nothing goes live, and nothing is recorded.
+ * - `record`: send every request live and record it again.
+ * - `off`: record and replay nothing.
+ */
+export type RecordingMode = "auto" | "off" | "record" | "replay";
+
+/** One kind of traffic that the proxy records. */
+export interface RecordingRule {
+  /**
+   * The name of the rule, such as `model`. Its keys start with
+   * `<name>/`. Use letters, digits, `_`, `.`, and `-`.
+   */
+  name: string;
+  /** The requests of the rule. Each field that is set must match. */
+  match: {
+    /** The method, such as `POST`. */
+    method?: string;
+    /** The start of the URL, such as `https://ai-gateway.vercel.sh/`. */
+    url?: string;
+    /** Header values. Names are lowercase. */
+    headers?: Record<string, string>;
+  };
+  /**
+   * Request headers that are in the key, with the method, the URL, and the
+   * body. Names are lowercase.
+   */
+  keyHeaders?: string[];
+  /**
+   * Values in the request body that change from run to run, such as ids and
+   * times. See `values.ts`.
+   */
+  values?: ValuePatterns;
+}
+
+/** A request that a rule matched, but that had no recording. */
+export interface RecordingMiss {
+  rule: string;
+  /** The session of the request. */
+  session?: string | undefined;
+  /** The key of the recording that the request needed. */
+  file: string;
+}
+
+/** The totals of a run. */
+export interface RecordingStats {
+  /**
+   * Requests by rule name. `missed` counts the requests that `replay` mode
+   * failed, because they had no recording.
+   */
+  counts: Record<string, { live: number; missed: number; replayed: number }>;
+  /** The requests without a recording, in order. The first 500 are kept. */
+  misses: RecordingMiss[];
+  /** Recordings that the proxy wrote and that were new or changed. */
+  written: number;
+  /** New recordings that the proxy dropped, because their session failed. */
+  discarded: number;
+  /**
+   * Requests that matched no rule, by origin. They went live and were not
+   * recorded. Use this to find traffic that a rule misses.
+   */
+  passthrough: Record<string, number>;
+}
+
+/** The configuration of one run. The client sends it. */
+export interface RunConfig {
+  /**
+   * The tenant of the run, as `owner/repo`, such as
+   * `process.env.GITHUB_REPOSITORY`.
+   */
+  tenant: string;
+  mode: RecordingMode;
+  rules: RecordingRule[];
+  /**
+   * The only origins that the run can reach, such as
+   * `https://ai-gateway.vercel.sh`. The service sends requests only to
+   * their public addresses.
+   */
+  allow: string[];
+  /**
+   * The name of the run in Sentry, such as
+   * `${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}`. Default: the run id.
+   */
+  name?: string;
+  /**
+   * Credentials that this run must never write, such as the API keys of
+   * its CI job. The service redacts them with the `secrets` of the service
+   * config, keeps them only in memory, and forgets them when the run ends.
+   */
+  secrets?: string[];
+}
+
+/** A run that the service created. */
+export interface RemoteRun {
+  /** The id of the run. */
+  id: string;
+  /**
+   * The proxy URL, with the run id and token as its user and password. A
+   * request through it belongs to the open session when only one is open.
+   */
+  url: string;
+  /** The run token. Session and stats calls use it. */
+  token: string;
+  /** The base URL of the control API of the run. */
+  controlUrl: string;
+  /** The PEM certificate of the authority that signs intercepted hosts. */
+  caCert: string;
+}
+
+/** A session that the service opened. */
+export interface OpenedSession {
+  /**
+   * The proxy URL of the session. Each request through it belongs to the
+   * session, also when other sessions are open.
+   */
+  url: string;
+}

package/src/usage.ts

@@ -0,0 +1,120 @@
+/**
+ * The token usage of a model response, as `gen_ai` span attributes.
+ *
+ * Sentry calculates the cost of a span in USD (`gen_ai.cost.*`) from these
+ * attributes and its own price of the model. So Roach needs no prices, and
+ * the client sends nothing extra. A replayed response has the usage of its
+ * recording: the cost that the replay saved.
+ *
+ * The proxy reads the usage fields of two model APIs: Anthropic Messages
+ * (`input_tokens`, `cache_read_input_tokens`) and OpenAI Chat Completions
+ * (`prompt_tokens`, `prompt_tokens_details`). It reads the whole body, or
+ * each event of a stream. A later event gives the total so far, so the last
+ * value of each field wins.
+ *
+ * As in Sentry, `gen_ai.usage.input_tokens` includes the cache tokens.
+ * Anthropic counts them apart, so the proxy adds them.
+ */
+import { isEventStream } from "./streams.ts";
+
+type Fields = Record<string, unknown>;
+
+const isObject = (value: unknown): value is Fields =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const count = (value: unknown) =>
+  typeof value === "number" && Number.isFinite(value) && value >= 0
+    ? value
+    : undefined;
+
+function parseJson(text: string): unknown {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return undefined;
+  }
+}
+
+/** The JSON objects of a body: the body itself, or each stream event. */
+function bodyObjects(contentType: string | undefined, body: string): Fields[] {
+  const values = isEventStream(contentType)
+    ? body
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => parseJson(line.slice(5).trim()))
+    : /json/i.test(contentType ?? "")
+      ? [parseJson(body)]
+      : [];
+  return values.filter(isObject);
+}
+
+/** The model that a request asks for, from its JSON body. */
+function requestModel(body: string): string | undefined {
+  const parsed = parseJson(body);
+  return isObject(parsed) && typeof parsed.model === "string"
+    ? parsed.model
+    : undefined;
+}
+
+/**
+ * The `gen_ai` attributes of one model call, or `undefined` when the
+ * response has no usage.
+ */
+export function usageAttributes(
+  requestBody: string,
+  contentType: string | undefined,
+  responseBody: string,
+): Record<string, string | number> | undefined {
+  let model: string | undefined;
+  const usage: Fields = {};
+  for (const object of bodyObjects(contentType, responseBody)) {
+    // An Anthropic stream sends the model and the first usage in
+    // `message_start`.
+    const message = isObject(object.message) ? object.message : object;
+    if (typeof message.model === "string") model = message.model;
+    for (const source of [message.usage, object.usage]) {
+      if (!isObject(source)) continue;
+      for (const [name, value] of Object.entries(source)) {
+        if (value !== null && value !== undefined) usage[name] = value;
+      }
+    }
+  }
+
+  const details = (name: string, field: string) =>
+    isObject(usage[name]) ? count(usage[name][field]) : undefined;
+  const cacheRead =
+    count(usage.cache_read_input_tokens) ??
+    details("prompt_tokens_details", "cached_tokens");
+  const cacheWrite = count(usage.cache_creation_input_tokens);
+  const input =
+    count(usage.prompt_tokens) ??
+    addCounts(count(usage.input_tokens), cacheRead, cacheWrite);
+  const output = count(usage.completion_tokens) ?? count(usage.output_tokens);
+  const reasoning = details("completion_tokens_details", "reasoning_tokens");
+  if (input === undefined && output === undefined) return undefined;
+
+  const attributes: Record<string, string | number> = {
+    "gen_ai.operation.name": "chat",
+  };
+  // Sentry prices the response model, or the request model without one. A
+  // gateway can name the model in the response in another way than its
+  // price list does, so the requested name wins.
+  const requested = requestModel(requestBody);
+  if (requested) attributes["gen_ai.request.model"] = requested;
+  else if (model) attributes["gen_ai.response.model"] = model;
+  const set = (name: string, value: number | undefined) => {
+    if (value !== undefined) attributes[`gen_ai.usage.${name}`] = value;
+  };
+  set("input_tokens", input);
+  set("output_tokens", output);
+  set("cache_read.input_tokens", cacheRead);
+  set("cache_creation.input_tokens", cacheWrite);
+  set("reasoning.output_tokens", reasoning);
+  return attributes;
+}
+
+/** The sum of the counts that are set, or `undefined` when none is. */
+function addCounts(...values: Array<number | undefined>): number | undefined {
+  const set = values.filter((value) => value !== undefined);
+  return set.length === 0 ? undefined : set.reduce((sum, v) => sum + v, 0);
+}

package/src/values.ts

@@ -0,0 +1,229 @@
+/**
+ * Changing values in recorded requests, such as ids and clock times.
+ *
+ * A rule names the values that change from run to run. The proxy handles
+ * them in two directions:
+ *
+ * - The key sees each value as `<<name>>`, so two runs with other ids or
+ *   times send the same request.
+ * - A response often repeats a value of its request, for example when the
+ *   model archives the memory with id `<<uuid>>`. When the proxy records a
+ *   response, it writes each value of the request as `<<name:n>>`, the n-th
+ *   value of that name in the request. On replay, it writes back the n-th
+ *   value of the current request. So a replayed response uses the ids of
+ *   this run, not the ids of the recording run.
+ *
+ * A value that the response makes itself, such as a date that the model
+ * calculates, stays as it was recorded.
+ */
+import vm from "node:vm";
+
+/**
+ * Lookbehind: the value does not continue a word or number. The proxy
+ * matches values in JSON text, where `\nab12` is a newline and then
+ * `ab12`. So a letter after a backslash, such as the `n` of `\n`, does not
+ * count as a word. Use it in a pattern that starts with a letter or digit.
+ */
+export const NOT_AFTER_WORD = String.raw`(?<!(?:^|[^\\])[0-9A-Za-z])`;
+
+/**
+ * Patterns for common changing values. Use them in `values` of a rule. Each
+ * pattern is a regular expression source.
+ */
+export const VALUE_PATTERNS = {
+  /** A UUID, also inside a name such as `junior-ws-<uuid>`. */
+  uuid: String.raw`${NOT_AFTER_WORD}[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}(?![0-9A-Za-z])`,
+  /**
+   * An ISO time, with `T` or a space, with or without seconds, and in UTC,
+   * with an offset, or in local time.
+   */
+  isoTime: String.raw`(?<![\d-])\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2}| ?UTC)?(?![\d:])`,
+  /** An ISO date, such as `2026-10-07`. */
+  date: String.raw`(?<![\d-])\d{4}-\d{2}-\d{2}(?![\d-])`,
+  /**
+   * Unix milliseconds from 2023 to 2033. Unix seconds, such as Slack
+   * timestamps, do not match.
+   */
+  epochMs: String.raw`(?<!\d)1[789]\d{11}(?!\d)`,
+  /**
+   * A SHA-256 hex digest. Ids that the product hashes from other changing
+   * values, such as attachment ids, change with them.
+   */
+  sha256: String.raw`${NOT_AFTER_WORD}[0-9a-f]{64}(?![0-9A-Za-z])`,
+  /**
+   * A git commit id. Its hash covers the commit time, so it changes on each
+   * run. A full id has 40 hex digits. A short id only counts in the output
+   * of `git commit`, such as `[main (root-commit) a7a9f1d]`, and in the range
+   * of `git push`, such as `a5fd79f..a73e959`, because seven hex digits can
+   * also be a word.
+   */
+  gitCommit: String.raw`${NOT_AFTER_WORD}[0-9a-f]{40}(?![0-9A-Za-z])|(?<=\[[^\]\s]+ (?:\(root-commit\) )?)[0-9a-f]{7,12}(?=\])|${NOT_AFTER_WORD}[0-9a-f]{7,12}(?=\.\.\.?[0-9a-f]{7,12}(?![0-9A-Za-z]))|(?<=${NOT_AFTER_WORD}[0-9a-f]{7,12}\.\.\.?)[0-9a-f]{7,12}(?![0-9A-Za-z])`,
+} as const;
+
+/** Changing values by name. Each value is a regular expression source. */
+export type ValuePatterns = Record<string, string>;
+
+/** The values of one request, by name, in the order of the request. */
+export type RequestValues = Map<string, string[]>;
+
+interface CompiledValues {
+  names: string[];
+  /** One expression for all patterns, with one group per name. */
+  pattern: RegExp;
+  /** The index of the group of each name. */
+  groups: number[];
+}
+
+const compiled = new WeakMap<ValuePatterns, CompiledValues>();
+
+/** The number of capturing groups in a pattern. */
+const groupCount = (source: string) =>
+  new RegExp(`${source}|`).exec("")!.length - 1;
+
+function compile(patterns: ValuePatterns): CompiledValues {
+  const cached = compiled.get(patterns);
+  if (cached) return cached;
+  const names = Object.keys(patterns);
+  const groups: number[] = [];
+  let next = 1;
+  for (const name of names) {
+    groups.push(next);
+    next += 1 + groupCount(patterns[name]!);
+  }
+  const result = {
+    names,
+    // Earlier names win when two patterns match at the same place.
+    pattern: new RegExp(
+      names.map((name) => `(${patterns[name]})`).join("|"),
+      "g",
+    ),
+    groups,
+  };
+  compiled.set(patterns, result);
+  return result;
+}
+
+/**
+ * Run `fn` with a time limit. A slow pattern cannot stop itself, but the
+ * `timeout` of `vm` stops any code that runs too long, also code outside
+ * the context that the script calls. A timeout throws an error with HTTP
+ * status 400.
+ */
+export function withTimeLimit<T>(ms: number, fn: () => T): T {
+  try {
+    return vm.runInContext("fn()", vm.createContext({ fn }), {
+      timeout: ms,
+    }) as T;
+  } catch (error) {
+    if ((error as { code?: string }).code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {
+      throw Object.assign(
+        new Error(`the value patterns took over ${ms} ms. Make them simpler.`),
+        { status: 400 },
+      );
+    }
+    throw error;
+  }
+}
+
+/**
+ * Check that the patterns of each rule compile. Returns the error, or
+ * `undefined`. A pattern can be slow to compile, so all of them together
+ * have 1 s.
+ */
+export function invalidValuePatterns(
+  list: ValuePatterns[],
+): string | undefined {
+  try {
+    withTimeLimit(1000, () => list.forEach((patterns) => compile(patterns)));
+    return undefined;
+  } catch (error) {
+    return (error as Error).message;
+  }
+}
+
+/** Values that an earlier request of the same session had, by value. */
+export type KnownValues = ReadonlyMap<string, string>;
+
+/**
+ * Replace each changing value in `text` with `<<name>>`. Returns the text
+ * and the values in their order. With no patterns, nothing changes.
+ *
+ * `known` maps values of earlier requests in the session to their names. A
+ * known value also counts where no pattern finds it. For example, the
+ * model repeats the short commit id of a `git push` range in its reply,
+ * and a later request sends that reply back. A pattern wins over a known
+ * value at the same place.
+ */
+export function extractValues(
+  text: string,
+  patterns: ValuePatterns | undefined,
+  known?: KnownValues,
+): { text: string; values: RequestValues } {
+  const values: RequestValues = new Map();
+  if (!patterns || Object.keys(patterns).length === 0) {
+    return { text, values };
+  }
+  const { names, pattern, groups } = compile(patterns);
+  const hasKnown = known !== undefined && known.size > 0;
+  // Known values are the last group, after the groups of the patterns.
+  const knownGroup = groupCount(pattern.source) + 1;
+  const search = hasKnown
+    ? new RegExp(`${pattern.source}|(${literals([...known.keys()])})`, "g")
+    : pattern;
+  const result = text.replace(search, (...match: unknown[]) => {
+    const value = match[0] as string;
+    const name =
+      hasKnown && match[knownGroup] !== undefined
+        ? known.get(value)!
+        : names[groups.findIndex((group) => match[group] !== undefined)]!;
+    const list = values.get(name) ?? [];
+    list.push(value);
+    values.set(name, list);
+    return `<<${name}>>`;
+  });
+  return { text: result, values };
+}
+
+const escape = (text: string) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/**
+ * A pattern source for any of `values`, where it is not part of a longer
+ * word or number. Longer values come first, so a date never replaces part
+ * of a time.
+ */
+const literals = (values: string[]) =>
+  `${NOT_AFTER_WORD}(?:${values
+    .toSorted((a, b) => b.length - a.length)
+    .map(escape)
+    .join("|")})(?![0-9A-Za-z])`;
+
+/**
+ * Write each value of the request that a recorded response repeats as
+ * `<<name:n>>`. A value is replaced only where it is not part of a longer
+ * word or number.
+ */
+export function templateValues(text: string, values: RequestValues): string {
+  const placeholders = new Map<string, string>();
+  for (const [name, list] of values) {
+    list.forEach((value, index) => {
+      if (!placeholders.has(value)) {
+        placeholders.set(value, `<<${name}:${index + 1}>>`);
+      }
+    });
+  }
+  if (placeholders.size === 0) return text;
+  const pattern = new RegExp(literals([...placeholders.keys()]), "g");
+  return text.replace(pattern, (value) => placeholders.get(value)!);
+}
+
+/**
+ * Write back the values of the current request into a recorded response.
+ * This undoes `templateValues()` with the values of this run.
+ */
+export function fillValues(text: string, values: RequestValues): string {
+  return text.replace(
+    /<<([^<>:\s]+):(\d+)>>/g,
+    (placeholder, name: string, index: string) =>
+      values.get(name)?.[Number(index) - 1] ?? placeholder,
+  );
+}

package/src/vitest-setup.ts

@@ -0,0 +1,66 @@
+/**
+ * The vitest setup file of Roach (`@sentry/roach/vitest/setup`). See "Use
+ * with vitest" in `README.md`.
+ *
+ * It opens one session for each test of the run that `vitest.ts` started.
+ * Requests of the test go through the proxy URL of its session, so tests
+ * in other workers record at the same time. Its child processes get that
+ * URL too. A passed test writes its new recordings, and a failed test
+ * drops them. A test with a request that `replay` mode failed fails.
+ *
+ * The tests of one file share one process, so they must run one at a
+ * time. Do not use `test.concurrent` with Roach.
+ */
+import http from "node:http";
+import {
+  beforeEach,
+  inject,
+  onTestFinished,
+  type ProvidedContext,
+} from "vitest";
+import { connectRoach } from "./client.ts";
+
+const provided = inject("roach");
+if (provided === undefined) {
+  throw new Error(
+    "Roach: add @sentry/roach/vitest to globalSetup to use the setup file",
+  );
+}
+// `null` is `off` mode: no run, so requests go direct.
+if (provided) useRun(provided);
+
+/** Open a session for each test of the run. */
+function useRun(run: NonNullable<ProvidedContext["roach"]>): void {
+  const control = connectRoach(run);
+  beforeEach(async ({ task }) => {
+    // The full name starts with the file, so tests of two files never share
+    // a session.
+    const session = await control.startSession(task.fullName);
+    const previous = {
+      HTTP_PROXY: process.env.HTTP_PROXY,
+      HTTPS_PROXY: process.env.HTTPS_PROXY,
+    };
+    process.env.HTTP_PROXY = session.url;
+    process.env.HTTPS_PROXY = session.url;
+    const restoreProxy = http.setGlobalProxyFromEnv({
+      HTTP_PROXY: session.url,
+      HTTPS_PROXY: session.url,
+      NO_PROXY: run.noProxy,
+    });
+    onTestFinished(async ({ task: finished }) => {
+      restoreProxy();
+      for (const [name, value] of Object.entries(previous)) {
+        if (value === undefined) delete process.env[name];
+        else process.env[name] = value;
+      }
+      const { missed } = await session.end(finished.result?.state === "pass");
+      // `replay` mode failed these requests, so nothing went live. The test
+      // must fail, also when it recovered from the error.
+      if (missed > 0) {
+        throw new Error(
+          `Roach: ${missed} request(s) had no recording in replay mode. Run with ROACH_TOKEN to record them.`,
+        );
+      }
+    });
+  });
+}