Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
feat: slack rich text notes (#2835)
Maximilian Kaskeea25dca7f460
diff --git a/apps/dashboard/src/components/content/process-message.tsx b/apps/dashboard/src/components/content/process-message.tsxindex 791a1f8e9..23deb35e4 100644--- a/apps/dashboard/src/components/content/process-message.tsx+++ b/apps/dashboard/src/components/content/process-message.tsx@@ -2,6 +2,7 @@ import type { AnchorHTMLAttributes } from "react";import { Fragment, createElement } from "react";import { jsx, jsxs } from "react/jsx-runtime";import rehypeReact from "rehype-react";+import remarkGfm from "remark-gfm";import remarkParse from "remark-parse";import remarkRehype from "remark-rehype";import { unified } from "unified";@@ -9,6 +10,7 @@ import { unified } from "unified";export function ProcessMessage({ value }: { value: string }) {const result = unified().use(remarkParse)+ .use(remarkGfm).use(remarkRehype).use(rehypeReact, {createElement,diff --git a/apps/server/src/libs/test/doubles/slack-test-state.ts b/apps/server/src/libs/test/doubles/slack-test-state.tsindex 4698fddb5..7519e052c 100644--- a/apps/server/src/libs/test/doubles/slack-test-state.ts+++ b/apps/server/src/libs/test/doubles/slack-test-state.ts@@ -26,6 +26,8 @@ export interface SlackTestState {usersInfoImpl: (args: Record<string, unknown>) => Promise<unknown>;/** `reactions.get` result; the default message has no reactions. */reactionsGetImpl: (args: Record<string, unknown>) => Promise<unknown>;+ /** `conversations.info` result; the default channel has no name. */+ conversationsInfoImpl: (args: Record<string, unknown>) => Promise<unknown>;}const g = globalThis as Record<string, unknown>;@@ -52,6 +54,7 @@ if (!g.__slackTestState) {}),usersInfoImpl: () => Promise.resolve({ ok: true, user: { profile: {} } }),reactionsGetImpl: () => Promise.resolve({ ok: true, message: {} }),+ conversationsInfoImpl: () => Promise.resolve({ ok: true, channel: {} }),} satisfies SlackTestState;}diff --git a/apps/server/src/libs/test/doubles/slack-web-api.mock.ts b/apps/server/src/libs/test/doubles/slack-web-api.mock.tsindex 01a73fc12..dc301130a 100644--- a/apps/server/src/libs/test/doubles/slack-web-api.mock.ts+++ b/apps/server/src/libs/test/doubles/slack-web-api.mock.ts@@ -81,6 +81,10 @@ export class WebClient {s.calls.push({ method: "conversations.history", args });return s.historyImpl();},+ info: (args: Record<string, unknown>) => {+ s.calls.push({ method: "conversations.info", args });+ return s.conversationsInfoImpl(args);+ },};agents = {sessions: {diff --git a/apps/server/src/routes/slack/handler.test.ts b/apps/server/src/routes/slack/handler.test.tsindex 425aab02e..8b8cd958e 100644--- a/apps/server/src/routes/slack/handler.test.ts+++ b/apps/server/src/routes/slack/handler.test.ts@@ -2043,6 +2043,8 @@ describe("incident channel events", () => {resetSlackTestState();slackTestState.reactionsGetImpl = () =>Promise.resolve({ ok: true, message: {} });+ slackTestState.conversationsInfoImpl = () =>+ Promise.resolve({ ok: true, channel: {} });channelId = `C_PIN_${crypto.randomUUID()}`;const [row] = await db.insert(incident)@@ -2101,6 +2103,165 @@ describe("incident channel events", () => {expect(rows[0].message).toContain("https://slack.test/archives/");});+ test("rich_text wins over mrkdwn: emoji, styles, mentions and channels", async () => {+ // U1 is the pinner and must stay linked; U9 has no email, so the+ // profile name is the only thing we know about them.+ slackTestState.usersInfoImpl = (args) =>+ Promise.resolve(+ args.user === "U9"+ ? { ok: true, user: { real_name: "Jane Doe", profile: {} } }+ : { ok: true, user: { profile: { email: "[email protected]" } } },+ );+ slackTestState.conversationsInfoImpl = () =>+ Promise.resolve({ ok: true, channel: { name: "inc-db" } });+ slackTestState.historyImpl = () =>+ Promise.resolve({+ messages: [+ {+ ts: "503.1",+ user: "U2",+ text: "*rolled back* :face_holding_back_tears: <@U9> see <#C7|inc-db>",+ blocks: [+ {+ type: "rich_text",+ elements: [+ {+ type: "rich_text_section",+ elements: [+ {+ type: "text",+ text: "rolled back",+ style: { bold: true },+ },+ { type: "text", text: " " },+ {+ type: "emoji",+ name: "face_holding_back_tears",+ unicode: "1f979",+ },+ { type: "text", text: " " },+ { type: "user", user_id: "U9" },+ { type: "text", text: " see " },+ { type: "channel", channel_id: "C7" },+ ],+ },+ ],+ },+ ],+ },+ ],+ });+ await pin("503.1");+ await waitForCall("reactions.add");+ const rows = await notes();+ expect(rows).toHaveLength(1);+ expect(rows[0].message).toContain(+ "**rolled back** 🥹 @Jane Doe see #inc-db",+ );+ expect(rows[0].message).not.toContain(":face_holding_back_tears:");+ });++ test("a mention whose lookup fails keeps the raw id", async () => {+ slackTestState.usersInfoImpl = (args) =>+ args.user === "U9"+ ? Promise.reject(new Error("user_not_found"))+ : Promise.resolve({+ ok: true,+ user: { profile: { email: "[email protected]" } },+ });+ slackTestState.historyImpl = () =>+ Promise.resolve({+ messages: [+ {+ ts: "504.1",+ text: "<@U9> ack",+ blocks: [+ {+ type: "rich_text",+ elements: [+ {+ type: "rich_text_section",+ elements: [+ { type: "user", user_id: "U9" },+ { type: "text", text: " ack" },+ ],+ },+ ],+ },+ ],+ },+ ],+ });+ await pin("504.1");+ await waitForCall("reactions.add");+ const rows = await notes();+ expect(rows).toHaveLength(1);+ expect(rows[0].message).toContain("@U9 ack");+ });++ test("the note keeps the time the message was said", async () => {+ const saidAt = Math.floor(Date.now() / 1000) - 3600;+ const ts = `${saidAt}.000100`;+ slackTestState.historyImpl = () =>+ Promise.resolve({ messages: [{ ts, text: "an hour ago" }] });+ await pin(ts);+ await waitForCall("reactions.add");+ const rows = await notes();+ expect(rows).toHaveLength(1);+ expect(Math.abs(rows[0].createdAt.getTime() - saidAt * 1000)).toBeLessThan(+ 1000,+ );+ });++ test("a message with only attachments is noted from their fallback", async () => {+ slackTestState.historyImpl = () =>+ Promise.resolve({+ messages: [+ {+ ts: "505.1",+ text: "",+ attachments: [{ fallback: "[FIRING] db latency > 2s" }],+ },+ ],+ });+ await pin("505.1");+ await waitForCall("reactions.add");+ const rows = await notes();+ expect(rows).toHaveLength(1);+ expect(rows[0].message).toContain("[FIRING] db latency > 2s");+ });++ test("an attachment with an empty fallback is noted from its text", async () => {+ slackTestState.historyImpl = () =>+ Promise.resolve({+ messages: [+ {+ ts: "507.1",+ text: "",+ attachments: [{ fallback: "", text: "Deploy 1234 failed" }],+ },+ ],+ });+ await pin("507.1");+ await waitForCall("reactions.add");+ const rows = await notes();+ expect(rows).toHaveLength(1);+ expect(rows[0].message).toContain("Deploy 1234 failed");+ });++ test("a message with nothing to copy tells the pinner", async () => {+ slackTestState.historyImpl = () =>+ Promise.resolve({ messages: [{ ts: "506.1", text: "" }] });+ await pin("506.1");+ const ephemeral = await waitForCall("postEphemeral");+ expect(ephemeral?.args.text).toContain("Nothing to copy");+ await new Promise((r) => setTimeout(r, 50));+ expect(slackTestState.calls.some((c) => c.method === "reactions.add")).toBe(+ false,+ );+ expect(await notes()).toHaveLength(0);+ });+test("a message already confirmed is not noted twice", async () => {slackTestState.historyImpl = () =>Promise.resolve({ messages: [{ ts: "501.1", text: "Twice" }] });diff --git a/apps/server/src/routes/slack/incident-events.ts b/apps/server/src/routes/slack/incident-events.tsindex bbf612501..a7467407d 100644--- a/apps/server/src/routes/slack/incident-events.ts+++ b/apps/server/src/routes/slack/incident-events.ts@@ -3,6 +3,7 @@ import type { ServiceContext } from "@openstatus/services";import {addIncidentNote,getIncidentBySlackChannel,+ isAllowedNoteCreatedAt,unbindIncidentSlackChannel,} from "@openstatus/services/incident";import { WebClient } from "@slack/web-api";@@ -17,6 +18,12 @@ import {requireSlackMember,slackAgentAllowed,} from "./require-slack-member";+import { resolveSlackMentionNames } from "./resolve-slack-user";+import {+ collectMentions,+ mentionLabelsFromText,+ richTextToMarkdown,+} from "./rich-text";import type { SlackWorkspace } from "./workspace-resolver";const logger = getLogger(["api-server", "slack", "incident-events"]);@@ -24,7 +31,67 @@ const logger = getLogger(["api-server", "slack", "incident-events"]);const PIN = "pushpin";const DONE = "white_check_mark";-type SlackMessage = { ts?: string; text?: string; user?: string };+type SlackMessage = {+ ts?: string;+ text?: string;+ user?: string;+ blocks?: unknown[];+ attachments?: { text?: string; fallback?: string }[];+};++const NOTHING_TO_COPY = "Nothing to copy from that message.";+const VERB_LAG_MS = 60_000;++/**+ * A Slack `ts` ("1759300000.123456") as the time the message was said, or+ * `undefined` (now) when the verb would reject it as outside its window.+ */+function messageDate(ts: string): Date | undefined {+ const date = new Date(Number(ts) * 1000);+ const now = Date.now();+ // The verb samples its own `now` a moment later; a boundary message must+ // pass both, or the pin would fail instead of falling back to now.+ return isAllowedNoteCreatedAt(date, now) &&+ isAllowedNoteCreatedAt(date, now + VERB_LAG_MS)+ ? date+ : undefined;+}++/** Alert bots post `attachments` with an empty `text`. */+function attachmentsText(message: SlackMessage): string {+ return (message.attachments ?? [])+ .map((a) => a.fallback?.trim() || a.text?.trim() || "")+ .filter(Boolean)+ .join("\n\n");+}++async function noteBody(args: {+ resolved: SlackWorkspace;+ teamId: string;+ slack: WebClient;+ message: SlackMessage;+}): Promise<string> {+ const { resolved, teamId, slack, message } = args;+ const labels = mentionLabelsFromText(message.text);+ const lookedUp = await resolveSlackMentionNames({+ workspace: resolved.workspace,+ teamId,+ slack,+ ...collectMentions(message.blocks),+ });+ // A looked-up name beats the label Slack put in `text`.+ const names = {+ users: new Map([...(labels.users ?? []), ...(lookedUp.users ?? [])]),+ channels: new Map([+ ...(labels.channels ?? []),+ ...(lookedUp.channels ?? []),+ ]),+ usergroups: labels.usergroups,+ };+ const body =+ richTextToMarkdown(message.blocks, names) ?? message.text?.trim() ?? "";+ return body || attachmentsText(message);+}function system(resolved: SlackWorkspace): ServiceContext {return {@@ -131,8 +198,21 @@ export async function handlePinReaction(args: {try {if (await alreadyNoted(slack, channel, ts, resolved.botUserId)) return;const message = await findMessage(slack, channel, ts);- if (!message?.text) {+ const body = message+ ? await noteBody({ resolved, teamId, slack, message })+ : "";+ if (!body) {await redis.del(claim);+ await slack.chat+ .postEphemeral({+ channel,+ user: slackUserId,+ thread_ts: ts,+ text: NOTHING_TO_COPY,+ })+ .catch((error) =>+ logger.warn("slack failed to report an empty pin", { error }),+ );return;}const permalink = await slack.chat@@ -145,9 +225,8 @@ export async function handlePinReaction(args: {ctx,input: {id: bound.id,- message: permalink- ? `${message.text}\n\n[From Slack](${permalink})`- : message.text,+ message: permalink ? `${body}\n\n[From Slack](${permalink})` : body,+ createdAt: messageDate(ts),},});trackSlackIncident(ctx, "note", { via: "reaction" });diff --git a/apps/server/src/routes/slack/resolve-slack-user.ts b/apps/server/src/routes/slack/resolve-slack-user.tsindex c65d58b73..ea3ada793 100644--- a/apps/server/src/routes/slack/resolve-slack-user.ts+++ b/apps/server/src/routes/slack/resolve-slack-user.ts@@ -1,55 +1,144 @@import { getLogger } from "@logtape/logtape";import type { Workspace } from "@openstatus/db/src/schema/workspaces/validation";import type { ServiceContext } from "@openstatus/services";-import { findMemberIdByEmail } from "@openstatus/services/member";+import {+ findMemberIdByEmail,+ getMemberDisplayName,+} from "@openstatus/services/member";import {createSlackUserMapping,getSlackUserMapping,} from "@openstatus/services/slack-user";import type { WebClient } from "@slack/web-api";+import type { MentionNames } from "./rich-text";+const logger = getLogger(["api-server", "slack", "resolve-user"]);/**- * The openstatus member linked to a Slack user, or `null`. A missing link is- * created on the spot when the Slack profile email matches exactly one member.+ * One `users.info` serves both the email match and the fallback name. Links+ * the Slack user to the member on an email match, so merely being mentioned+ * in a pinned message can create the mapping; it is the same rule applied+ * when they act themselves.*/-export async function resolveSlackMember(args: {+async function lookupSlackMember(args: {workspace: Workspace;teamId: string;slackUserId: string;slack: WebClient;-}): Promise<number | null> {+}): Promise<{ userId: number | null; profileName: string | null }> {const { workspace, teamId, slackUserId, slack } = args;- if (!teamId || !slackUserId) return null;+ if (!teamId || !slackUserId) return { userId: null, profileName: null };const ctx: ServiceContext = {workspace,actor: { type: "system", job: "slack-user-automap" },};+ let profileName: string | null = null;try {const linked = await getSlackUserMapping({ctx,input: { teamId, slackUserId },});- if (linked !== null) return linked;+ if (linked !== null) return { userId: linked, profileName };const info = await slack.users.info({ user: slackUserId });+ profileName =+ info.user?.profile?.display_name ||+ info.user?.real_name ||+ info.user?.name ||+ null;const email = info.user?.profile?.email;- if (!email) return null;+ if (!email) return { userId: null, profileName };const userId = await findMemberIdByEmail({ ctx, input: { email } });- if (userId === null) return null;+ if (userId === null) return { userId: null, profileName };await createSlackUserMapping({ctx,input: { teamId, slackUserId, userId },});- return userId;+ return { userId, profileName };} catch (err) {logger.warn("slack user resolution failed", {workspaceId: workspace.id,teamId,error: err instanceof Error ? err.message : String(err),});- return null;+ return { userId: null, profileName };}}++/**+ * The openstatus member linked to a Slack user, or `null`. A missing link is+ * created on the spot when the Slack profile email matches exactly one member.+ */+export async function resolveSlackMember(args: {+ workspace: Workspace;+ teamId: string;+ slackUserId: string;+ slack: WebClient;+}): Promise<number | null> {+ return (await lookupSlackMember(args)).userId;+}++// A pinned message rarely mentions more than a handful of people; Slack+// rate-limits `users.info`/`conversations.info`, so look them up a few at a time.+const MAX_MENTIONS = 20;+const LOOKUP_CONCURRENCY = 5;++async function forEachBounded<T>(+ items: T[],+ fn: (item: T) => Promise<void>,+): Promise<void> {+ for (let i = 0; i < items.length; i += LOOKUP_CONCURRENCY) {+ await Promise.all(items.slice(i, i + LOOKUP_CONCURRENCY).map(fn));+ }+}++/**+ * Names for the users and channels a message mentions: a linked member's+ * openstatus name, else the Slack profile name, else nothing (the caller+ * keeps the raw id). Lookups that fail are dropped, never thrown.+ */+export async function resolveSlackMentionNames(args: {+ workspace: Workspace;+ teamId: string;+ slack: WebClient;+ users: string[];+ channels: string[];+}): Promise<MentionNames> {+ const { workspace, teamId, slack } = args;+ const ctx: ServiceContext = {+ workspace,+ actor: { type: "system", job: "slack-user-automap" },+ };+ const users = new Map<string, string>();+ const channels = new Map<string, string>();++ await Promise.all([+ forEachBounded(args.users.slice(0, MAX_MENTIONS), async (slackUserId) => {+ const { userId, profileName } = await lookupSlackMember({+ workspace,+ teamId,+ slackUserId,+ slack,+ });+ const memberName =+ userId === null+ ? null+ : await getMemberDisplayName({ ctx, input: { userId } }).catch(+ () => null,+ );+ const name = memberName ?? profileName;+ if (name) users.set(slackUserId, name);+ }),+ forEachBounded(args.channels.slice(0, MAX_MENTIONS), async (channelId) => {+ const res = await slack.conversations+ .info({ channel: channelId })+ .catch(() => undefined);+ const name = res?.channel?.name;+ if (name) channels.set(channelId, name);+ }),+ ]);++ return { users, channels };+}diff --git a/apps/server/src/routes/slack/rich-text.test.ts b/apps/server/src/routes/slack/rich-text.test.tsnew file mode 100644index 000000000..6aa5d6128--- /dev/null+++ b/apps/server/src/routes/slack/rich-text.test.ts@@ -0,0 +1,404 @@+import { describe, expect, test } from "@openstatus/test-utils";++import {+ collectMentions,+ mentionLabelsFromText,+ richTextToMarkdown,+} from "./rich-text";++function section(...elements: unknown[]) {+ return { type: "rich_text_section", elements };+}++function message(...elements: unknown[]) {+ return [{ type: "rich_text", elements }];+}++describe("richTextToMarkdown", () => {+ test("returns undefined without a rich_text block", () => {+ expect(richTextToMarkdown(undefined)).toBeUndefined();+ expect(richTextToMarkdown([])).toBeUndefined();+ expect(+ richTextToMarkdown([{ type: "section", text: { type: "mrkdwn" } }]),+ ).toBeUndefined();+ });++ test("renders a standard emoji from its codepoints", () => {+ expect(+ richTextToMarkdown(+ message(+ section(+ { type: "text", text: "oh wow, it syncs omg " },+ {+ type: "emoji",+ name: "face_holding_back_tears",+ unicode: "1f979",+ },+ ),+ ),+ ),+ ).toBe("oh wow, it syncs omg 🥹");+ });++ test("renders a skin-tone sequence", () => {+ expect(+ richTextToMarkdown(+ message(+ section({+ type: "emoji",+ name: "+1",+ skin_tone: 3,+ unicode: "1f44d-1f3fc",+ }),+ ),+ ),+ ).toBe("👍🏼");+ });++ test("keeps a custom emoji as its shortcode", () => {+ expect(+ richTextToMarkdown(+ message(section({ type: "emoji", name: "partyparrot" })),+ ),+ ).toBe(":partyparrot:");+ });++ test("converts styles to markdown", () => {+ expect(+ richTextToMarkdown(+ message(+ section(+ { type: "text", text: "bold", style: { bold: true } },+ { type: "text", text: " " },+ { type: "text", text: "italic", style: { italic: true } },+ { type: "text", text: " " },+ { type: "text", text: "gone", style: { strike: true } },+ { type: "text", text: " " },+ { type: "text", text: "a*b", style: { code: true } },+ ),+ ),+ ),+ ).toBe("**bold** _italic_ ~~gone~~ `a*b`");+ });++ test("keeps surrounding whitespace outside style markers", () => {+ expect(+ richTextToMarkdown(+ message(+ section(+ { type: "text", text: "rolled back ", style: { bold: true } },+ { type: "text", text: "to v41" },+ ),+ ),+ ),+ ).toBe("**rolled back** to v41");+ });++ test("converts links with and without a label", () => {+ expect(+ richTextToMarkdown(+ message(+ section(+ { type: "link", url: "https://example.com/run/1", text: "the run" },+ { type: "text", text: " and " },+ { type: "link", url: "https://example.com" },+ ),+ ),+ ),+ ).toBe("[the run](https://example.com/run/1) and <https://example.com>");+ });++ test("names mentions from the map and falls back to the id", () => {+ expect(+ richTextToMarkdown(+ message(+ section(+ { type: "user", user_id: "U1" },+ { type: "text", text: " ping " },+ { type: "user", user_id: "U2" },+ { type: "text", text: " in " },+ { type: "channel", channel_id: "C1" },+ { type: "text", text: " " },+ { type: "channel", channel_id: "C2" },+ ),+ ),+ {+ users: new Map([["U1", "Maximilian Kaske"]]),+ channels: new Map([["C1", "inc-db"]]),+ },+ ),+ ).toBe("@Maximilian Kaske ping @U2 in #inc-db #C2");+ });++ test("escapes markdown specials in names and plain text", () => {+ expect(+ richTextToMarkdown(+ message(+ section(+ { type: "user", user_id: "U1" },+ { type: "text", text: " said 2*3 is_fine [sic]" },+ ),+ ),+ { users: new Map([["U1", "jo_hn"]]) },+ ),+ ).toBe("@jo\\_hn said 2\\*3 is\\_fine \\[sic\\]");+ });++ test("names a user group from the map and falls back to the id", () => {+ const blocks = message(+ section(+ { type: "usergroup", usergroup_id: "S1" },+ { type: "text", text: " " },+ { type: "usergroup", usergroup_id: "S2" },+ ),+ );+ expect(+ richTextToMarkdown(blocks, {+ usergroups: new Map([["S1", "engineering"]]),+ }),+ ).toBe("@engineering @S2");+ });++ test("renders broadcasts", () => {+ expect(+ richTextToMarkdown(+ message(+ section(+ { type: "broadcast", range: "here" },+ { type: "text", text: " db is back" },+ ),+ ),+ ),+ ).toBe("@here db is back");+ });++ test("renders lists, quotes and code blocks", () => {+ expect(+ richTextToMarkdown(+ message(+ section({ type: "text", text: "Findings:" }),+ {+ type: "rich_text_list",+ style: "bullet",+ elements: [+ section({ type: "text", text: "one" }),+ section({ type: "text", text: "two" }),+ ],+ },+ {+ type: "rich_text_list",+ style: "ordered",+ indent: 1,+ elements: [section({ type: "text", text: "nested" })],+ },+ {+ type: "rich_text_quote",+ elements: [{ type: "text", text: "quoted\nlines" }],+ },+ {+ type: "rich_text_preformatted",+ elements: [{ type: "text", text: "SELECT *\nFROM t;" }],+ },+ ),+ ),+ ).toBe(+ [+ "Findings:",+ "",+ "- one\n- two\n 1. nested",+ "",+ "> quoted\n> lines",+ "",+ "```\nSELECT *\nFROM t;\n```",+ ].join("\n"),+ );+ });++ test("escapes a line-start dash so it does not become a list", () => {+ expect(+ richTextToMarkdown(+ message(section({ type: "text", text: "- not a list" })),+ ),+ ).toBe("\\- not a list");+ });+});++describe("richTextToMarkdown edge cases", () => {+ test("honors the ordered-list offset", () => {+ expect(+ richTextToMarkdown(+ message({+ type: "rich_text_list",+ style: "ordered",+ offset: 2,+ elements: [+ section({ type: "text", text: "third" }),+ section({ type: "text", text: "fourth" }),+ ],+ }),+ ),+ ).toBe("3. third\n4. fourth");+ });++ test("escapes tildes so literal text is not struck through", () => {+ expect(+ richTextToMarkdown(+ message(section({ type: "text", text: "~~not gone~~" })),+ ),+ ).toBe("\\~\\~not gone\\~\\~");+ });++ test("widens code delimiters past the backticks inside", () => {+ expect(+ richTextToMarkdown(+ message(+ section({ type: "text", text: "a `b` c", style: { code: true } }),+ {+ type: "rich_text_preformatted",+ elements: [{ type: "text", text: "```\nx\n```" }],+ },+ ),+ ),+ ).toBe("``a `b` c``\n\n````\n```\nx\n```\n````");+ });++ test("pads inline code that starts or ends with a backtick", () => {+ expect(+ richTextToMarkdown(+ message(section({ type: "text", text: "`x", style: { code: true } })),+ ),+ ).toBe("`` `x ``");+ expect(+ richTextToMarkdown(+ message(section({ type: "text", text: "x`", style: { code: true } })),+ ),+ ).toBe("`` x` ``");+ });++ test("keeps a multi-line list item inside the item", () => {+ expect(+ richTextToMarkdown(+ message(+ {+ type: "rich_text_list",+ style: "ordered",+ offset: 9,+ elements: [section({ type: "text", text: "first\nstill first" })],+ },+ {+ type: "rich_text_list",+ style: "bullet",+ indent: 1,+ elements: [section({ type: "text", text: "a\nb" })],+ },+ ),+ ),+ ).toBe("10. first\n still first\n - a\n b");+ });++ test("escapes block syntax at line start, also inside quotes", () => {+ expect(+ richTextToMarkdown(+ message(+ section({ type: "text", text: "## not a heading\n---\n+ no\n1) no" }),+ {+ type: "rich_text_quote",+ elements: [{ type: "text", text: "# q" }],+ },+ ),+ ),+ ).toBe("\\## not a heading\n\\---\n\\+ no\n\\1) no\n\n> \\# q");+ });++ test("renders a link with an unsafe scheme as plain text", () => {+ expect(+ richTextToMarkdown(+ message(+ section(+ { type: "link", url: "javascript:alert(1)", text: "click" },+ { type: "text", text: " " },+ { type: "link", url: "javascript:alert(1)" },+ { type: "text", text: " " },+ { type: "link", url: "mailto:[email protected]" },+ ),+ ),+ ),+ ).toBe("click javascript:alert(1) <mailto:[email protected]>");+ });++ test("encodes spaces and parentheses in link destinations", () => {+ expect(+ richTextToMarkdown(+ message(+ section(+ { type: "link", url: "https://w.org/wiki/Foo_(bar)", text: "wiki" },+ { type: "text", text: " " },+ { type: "link", url: "https://e.com/a b" },+ ),+ ),+ ),+ ).toBe("[wiki](https://w.org/wiki/Foo_%28bar%29) <https://e.com/a%20b>");+ });+});++describe("mentionLabelsFromText", () => {+ test("harvests the labels Slack spelled out in mrkdwn", () => {+ const names = mentionLabelsFromText(+ "<@U1|max> ping <!subteam^S1|@engineering> in <#C1|inc-db> and <#C2>",+ );+ expect(names.users).toEqual(new Map([["U1", "max"]]));+ expect(names.usergroups).toEqual(new Map([["S1", "engineering"]]));+ expect(names.channels).toEqual(new Map([["C1", "inc-db"]]));+ });++ test("is empty without text", () => {+ expect(mentionLabelsFromText(undefined).users?.size).toBe(0);+ });+});++describe("collectMentions", () => {+ test("dedupes user and channel ids across blocks", () => {+ expect(+ collectMentions(+ message(+ section(+ { type: "user", user_id: "U1" },+ { type: "channel", channel_id: "C1" },+ ),+ {+ type: "rich_text_quote",+ elements: [+ { type: "user", user_id: "U1" },+ { type: "user", user_id: "U2" },+ ],+ },+ ),+ ),+ ).toEqual({ users: ["U1", "U2"], channels: ["C1"] });+ });++ test("is empty without rich_text", () => {+ expect(collectMentions(undefined)).toEqual({ users: [], channels: [] });+ });++ test("finds mentions inside list items", () => {+ const blocks = message({+ type: "rich_text_list",+ style: "bullet",+ elements: [+ section(+ { type: "user", user_id: "U5" },+ { type: "text", text: " owns it" },+ ),+ section({ type: "channel", channel_id: "C5" }),+ ],+ });+ expect(collectMentions(blocks)).toEqual({+ users: ["U5"],+ channels: ["C5"],+ });+ expect(+ richTextToMarkdown(blocks, { users: new Map([["U5", "Sam"]]) }),+ ).toBe("- @Sam owns it\n- #C5");+ });+});diff --git a/apps/server/src/routes/slack/rich-text.ts b/apps/server/src/routes/slack/rich-text.tsnew file mode 100644index 000000000..1830125d1--- /dev/null+++ b/apps/server/src/routes/slack/rich-text.ts@@ -0,0 +1,316 @@+/**+ * Slack attaches `rich_text` blocks to every user-typed message. They carry+ * what `message.text` (mrkdwn) loses: emoji codepoints, structured mentions+ * and links, styles. Convert them to the markdown the timeline renders.+ *+ * Structural types instead of `@slack/types`: the package is only a+ * transitive dep and the fields used here are stable.+ */++type Style = {+ bold?: boolean;+ italic?: boolean;+ strike?: boolean;+ code?: boolean;+};++type InlineElement =+ | { type: "text"; text: string; style?: Style }+ | { type: "emoji"; name: string; unicode?: string; style?: Style }+ | { type: "link"; url: string; text?: string; style?: Style }+ | { type: "user"; user_id: string; style?: Style }+ | { type: "channel"; channel_id: string; style?: Style }+ | { type: "usergroup"; usergroup_id: string; style?: Style }+ | { type: "broadcast"; range: string; style?: Style }+ | { type: "date"; fallback?: string; style?: Style }+ | { type: "color"; value: string; style?: Style };++type Section = { type: "rich_text_section"; elements: InlineElement[] };+type List = {+ type: "rich_text_list";+ style: "bullet" | "ordered";+ indent?: number;+ offset?: number;+ elements: Section[];+};+type Quote = { type: "rich_text_quote"; elements: InlineElement[] };+type Preformatted = {+ type: "rich_text_preformatted";+ elements: InlineElement[];+};+type RichTextElement = Section | List | Quote | Preformatted;+type RichTextBlock = { type: "rich_text"; elements: RichTextElement[] };++export type MentionNames = {+ users?: Map<string, string>;+ channels?: Map<string, string>;+ usergroups?: Map<string, string>;+};++// `<@U1|max>`, `<#C1|inc-db>`, `<!subteam^S1|@engineering>` in mrkdwn `text`.+const LABELLED_MENTION = /<([@#]|!subteam\^)([A-Z0-9]+)\|@?([^>|]+)>/g;++/**+ * Names Slack already spelled out in `message.text`. The only source for a+ * user group's handle, since `rich_text` carries just its id and reading+ * groups would need a scope we do not request.+ */+export function mentionLabelsFromText(text: string | undefined): MentionNames {+ const names: Required<MentionNames> = {+ users: new Map(),+ channels: new Map(),+ usergroups: new Map(),+ };+ for (const match of (text ?? "").matchAll(LABELLED_MENTION)) {+ const [, kind, id, label] = match;+ const target =+ kind === "@"+ ? names.users+ : kind === "#"+ ? names.channels+ : names.usergroups;+ target.set(id, label.trim());+ }+ return names;+}++function isRichTextBlock(block: unknown): block is RichTextBlock {+ return (+ typeof block === "object" &&+ block !== null &&+ (block as { type?: unknown }).type === "rich_text" &&+ Array.isArray((block as { elements?: unknown }).elements)+ );+}++function richTextBlocks(blocks: unknown[] | undefined): RichTextBlock[] {+ return (blocks ?? []).filter(isRichTextBlock);+}++/** A list's children are sections; everything else holds inlines directly. */+function inlinesOf(element: RichTextElement): InlineElement[] {+ if (element.type === "rich_text_list") {+ return element.elements.flatMap((item) => item.elements ?? []);+ }+ return element.elements ?? [];+}++/** Every user and channel id mentioned, deduplicated, for the caller to resolve. */+export function collectMentions(blocks: unknown[] | undefined): {+ users: string[];+ channels: string[];+} {+ const users = new Set<string>();+ const channels = new Set<string>();+ for (const block of richTextBlocks(blocks)) {+ for (const element of block.elements) {+ for (const inline of inlinesOf(element)) {+ if (inline.type === "user") users.add(inline.user_id);+ if (inline.type === "channel") channels.add(inline.channel_id);+ }+ }+ }+ return { users: [...users], channels: [...channels] };+}++// Only what remark would otherwise interpret; `#`, `>`, `-` matter at line start.+const INLINE_SPECIALS = /[\\`*_~[\]]/g;+const LINE_START_SPECIALS =+ /^(\s*)(#{1,6}|>|[-+]|-{3,}|={3,}|\d+[.)])(?=\s|$)/gm;++function escapeText(text: string): string {+ return text+ .replace(INLINE_SPECIALS, "\\$&")+ .replace(LINE_START_SPECIALS, "$1\\$2");+}++function longestBacktickRun(text: string): number {+ let max = 0;+ for (const match of text.matchAll(/`+/g)) {+ max = Math.max(max, match[0].length);+ }+ return max;+}++/** A delimiter longer than any backtick run inside, so the span cannot close early. */+function inlineCode(text: string): string {+ const fence = "`".repeat(longestBacktickRun(text) + 1);+ const pad = text.startsWith("`") || text.endsWith("`") ? " " : "";+ return `${fence}${pad}${text}${pad}${fence}`;+}++function codeFence(code: string): string {+ const fence = "`".repeat(Math.max(3, longestBacktickRun(code) + 1));+ return `${fence}\n${code}\n${fence}`;+}++// Not every renderer sanitizes `javascript:`; anything else becomes plain text.+const SAFE_LINK = /^(https?:|mailto:)/i;++/** Spaces and parentheses end a markdown destination early; `<>` break autolinks. */+function linkDestination(url: string): string {+ return url.replace(+ /[ ()<>]/g,+ (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,+ );+}++/** `"1f44d-1f3fc"` → 👍🏼. Hyphen-separated hex codepoints. */+function emojiFromUnicode(unicode: string): string | undefined {+ const points = unicode.split("-").map((hex) => Number.parseInt(hex, 16));+ if (points.length === 0 || points.some((p) => !Number.isFinite(p))) {+ return undefined;+ }+ try {+ return String.fromCodePoint(...points);+ } catch {+ return undefined;+ }+}++/** Markers must hug the text, or remark reads `**bold **` literally. */+function applyStyle(text: string, style: Style | undefined): string {+ if (!style || !text.trim()) return text;+ const leading = text.match(/^\s*/)?.[0] ?? "";+ const trailing = text.match(/\s*$/)?.[0] ?? "";+ let inner = text.slice(leading.length, text.length - trailing.length);+ if (style.code) {+ inner = inlineCode(inner);+ } else {+ if (style.strike) inner = `~~${inner}~~`;+ if (style.italic) inner = `_${inner}_`;+ if (style.bold) inner = `**${inner}**`;+ }+ return `${leading}${inner}${trailing}`;+}++function renderInline(element: InlineElement, names: MentionNames): string {+ switch (element.type) {+ case "text":+ return applyStyle(+ element.style?.code ? element.text : escapeText(element.text),+ element.style,+ );+ case "emoji": {+ const char = element.unicode+ ? emojiFromUnicode(element.unicode)+ : undefined;+ return applyStyle(char ?? `:${element.name}:`, element.style);+ }+ case "link": {+ const label = element.text?.trim();+ if (!SAFE_LINK.test(element.url)) {+ return applyStyle(escapeText(label || element.url), element.style);+ }+ const url = linkDestination(element.url);+ const md =+ label && label !== element.url+ ? `[${escapeText(label)}](${url})`+ : `<${url}>`;+ return applyStyle(md, element.style);+ }+ case "user": {+ const name = names.users?.get(element.user_id);+ return applyStyle(+ `@${escapeText(name ?? element.user_id)}`,+ element.style,+ );+ }+ case "channel": {+ const name = names.channels?.get(element.channel_id);+ return applyStyle(+ `#${escapeText(name ?? element.channel_id)}`,+ element.style,+ );+ }+ case "usergroup": {+ const name = names.usergroups?.get(element.usergroup_id);+ return applyStyle(+ `@${escapeText(name ?? element.usergroup_id)}`,+ element.style,+ );+ }+ case "broadcast":+ return applyStyle(`@${element.range}`, element.style);+ case "date":+ return applyStyle(escapeText(element.fallback ?? ""), element.style);+ case "color":+ return applyStyle(escapeText(element.value), element.style);+ default:+ return "";+ }+}++function renderInlines(elements: InlineElement[], names: MentionNames): string {+ return elements.map((element) => renderInline(element, names)).join("");+}++// Wide enough to nest under `1. ` (3 columns) as well as `- `.+const LIST_INDENT = " ";++function renderElement(element: RichTextElement, names: MentionNames): string {+ switch (element.type) {+ case "rich_text_section":+ return renderInlines(element.elements, names);+ case "rich_text_list": {+ const pad = LIST_INDENT.repeat(element.indent ?? 0);+ const start = (element.offset ?? 0) + 1;+ return element.elements+ .map((item, index) => {+ const marker =+ element.style === "ordered" ? `${start + index}.` : "-";+ // Continuation lines stay inside the item when indented to its text.+ const hang = `\n${pad}${" ".repeat(marker.length + 1)}`;+ const text = renderInlines(item.elements, names).replace(/\n/g, hang);+ return `${pad}${marker} ${text}`;+ })+ .join("\n");+ }+ case "rich_text_quote":+ return renderInlines(element.elements, names)+ .split("\n")+ .map((line) => `> ${line}`)+ .join("\n");+ case "rich_text_preformatted":+ return codeFence(+ element.elements+ .map((inline) =>+ inline.type === "text"+ ? inline.text+ : inline.type === "link"+ ? (inline.text ?? inline.url)+ : "",+ )+ .join(""),+ );+ default:+ return "";+ }+}++/**+ * Markdown for a message's `rich_text` blocks, or `undefined` when there are+ * none so the caller falls back to `message.text`.+ */+export function richTextToMarkdown(+ blocks: unknown[] | undefined,+ names: MentionNames = {},+): string | undefined {+ const rich = richTextBlocks(blocks);+ if (rich.length === 0) return undefined;+ let out = "";+ let previous: RichTextElement["type"] | undefined;+ for (const block of rich) {+ for (const element of block.elements) {+ const rendered = renderElement(element, names);+ if (!rendered.trim()) continue;+ // Slack emits one list per nesting level; a blank line would split them.+ const adjacentLists =+ previous === "rich_text_list" && element.type === "rich_text_list";+ if (out) out += adjacentLists ? "\n" : "\n\n";+ out += rendered;+ previous = element.type;+ }+ }+ return out.trim() || undefined;+}diff --git a/packages/services/src/incident/__tests__/incident.test.ts b/packages/services/src/incident/__tests__/incident.test.tsindex 640c411bd..7dc78c156 100644--- a/packages/services/src/incident/__tests__/incident.test.ts+++ b/packages/services/src/incident/__tests__/incident.test.ts@@ -459,6 +459,43 @@ describe("addIncidentNote", () => {});});+ test("keeps a createdAt inside the window and treats null as now", async () => {+ await withTestTransaction(async (tx) => {+ const row = await declare(tx);+ const saidAt = new Date(Date.now() - 60 * 60 * 1000);+ const backdated = await addIncidentNote({+ ctx: as(memberId, tx),+ input: { id: row.id, message: "an hour ago", createdAt: saidAt },+ });+ // `created_at` is stored in whole seconds.+ expect(+ Math.abs(backdated.createdAt.getTime() - saidAt.getTime()),+ ).toBeLessThan(1000);+ const now = await addIncidentNote({+ ctx: as(memberId, tx),+ input: { id: row.id, message: "now", createdAt: null },+ });+ expect(Math.abs(now.createdAt.getTime() - Date.now())).toBeLessThan(5000);+ });+ });++ test("rejects a createdAt in the future or older than the window", async () => {+ await withTestTransaction(async (tx) => {+ const row = await declare(tx);+ for (const createdAt of [+ new Date(Date.now() + 10 * 60 * 1000),+ new Date(Date.now() - 31 * 24 * 60 * 60 * 1000),+ ]) {+ await expect(+ addIncidentNote({+ ctx: as(memberId, tx),+ input: { id: row.id, message: "off the timeline", createdAt },+ }),+ ).rejects.toThrow(/createdAt must be within the last 30 days/);+ }+ });+ });+test("a closed incident takes no notes", async () => {await withTestTransaction(async (tx) => {const row = await createIncident(diff --git a/packages/services/src/incident/add-note.ts b/packages/services/src/incident/add-note.tsindex d518408c2..106f08425 100644--- a/packages/services/src/incident/add-note.ts+++ b/packages/services/src/incident/add-note.ts@@ -32,6 +32,7 @@ export async function addIncidentNote(args: {incidentId: existing.id,type: "note",message: input.message,+ createdAt: input.createdAt ?? undefined,});});}diff --git a/packages/services/src/incident/index.ts b/packages/services/src/incident/index.tsindex 7130a9837..b4f6ddfbb 100644--- a/packages/services/src/incident/index.ts+++ b/packages/services/src/incident/index.ts@@ -37,6 +37,9 @@ export {} from "./postmortem-draft";export {AddIncidentNoteInput,+ isAllowedNoteCreatedAt,+ NOTE_BACKDATE_MAX_MS,+ NOTE_FUTURE_SKEW_MS,ApprovePostmortemInput,CloseIncidentInput,DraftPostmortemInput,diff --git a/packages/services/src/incident/schemas.ts b/packages/services/src/incident/schemas.tsindex 125857b31..4c6599357 100644--- a/packages/services/src/incident/schemas.ts+++ b/packages/services/src/incident/schemas.ts@@ -42,7 +42,31 @@ export const SetIncidentStatusInput = z.object({});export type SetIncidentStatusInput = z.infer<typeof SetIncidentStatusInput>;-export const AddIncidentNoteInput = z.object({ id, message: note });+// A note copied from elsewhere (Slack) may keep the time it was said, within+// a window that keeps the timeline honest for every caller of the verb.+export const NOTE_BACKDATE_MAX_MS = 30 * 24 * 60 * 60 * 1000;+export const NOTE_FUTURE_SKEW_MS = 60_000;++export function isAllowedNoteCreatedAt(date: Date, now = Date.now()): boolean {+ const ms = date.getTime();+ return (+ Number.isFinite(ms) &&+ ms <= now + NOTE_FUTURE_SKEW_MS &&+ ms >= now - NOTE_BACKDATE_MAX_MS+ );+}++export const AddIncidentNoteInput = z.object({+ id,+ message: note,+ createdAt: z.coerce+ .date()+ .refine((d) => isAllowedNoteCreatedAt(d), {+ message:+ "createdAt must be within the last 30 days and at most a minute ahead",+ })+ .nullish(),+});export type AddIncidentNoteInput = z.infer<typeof AddIncidentNoteInput>;export const LinkIncidentStatusReportInput = z.object({diff --git a/packages/services/src/member/__tests__/display-name.test.ts b/packages/services/src/member/__tests__/display-name.test.tsnew file mode 100644index 000000000..8cc7adc83--- /dev/null+++ b/packages/services/src/member/__tests__/display-name.test.ts@@ -0,0 +1,44 @@+import {+ addUserToWorkspace,+ createUser,+} from "@openstatus/db/src/test/factories";+import { expect } from "@std/expect";+import { beforeAll, describe, test } from "@std/testing/bdd";++import { createWorkspaceFixture, makeSystemCtx } from "../../../test/helpers";+import type { ServiceContext } from "../../context";+import { getMemberDisplayName } from "../index.ts";++let ctx: ServiceContext;+let workspaceId: number;++beforeAll(async () => {+ const fixture = await createWorkspaceFixture("team");+ workspaceId = fixture.workspace.id;+ ctx = makeSystemCtx(fixture.workspace, { job: "slack-user-automap" });+});++describe("getMemberDisplayName", () => {+ test("prefers the explicit name over first and last", async () => {+ const member = await createUser({ name: "Max K." });+ await addUserToWorkspace(member.id, workspaceId, "member");+ expect(+ await getMemberDisplayName({ ctx, input: { userId: member.id } }),+ ).toBe("Max K.");+ });++ test("falls back to first and last name", async () => {+ const member = await createUser({ name: null });+ await addUserToWorkspace(member.id, workspaceId, "member");+ expect(+ await getMemberDisplayName({ ctx, input: { userId: member.id } }),+ ).toBe("Test User");+ });++ test("returns null for a user who is not a member here", async () => {+ const outsider = await createUser();+ expect(+ await getMemberDisplayName({ ctx, input: { userId: outsider.id } }),+ ).toBeNull();+ });+});diff --git a/packages/services/src/member/display-name.ts b/packages/services/src/member/display-name.tsnew file mode 100644index 000000000..6a35fdafc--- /dev/null+++ b/packages/services/src/member/display-name.ts@@ -0,0 +1,32 @@+import { and, eq, isNull } from "@openstatus/db";+import { user, usersToWorkspaces } from "@openstatus/db/src/schema";++import { displayName } from "../attribution";+import { type ServiceContext, getReadDb } from "../context";+import { GetMemberDisplayNameInput } from "./schemas";++/** The display name of a live member of this workspace, or `null`. */+export async function getMemberDisplayName(args: {+ ctx: ServiceContext;+ input: GetMemberDisplayNameInput;+}): Promise<string | null> {+ const input = GetMemberDisplayNameInput.parse(args.input);+ const row = await getReadDb(args.ctx)+ .select({+ name: user.name,+ firstName: user.firstName,+ lastName: user.lastName,+ email: user.email,+ })+ .from(usersToWorkspaces)+ .innerJoin(user, eq(user.id, usersToWorkspaces.userId))+ .where(+ and(+ eq(usersToWorkspaces.workspaceId, args.ctx.workspace.id),+ eq(usersToWorkspaces.userId, input.userId),+ isNull(user.deletedAt),+ ),+ )+ .get();+ return row ? displayName(row) : null;+}diff --git a/packages/services/src/member/index.ts b/packages/services/src/member/index.tsindex 10cc2823e..6582ab10e 100644--- a/packages/services/src/member/index.ts+++ b/packages/services/src/member/index.ts@@ -1,8 +1,10 @@export { deleteMember } from "./delete";+export { getMemberDisplayName } from "./display-name";export { findMemberIdByEmail } from "./find-by-email";export { listMembers, type Member } from "./list";export {DeleteMemberInput,FindMemberByEmailInput,+ GetMemberDisplayNameInput,ListMembersInput,} from "./schemas";diff --git a/packages/services/src/member/schemas.ts b/packages/services/src/member/schemas.tsindex 0e24564a0..db5605c44 100644--- a/packages/services/src/member/schemas.ts+++ b/packages/services/src/member/schemas.ts@@ -8,3 +8,8 @@ export type DeleteMemberInput = z.infer<typeof DeleteMemberInput>;export const FindMemberByEmailInput = z.object({ email: z.string() });export type FindMemberByEmailInput = z.infer<typeof FindMemberByEmailInput>;++export const GetMemberDisplayNameInput = z.object({ userId: z.number().int() });+export type GetMemberDisplayNameInput = z.infer<+ typeof GetMemberDisplayNameInput+>;