@oneuptime/common 11.5.8 → 11.5.9

package/UI/Utils/AIChatExport/ConversationMarkdown.ts

@@ -0,0 +1,177 @@
+import AIConversationMessage from "../../../Models/DatabaseModels/AIConversationMessage";
+import AIRun from "../../../Models/DatabaseModels/AIRun";
+import AIChatMessageRole from "../../../Types/AI/AIChatMessageRole";
+import AIChatMessageStatus from "../../../Types/AI/AIChatMessageStatus";
+import {
+  AIChatCitation,
+  AIChatToolAction,
+  AIChatWidget,
+} from "../../../Types/AI/AIChatTypes";
+import OneUptimeDate from "../../../Types/Date";
+import neutralizeAssistantMarkdown from "./MarkdownSafety";
+import {
+  citationsToMarkdown,
+  toolActionsToMarkdown,
+  widgetsToMarkdown,
+} from "./ChatWidgetMarkdown";
+
+/*
+ * Renders a whole AI chat conversation as a markdown document.
+ *
+ * The shape follows the chat itself: alternating turns, each assistant turn
+ * carrying the widgets, actions and citations that were shown beneath it. What
+ * the reader gets is the transcript plus the evidence behind it, in a file that
+ * reads fine in a plain text editor.
+ */
+
+export interface ConversationMarkdownOptions {
+  title: string;
+  messages: Array<AIConversationMessage>;
+  latestRun?: AIRun | undefined;
+  exportedAt: Date;
+}
+
+// Mirrors the cost footer the chat shows under the newest completed answer.
+function runFooter(run: AIRun): string {
+  const parts: Array<string> = [];
+
+  if (run.egressManifest?.modelName) {
+    parts.push(run.egressManifest.modelName);
+  }
+  if (run.totalTokens) {
+    parts.push(`${run.totalTokens.toLocaleString()} tokens`);
+  }
+  if (run.totalCostInUSDCents) {
+    parts.push(`$${(run.totalCostInUSDCents / 100).toFixed(4)}`);
+  }
+  const toolCallCount: number = run.toolCallCount || 0;
+  parts.push(`${toolCallCount} ${toolCallCount === 1 ? "query" : "queries"}`);
+
+  return parts.join(" · ");
+}
+
+function messageToMarkdown(
+  message: AIConversationMessage,
+  isLastCompletedAssistant: boolean,
+  latestRun: AIRun | undefined,
+): Array<string> {
+  const lines: Array<string> = [];
+  const timestamp: string = message.createdAt
+    ? OneUptimeDate.getDateAsLocalFormattedString(message.createdAt)
+    : "";
+
+  if (message.role === AIChatMessageRole.User) {
+    lines.push("## You", "");
+    /*
+     * The user's own words, shown literally on screen. No neutralization: this
+     * is the operator's own input, not model output derived from telemetry.
+     */
+    if (message.contentInMarkdown) {
+      lines.push(message.contentInMarkdown.trim(), "");
+    }
+    if (timestamp) {
+      lines.push(`_${timestamp}_`, "");
+    }
+    return lines;
+  }
+
+  lines.push("## AI", "");
+
+  if (message.status === AIChatMessageStatus.Error) {
+    lines.push(
+      `> **Error:** ${
+        message.errorMessage || "Something went wrong generating this response."
+      }`,
+      "",
+    );
+    return lines;
+  }
+
+  if (message.contentInMarkdown) {
+    lines.push(neutralizeAssistantMarkdown(message.contentInMarkdown), "");
+  }
+
+  const widgets: Array<AIChatWidget> = message.widgets || [];
+  if (widgets.length > 0) {
+    lines.push(widgetsToMarkdown(widgets), "");
+  }
+
+  const toolActions: Array<AIChatToolAction> = message.toolActions || [];
+  if (toolActions.length > 0) {
+    lines.push(toolActionsToMarkdown(toolActions), "");
+  }
+
+  const citations: Array<AIChatCitation> = message.citations || [];
+  if (citations.length > 0) {
+    lines.push(citationsToMarkdown(citations), "");
+  }
+
+  const footerParts: Array<string> = [];
+  if (timestamp) {
+    footerParts.push(timestamp);
+  }
+  if (isLastCompletedAssistant && latestRun) {
+    footerParts.push(runFooter(latestRun));
+  }
+  if (footerParts.length > 0) {
+    lines.push(`_${footerParts.join(" · ")}_`, "");
+  }
+
+  return lines;
+}
+
+export default function convertConversationToMarkdown(
+  options: ConversationMarkdownOptions,
+): string {
+  const lines: Array<string> = [
+    `# ${options.title || "AI conversation"}`,
+    "",
+    `_Exported from OneUptime on ${OneUptimeDate.getDateAsLocalFormattedString(
+      options.exportedAt,
+    )}_`,
+    "",
+    "---",
+    "",
+  ];
+
+  /*
+   * The run footer belongs to the newest completed answer, matching where the
+   * chat shows it.
+   */
+  const lastCompletedAssistantId: string | undefined = [...options.messages]
+    .reverse()
+    .find((message: AIConversationMessage) => {
+      return (
+        message.role === AIChatMessageRole.Assistant &&
+        message.status === AIChatMessageStatus.Completed
+      );
+    })
+    ?.id?.toString();
+
+  for (const message of options.messages) {
+    /*
+     * An answer still being generated has nothing to export yet; the chat
+     * represents it with a live activity feed rather than content.
+     */
+    if (
+      message.role === AIChatMessageRole.Assistant &&
+      (message.status === AIChatMessageStatus.InProgress ||
+        message.status === AIChatMessageStatus.Pending) &&
+      !message.contentInMarkdown &&
+      (message.widgets || []).length === 0 &&
+      (message.toolActions || []).length === 0
+    ) {
+      continue;
+    }
+
+    lines.push(
+      ...messageToMarkdown(
+        message,
+        message.id?.toString() === lastCompletedAssistantId,
+        options.latestRun,
+      ),
+    );
+  }
+
+  return `${lines.join("\n").trim()}\n`;
+}

package/UI/Utils/AIChatExport/MarkdownBlocks.ts

@@ -0,0 +1,327 @@
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+
+/*
+ * Flattens markdown into a small list of drawable blocks.
+ *
+ * The PDF exporter cannot use the chat's React markdown renderer, but it should
+ * not hand-roll a markdown parser either — that is how exports end up rendering
+ * a code fence as bold text. So the same parser the chat uses (remark + GFM)
+ * produces the tree, and this module lowers it into a shape a drawing routine
+ * can consume without knowing anything about mdast.
+ *
+ * Only the constructs an assistant answer actually produces are modelled.
+ * Anything unrecognized degrades to its text content rather than disappearing.
+ */
+
+export enum MarkdownBlockType {
+  Heading = "Heading",
+  Paragraph = "Paragraph",
+  ListItem = "ListItem",
+  Code = "Code",
+  Quote = "Quote",
+  Table = "Table",
+  Rule = "Rule",
+}
+
+export interface MarkdownInline {
+  text: string;
+  isBold?: boolean | undefined;
+  isItalic?: boolean | undefined;
+  isCode?: boolean | undefined;
+  isStrikethrough?: boolean | undefined;
+}
+
+export interface MarkdownBlock {
+  type: MarkdownBlockType;
+  // Heading level 1-6.
+  level?: number | undefined;
+  inlines?: Array<MarkdownInline> | undefined;
+  // Code blocks.
+  code?: string | undefined;
+  language?: string | undefined;
+  // List items.
+  indent?: number | undefined;
+  marker?: string | undefined;
+  // Tables.
+  headers?: Array<string> | undefined;
+  rows?: Array<Array<string>> | undefined;
+  alignments?: Array<"left" | "right" | "center"> | undefined;
+}
+
+interface MarkdownNode {
+  type: string;
+  value?: string | undefined;
+  lang?: string | undefined;
+  depth?: number | undefined;
+  ordered?: boolean | undefined;
+  start?: number | null | undefined;
+  align?: Array<string | null> | undefined;
+  children?: Array<MarkdownNode> | undefined;
+}
+
+interface InlineStyle {
+  isBold: boolean;
+  isItalic: boolean;
+  isCode: boolean;
+  isStrikethrough: boolean;
+}
+
+const BASE_STYLE: InlineStyle = {
+  isBold: false,
+  isItalic: false,
+  isCode: false,
+  isStrikethrough: false,
+};
+
+function collectInlines(
+  nodes: Array<MarkdownNode>,
+  style: InlineStyle,
+  into: Array<MarkdownInline>,
+): void {
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text":
+        if (node.value) {
+          into.push({
+            text: node.value,
+            isBold: style.isBold,
+            isItalic: style.isItalic,
+            isStrikethrough: style.isStrikethrough,
+          });
+        }
+        break;
+
+      case "inlineCode":
+        into.push({
+          text: node.value || "",
+          isCode: true,
+          isBold: style.isBold,
+          isItalic: style.isItalic,
+        });
+        break;
+
+      case "strong":
+        collectInlines(node.children || [], { ...style, isBold: true }, into);
+        break;
+
+      case "emphasis":
+        collectInlines(node.children || [], { ...style, isItalic: true }, into);
+        break;
+
+      case "delete":
+        collectInlines(
+          node.children || [],
+          { ...style, isStrikethrough: true },
+          into,
+        );
+        break;
+
+      case "break":
+        into.push({ text: "\n" });
+        break;
+
+      /*
+       * Links and images should already have been rewritten into text by the
+       * neutralizer before this runs. If one survives, keep its text and drop
+       * the destination rather than carrying a live URL forward.
+       */
+      case "link":
+      case "image":
+      case "linkReference":
+      case "imageReference":
+        collectInlines(node.children || [], style, into);
+        break;
+
+      default:
+        if (node.children) {
+          collectInlines(node.children, style, into);
+        } else if (node.value) {
+          into.push({ text: node.value, isBold: style.isBold });
+        }
+        break;
+    }
+  }
+}
+
+function inlinesOf(nodes: Array<MarkdownNode>): Array<MarkdownInline> {
+  const inlines: Array<MarkdownInline> = [];
+  collectInlines(nodes, BASE_STYLE, inlines);
+  return inlines;
+}
+
+function plainTextOf(nodes: Array<MarkdownNode>): string {
+  return inlinesOf(nodes)
+    .map((inline: MarkdownInline) => {
+      return inline.text;
+    })
+    .join("");
+}
+
+function tableToBlock(node: MarkdownNode): MarkdownBlock {
+  const rows: Array<Array<string>> = (node.children || []).map(
+    (row: MarkdownNode) => {
+      return (row.children || []).map((cell: MarkdownNode) => {
+        return plainTextOf(cell.children || []);
+      });
+    },
+  );
+
+  const headers: Array<string> =
+    rows.length > 0 ? (rows[0] as Array<string>) : [];
+
+  const alignments: Array<"left" | "right" | "center"> = (node.align || []).map(
+    (align: string | null) => {
+      if (align === "right") {
+        return "right";
+      }
+      if (align === "center") {
+        return "center";
+      }
+      return "left";
+    },
+  );
+
+  return {
+    type: MarkdownBlockType.Table,
+    headers: headers,
+    rows: rows.slice(1),
+    alignments: alignments,
+  };
+}
+
+function flattenList(
+  node: MarkdownNode,
+  indent: number,
+  into: Array<MarkdownBlock>,
+): void {
+  const isOrdered: boolean = node.ordered === true;
+  let counter: number = typeof node.start === "number" ? node.start : 1;
+
+  for (const item of node.children || []) {
+    const inlines: Array<MarkdownInline> = [];
+    const nested: Array<MarkdownBlock> = [];
+
+    for (const child of item.children || []) {
+      if (child.type === "list") {
+        flattenList(child, indent + 1, nested);
+      } else if (child.type === "paragraph") {
+        // Multiple paragraphs in one item are joined by a soft break.
+        if (inlines.length > 0) {
+          inlines.push({ text: "\n" });
+        }
+        collectInlines(child.children || [], BASE_STYLE, inlines);
+      } else {
+        toBlocks(child, nested, indent + 1);
+      }
+    }
+
+    into.push({
+      type: MarkdownBlockType.ListItem,
+      inlines: inlines,
+      indent: indent,
+      marker: isOrdered ? `${counter}.` : "-",
+    });
+    into.push(...nested);
+
+    counter++;
+  }
+}
+
+function toBlocks(
+  node: MarkdownNode,
+  into: Array<MarkdownBlock>,
+  indent: number = 0,
+): void {
+  switch (node.type) {
+    case "heading":
+      into.push({
+        type: MarkdownBlockType.Heading,
+        level: node.depth || 1,
+        inlines: inlinesOf(node.children || []),
+      });
+      break;
+
+    case "paragraph":
+      into.push({
+        type: MarkdownBlockType.Paragraph,
+        inlines: inlinesOf(node.children || []),
+        indent: indent,
+      });
+      break;
+
+    case "list":
+      flattenList(node, indent, into);
+      break;
+
+    case "code":
+      into.push({
+        type: MarkdownBlockType.Code,
+        code: node.value || "",
+        language: node.lang || "",
+      });
+      break;
+
+    case "blockquote":
+      for (const child of node.children || []) {
+        const quoted: Array<MarkdownBlock> = [];
+        toBlocks(child, quoted, indent);
+        for (const block of quoted) {
+          into.push({ ...block, type: MarkdownBlockType.Quote });
+        }
+      }
+      break;
+
+    case "table":
+      into.push(tableToBlock(node));
+      break;
+
+    case "thematicBreak":
+      into.push({ type: MarkdownBlockType.Rule });
+      break;
+
+    case "html":
+      // Raw HTML is inert text here; show it rather than silently dropping it.
+      if (node.value) {
+        into.push({
+          type: MarkdownBlockType.Paragraph,
+          inlines: [{ text: node.value }],
+          indent: indent,
+        });
+      }
+      break;
+
+    default:
+      if (node.children) {
+        for (const child of node.children) {
+          toBlocks(child, into, indent);
+        }
+      }
+      break;
+  }
+}
+
+export default function parseMarkdownBlocks(
+  text: string,
+): Array<MarkdownBlock> {
+  if (!text) {
+    return [];
+  }
+
+  try {
+    const tree: MarkdownNode = unified()
+      .use(remarkParse)
+      .use(remarkGfm)
+      .parse(text) as unknown as MarkdownNode;
+
+    const blocks: Array<MarkdownBlock> = [];
+    for (const child of tree.children || []) {
+      toBlocks(child, blocks);
+    }
+    return blocks;
+  } catch {
+    // A parse failure should still show the answer, just without formatting.
+    return [{ type: MarkdownBlockType.Paragraph, inlines: [{ text: text }] }];
+  }
+}

package/UI/Utils/AIChatExport/MarkdownSafety.ts

@@ -0,0 +1,215 @@
+import { gfmToMarkdown } from "mdast-util-gfm";
+import { toMarkdown } from "mdast-util-to-markdown";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+
+/*
+ * Neutralizes the exfiltration channels in assistant markdown before it is
+ * written to an exported file.
+ *
+ * The chat UI already does this on screen: SafeChatMarkdown renders through
+ * MarkdownViewer in safeMode, which drops every href and never emits an <img>.
+ * The reason is that an assistant answer is derived from attacker-influenceable
+ * telemetry (a log body or exception message can carry markdown), so a
+ * prompt-injected response must not be able to render a tracking pixel or hand
+ * the reader a clickable exfil URL. An export that turned those back into live
+ * links would reopen that hole in a file that then gets shared around, so the
+ * exports hold the same line.
+ *
+ * Unlike the on-screen path we keep the URL visible — a reader auditing a
+ * transcript should be able to see where a link pointed — but only ever as
+ * inert text. In markdown that means wrapping it in a code span: a bare URL in
+ * a .md file would otherwise be turned back into a live link by GFM's autolink
+ * literals, which is precisely what we are trying to prevent.
+ *
+ * This works on the PARSED tree rather than by regex over the raw string, for
+ * the same reason MarkdownViewer does: no CommonMark edge case (reference
+ * links, autolinks, raw HTML, nesting) can slip a link past a parser, whereas
+ * regexes miss those forms routinely.
+ */
+
+/*
+ * A structural view of the mdast nodes we touch. Declared locally rather than
+ * imported from @types/mdast: the version hoisted into Common/node_modules is
+ * v3 (pulled in by slackify-markdown's old unified 9 tree) while the mdast-util
+ * packages here expect v4, so importing those types would fight the resolver
+ * for no benefit.
+ */
+interface MarkdownNode {
+  type: string;
+  value?: string | undefined;
+  url?: string | undefined;
+  alt?: string | null | undefined;
+  identifier?: string | undefined;
+  children?: Array<MarkdownNode> | undefined;
+}
+
+type MarkdownRoot = Parameters<typeof toMarkdown>[0];
+
+// Node types that may only appear inside a block, never directly under the root.
+const PHRASING_TYPES: Set<string> = new Set(["text", "inlineCode"]);
+
+function textNode(value: string): MarkdownNode {
+  return { type: "text", value: value };
+}
+
+function codeNode(value: string): MarkdownNode {
+  return { type: "inlineCode", value: value };
+}
+
+// The visible text of a subtree, used to decide whether a label adds anything.
+function textOf(nodes: Array<MarkdownNode>): string {
+  return nodes
+    .map((node: MarkdownNode) => {
+      if (node.type === "text" || node.type === "inlineCode") {
+        return node.value || "";
+      }
+      return node.children ? textOf(node.children) : "";
+    })
+    .join("");
+}
+
+/*
+ * "label (`url`)" — or just "`url`" when the label is only a repeat of the URL,
+ * which is what an autolink or a GFM bare URL parses into.
+ */
+function inertLink(
+  label: Array<MarkdownNode>,
+  url: string,
+): Array<MarkdownNode> {
+  const labelText: string = textOf(label);
+  const hasDistinctLabel: boolean = Boolean(labelText) && labelText !== url;
+
+  if (!url) {
+    return hasDistinctLabel ? label : [textNode(labelText)];
+  }
+
+  if (!hasDistinctLabel) {
+    return [codeNode(url)];
+  }
+
+  return [...label, textNode(" ("), codeNode(url), textNode(")")];
+}
+
+function neutralizeNode(
+  node: MarkdownNode,
+  definitions: Map<string, string>,
+  isRootChild: boolean,
+): Array<MarkdownNode> {
+  // Depth first, so a link nested inside emphasis is rewritten before its parent.
+  if (node.children) {
+    const rewritten: Array<MarkdownNode> = [];
+    for (const child of node.children) {
+      rewritten.push(...neutralizeNode(child, definitions, false));
+    }
+    node.children = rewritten;
+  }
+
+  const identifier: string = (node.identifier || "").toLowerCase();
+
+  switch (node.type) {
+    /*
+     * Drop link definitions outright. Their referents have already been
+     * inlined below, and leaving a definition behind would let "[x][ref]"
+     * resolve to a live link again.
+     */
+    case "definition":
+      return [];
+
+    /*
+     * Raw HTML is inert on screen (react-markdown does not render it without
+     * rehype-raw), but a .md file is rendered by viewers that do, where an
+     * <img src> or <a href> would be live. Demote it to text — toMarkdown
+     * escapes the angle brackets on the way out.
+     */
+    case "html": {
+      const asText: MarkdownNode = textNode(node.value || "");
+      return isRootChild
+        ? [{ type: "paragraph", children: [asText] }]
+        : [asText];
+    }
+
+    case "link":
+      return inertLink(node.children || [], node.url || "");
+
+    case "image":
+      return inertLink(
+        [textNode(`[image: ${node.alt || ""}]`)],
+        node.url || "",
+      );
+
+    case "linkReference":
+      return inertLink(node.children || [], definitions.get(identifier) || "");
+
+    case "imageReference":
+      return inertLink(
+        [textNode(`[image: ${node.alt || ""}]`)],
+        definitions.get(identifier) || "",
+      );
+
+    default:
+      return [node];
+  }
+}
+
+function collectDefinitions(
+  node: MarkdownNode,
+  into: Map<string, string>,
+): void {
+  if (node.type === "definition" && node.identifier) {
+    into.set(node.identifier.toLowerCase(), node.url || "");
+  }
+  for (const child of node.children || []) {
+    collectDefinitions(child, into);
+  }
+}
+
+/*
+ * Rewrites every link, image and raw HTML node in `text` into inert text, and
+ * returns the result as markdown. Safe to call on any string; a parse failure
+ * degrades to a fenced code block rather than emitting unneutralized markdown.
+ */
+export default function neutralizeAssistantMarkdown(text: string): string {
+  if (!text) {
+    return "";
+  }
+
+  try {
+    const tree: MarkdownNode = unified()
+      .use(remarkParse)
+      .use(remarkGfm)
+      .parse(text) as unknown as MarkdownNode;
+
+    const definitions: Map<string, string> = new Map();
+    collectDefinitions(tree, definitions);
+
+    const children: Array<MarkdownNode> = [];
+    for (const child of tree.children || []) {
+      children.push(...neutralizeNode(child, definitions, true));
+    }
+
+    /*
+     * A root child demoted to phrasing (a stray inline node left behind once
+     * its link wrapper was removed) is not valid at root level; wrap it back
+     * into a paragraph so the serializer stays on its typed path.
+     */
+    tree.children = children.map((child: MarkdownNode) => {
+      return PHRASING_TYPES.has(child.type)
+        ? { type: "paragraph", children: [child] }
+        : child;
+    });
+
+    return toMarkdown(tree as unknown as MarkdownRoot, {
+      extensions: [gfmToMarkdown()],
+      bullet: "-",
+    }).trim();
+  } catch {
+    /*
+     * Never fall back to returning the raw string: that would ship exactly the
+     * live links this function exists to remove. A fence renders the content
+     * verbatim and inert.
+     */
+    return ["```", text.replace(/```/g, "'''"), "```"].join("\n");
+  }
+}