Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
slack: /openstatus incident subcommands + channel context (#2803)
Thibault Le Ouay25c93d9e76eb
diff --git a/apps/dashboard/src/components/chat/tool-renderers/index.tsx b/apps/dashboard/src/components/chat/tool-renderers/index.tsxindex 65ff7a0af..2100153b2 100644--- a/apps/dashboard/src/components/chat/tool-renderers/index.tsx+++ b/apps/dashboard/src/components/chat/tool-renderers/index.tsx@@ -181,6 +181,14 @@ export const toolRenderers: ToolRendererRegistry = {),summary: (o) => `resolved · ID ${o.id}`,},+ set_incident_status: {+ renderDraft: (input) => [+ { field: "incidentId", after: input.id },+ { field: "status", after: input.status },+ ...(input.note ? [{ field: "note", after: input.note }] : []),+ ],+ summary: (o) => `${o.status} · ID ${o.id}`,+ },add_incident_note: {summary: (o) => `note added to incident ${o.incidentId}`,},diff --git a/apps/server/src/routes/mcp/handler.test.ts b/apps/server/src/routes/mcp/handler.test.tsindex 6a180317c..199196d8c 100644--- a/apps/server/src/routes/mcp/handler.test.ts+++ b/apps/server/src/routes/mcp/handler.test.ts@@ -146,6 +146,7 @@ describe("MCP transport", () => {"resolve_status_report","search_content","search_docs",+ "set_incident_status","update_incident","update_status_report",]);diff --git a/apps/server/src/routes/mcp/tools/incident.ts b/apps/server/src/routes/mcp/tools/incident.tsindex ae11e998f..c69239acb 100644--- a/apps/server/src/routes/mcp/tools/incident.ts+++ b/apps/server/src/routes/mcp/tools/incident.ts@@ -9,6 +9,7 @@ import {getIncidentTool,listIncidentsTool,resolveIncidentTool,+ setIncidentStatusTool,updateIncidentTool,} from "@openstatus/services/agent-tools";@@ -24,6 +25,7 @@ export function registerIncidentTools(declareIncidentTool,updateIncidentTool,resolveIncidentTool,+ setIncidentStatusTool,addIncidentNoteTool,]);}diff --git a/apps/server/src/routes/slack/commands.test.ts b/apps/server/src/routes/slack/commands.test.tsindex f417389d9..f77d11526 100644--- a/apps/server/src/routes/slack/commands.test.ts+++ b/apps/server/src/routes/slack/commands.test.ts@@ -1,5 +1,15 @@import crypto from "node:crypto";+import { and, db, eq, or, sql } from "@openstatus/db";+import {+ auditLog,+ incident,+ incidentEvent,+ selectWorkspaceSchema,+ type Workspace,+ workspace as workspaceTable,+} from "@openstatus/db/src/schema";+import { declareIncident } from "@openstatus/services/incident";import { beforeEach, describe, expect, test } from "@openstatus/test-utils";import { Hono } from "hono";@@ -23,12 +33,13 @@ function post(app: ReturnType<typeof createTestApp>,text: string,user: string,+ channelId = "C1",) {const body = new URLSearchParams({text,team_id: "T_KNOWN",user_id: user,- channel_id: "C1",+ channel_id: channelId,}).toString();const timestamp = Math.floor(Date.now() / 1000);const sig = crypto@@ -92,3 +103,115 @@ describe("handleSlackCommand (members only)", () => {expect(json.blocks).toBeUndefined();});});++describe("/openstatus incident", () => {+ const app = createTestApp();+ const redisStore = (globalThis as Record<string, unknown>)+ .__testRedisStore as Map<string, string>;+ let workspace: Workspace;++ beforeEach(async () => {+ slackTestState.calls = [];+ slackTestState.usersInfoImpl = () =>+ Promise.resolve({+ ok: true,+ user: { profile: { email: "[email protected]" } },+ });+ workspace = selectWorkspaceSchema.parse(+ await db.query.workspace.findFirst({ where: eq(workspaceTable.id, 1) }),+ );+ slackTestState.resolveWorkspace = (teamId: string) =>+ teamId === "T_KNOWN"+ ? Promise.resolve({+ workspace: {+ ...workspace,+ limits: { ...workspace.limits, "slack-agent": true },+ },+ botToken: "xoxb-test",+ botUserId: "UBOT",+ })+ : Promise.resolve(null);+ });++ test("declare posts an approval card instead of declaring", async () => {+ redisStore.clear();+ const res = await post(+ app,+ "incident declare Checkout down --sev critical",+ `U_${crypto.randomUUID()}`,+ );+ const json = (await res.json()) as { text: string };+ expect(json.text).toContain("approval card");+ const card = slackTestState.calls.find(+ (c) => c.method === "update" && Array.isArray(c.args.blocks),+ );+ expect(card).toBeDefined();+ const pending = [...redisStore.entries()].find(([key]) =>+ key.startsWith("slack:action:"),+ );+ expect(pending?.[1]).toContain("declare_incident");+ expect(pending?.[1]).toContain("critical");+ });++ test("note in a bound channel lands on the timeline", async () => {+ const channelId = `C_INC_${crypto.randomUUID()}`;+ const created = await declareIncident({+ ctx: { workspace, actor: { type: "system", job: "test" } },+ input: { title: "Bound", severity: "minor" },+ });+ await db+ .update(incident)+ .set({ slackTeamId: "T_KNOWN", slackChannelId: channelId })+ .where(eq(incident.id, created.id));+ try {+ const res = await post(+ app,+ "incident note rolled back the deploy",+ `U_${crypto.randomUUID()}`,+ channelId,+ );+ const json = (await res.json()) as { text: string };+ expect(json.text).toContain("Added to the timeline");+ const events = await db+ .select()+ .from(incidentEvent)+ .where(eq(incidentEvent.incidentId, created.id))+ .all();+ expect(events.some((e) => e.message === "rolled back the deploy")).toBe(+ true,+ );+ } finally {+ await db+ .delete(auditLog)+ .where(+ and(+ eq(auditLog.workspaceId, workspace.id),+ or(+ and(+ eq(auditLog.entityType, "incident"),+ eq(auditLog.entityId, String(created.id)),+ ),+ and(+ eq(auditLog.action, "incident_event.create"),+ sql`json_extract(${auditLog.metadata}, '$.incidentId') = ${created.id}`,+ ),+ ),+ ),+ );+ await db+ .delete(incidentEvent)+ .where(eq(incidentEvent.incidentId, created.id));+ await db.delete(incident).where(eq(incident.id, created.id));+ }+ });++ test("note outside an incident channel explains where to run it", async () => {+ const res = await post(+ app,+ "incident note hello",+ `U_${crypto.randomUUID()}`,+ );+ const json = (await res.json()) as { text: string };+ expect(json.text).toContain("incident's channel");+ });+});diff --git a/apps/server/src/routes/slack/commands.ts b/apps/server/src/routes/slack/commands.tsindex d5762db54..ea67c2fdc 100644--- a/apps/server/src/routes/slack/commands.ts+++ b/apps/server/src/routes/slack/commands.ts@@ -16,6 +16,7 @@ import {LINK_ACCOUNT_TEXT,} from "./blocks";import type { SlackConfig, SlackEnv } from "./config";+import { runIncidentCommand } from "./incident-commands";import {linkAccountUrl,planRequiredMessage,@@ -43,6 +44,7 @@ const HELP = ["• `/openstatus subscribe <status-page-url>` — subscribe this channel to a status page","• `/openstatus unsubscribe <status-page-url>` — unsubscribe","• `/openstatus subscriptions` — show this channel's subscriptions",+ "• `/openstatus incident help` — declare and run incidents",].join("\n");type CommandReply = { text: string; blocks?: Block[] };@@ -92,7 +94,12 @@ export function handleSlackCommand(c: Context<SlackEnv>) {// `help` — and anything unrecognised, which falls through to it — needs no// I/O, so it is answered in the ack itself.- if (sub !== "subscribe" && sub !== "unsubscribe" && sub !== "subscriptions") {+ if (+ sub !== "subscribe" &&+ sub !== "unsubscribe" &&+ sub !== "subscriptions" &&+ sub !== "incident"+ ) {return ephemeral(c, { text: HELP });}@@ -166,6 +173,19 @@ async function runMemberCommand(});return { text: LINK_ACCOUNT_TEXT, blocks: buildLinkAccountBlocks(url) };}+ if (subcommand(command) === "incident") {+ const words = command.text.trim().split(/\s+/).filter(Boolean).slice(1);+ return {+ text: await runIncidentCommand({+ words,+ teamId: command.team_id,+ channelId: command.channel_id,+ resolved,+ actor,+ config,+ }),+ };+ }return { text: await runCommand(command) };}diff --git a/apps/server/src/routes/slack/confirmation-card.ts b/apps/server/src/routes/slack/confirmation-card.tsnew file mode 100644index 000000000..dc7072371--- /dev/null+++ b/apps/server/src/routes/slack/confirmation-card.ts@@ -0,0 +1,73 @@+import type { ServiceContext } from "@openstatus/services";+import type { WebClient } from "@slack/web-api";++import {+ buildConfirmationBlocks,+ getConfirmationText,+ type RefResolvers,+} from "./blocks";+import { store } from "./confirmation-store";+import {+ getComponentNames,+ getPageDashboardLink,+ getStatusReportLink,+} from "./page-urls";+import { deriveDraftSchema, getRegistryTool } from "./registry-runner";++export function makeRefResolvers(workspaceId: number): RefResolvers {+ return {+ page: (pageId) => getPageDashboardLink(workspaceId, pageId),+ statusReport: (statusReportId) =>+ getStatusReportLink(workspaceId, statusReportId),+ componentNames: (ids) => getComponentNames(workspaceId, ids),+ };+}++/**+ * Posts an approval card for a registry write outside an agent turn (slash+ * commands, follow-ups). Nothing runs until the initiator clicks Approve.+ */+export async function postConfirmationCard(args: {+ slack: WebClient;+ ctx: ServiceContext;+ teamId: string;+ channel: string;+ threadTs?: string;+ slackUserId: string;+ toolName: string;+ input: object;+}): Promise<void> {+ const { slack, ctx, teamId, channel, slackUserId, toolName } = args;+ const tool = getRegistryTool(toolName);+ if (!tool) throw new Error(`slack: unknown tool "${toolName}"`);++ const input = deriveDraftSchema(tool).parse(args.input);+ const displayInput = tool.approval?.prepareDraftInput+ ? await tool.approval.prepareDraftInput({ ctx, input })+ : input;+ const text = getConfirmationText({ tool, input: displayInput });++ const posted = await slack.chat.postMessage({+ channel,+ text,+ ...(args.threadTs ? { thread_ts: args.threadTs } : {}),+ });+ if (!posted.ts) throw new Error("chat.postMessage returned no ts");++ const actionId = await store({+ workspaceId: ctx.workspace.id,+ teamId,+ channelId: channel,+ threadTs: args.threadTs ?? posted.ts,+ messageTs: posted.ts,+ userId: slackUserId,+ payload: { toolName, input },+ });+ const blocks = await buildConfirmationBlocks({+ actionId,+ tool,+ input: displayInput,+ resolvers: makeRefResolvers(ctx.workspace.id),+ });+ await slack.chat.update({ channel, ts: posted.ts, text, blocks });+}diff --git a/apps/server/src/routes/slack/handler.test.ts b/apps/server/src/routes/slack/handler.test.tsindex 17c4bceeb..b9bbbac4a 100644--- a/apps/server/src/routes/slack/handler.test.ts+++ b/apps/server/src/routes/slack/handler.test.ts@@ -1,7 +1,7 @@import crypto from "node:crypto";import { db, eq } from "@openstatus/db";-import { integration } from "@openstatus/db/src/schema";+import { incident, integration } from "@openstatus/db/src/schema";import { createTestWorkspace } from "@openstatus/db/src/test/factories";import { beforeEach, describe, expect, test } from "@openstatus/test-utils";import { Hono } from "hono";@@ -1965,3 +1965,61 @@ describe("reconnect banner", () => {expect(view.blocks[0].text?.text).toContain("Reconnect openstatus");});});++describe("incident channel context", () => {+ const app = createTestApp();++ beforeEach(resetSlackTestState);++ test("a mention in a bound channel tells the agent which incident it is", async () => {+ const channelId = `C_CTX_${crypto.randomUUID()}`;+ const [row] = await db+ .insert(incident)+ .values({+ workspaceId: 1,+ title: "Context incident",+ severity: "major",+ declaredAt: new Date(),+ startedAt: new Date(),+ slackTeamId: "T_KNOWN",+ slackChannelId: channelId,+ })+ .returning();+ let contextNote: string | undefined;+ slackTestState.runAgentOverride = (options) => {+ contextNote = (options as { contextNote?: string } | undefined)+ ?.contextNote;+ return Promise.resolve({+ text: "ok",+ toolResults: [],+ finishReason: "stop",+ stepCount: 1,+ hitStepLimit: false,+ aborted: false,+ });+ };+ try {+ await signAndPost(app, {+ type: "event_callback",+ team_id: "T_KNOWN",+ event_id: `evt_ctx_${Date.now()}`,+ event: {+ type: "app_mention",+ text: "<@UBOT> note that we rolled back",+ user: "U1",+ channel: channelId,+ channel_type: "channel",+ ts: `${Date.now()}.71`,+ },+ });+ const deadline = Date.now() + 2000;+ while (contextNote === undefined && Date.now() < deadline) {+ await new Promise((r) => setTimeout(r, 20));+ }+ expect(contextNote).toContain(`id ${row.id}`);+ expect(contextNote).toContain("Context incident");+ } finally {+ await db.delete(incident).where(eq(incident.id, row.id));+ }+ });+});diff --git a/apps/server/src/routes/slack/handler.ts b/apps/server/src/routes/slack/handler.tsindex f2cafd77a..3cff0b6f8 100644--- a/apps/server/src/routes/slack/handler.ts+++ b/apps/server/src/routes/slack/handler.ts@@ -1,5 +1,6 @@import { getLogger } from "@logtape/logtape";import { isFeatureEnabled } from "@openstatus/services";+import { getIncidentBySlackChannel } from "@openstatus/services/incident";import {missingSlackScopes,uninstallSlackTeam,@@ -31,6 +32,7 @@ import {rememberContext,} from "./channel-context";import type { SlackConfig, SlackEnv } from "./config";+import { makeRefResolvers } from "./confirmation-card";import { draftKey, findByThread, replace, store } from "./confirmation-store";import type { PendingPayload } from "./confirmation-store";import { publishHomeView, publishLinkAccountView } from "./home";@@ -51,6 +53,7 @@ import {planRequiredMessage,releaseLinkCardWindow,requireSlackMember,+ type SlackActor,slackAgentAllowed,} from "./require-slack-member";import { abortTurn, broadcastStop, endTurn, startTurn } from "./running-turns";@@ -60,16 +63,7 @@ import {markThreadTitled,renameThread,} from "./thread-title";-import { resolveWorkspace } from "./workspace-resolver";--function makeRefResolvers(workspaceId: number): RefResolvers {- return {- page: (pageId) => getPageDashboardLink(workspaceId, pageId),- statusReport: (statusReportId) =>- getStatusReportLink(workspaceId, statusReportId),- componentNames: (ids) => getComponentNames(workspaceId, ids),- };-}+import { resolveWorkspace, type SlackWorkspace } from "./workspace-resolver";const logger = getLogger("api-server");@@ -268,6 +262,25 @@ export async function handleSlackEvent(c: Context<SlackEnv>) {return c.json({ ok: true });}+/** Tells the agent which incident a channel belongs to, when it has one. */+async function boundIncidentNote(args: {+ workspace: SlackWorkspace["workspace"];+ actor: SlackActor;+ teamId: string;+ channelId: string | undefined;+}): Promise<string | undefined> {+ if (!args.channelId) return undefined;+ const bound = await getIncidentBySlackChannel({+ ctx: { workspace: args.workspace, actor: args.actor },+ input: { teamId: args.teamId, channelId: args.channelId },+ }).catch(() => undefined);+ if (!bound) return undefined;+ const report = bound.statusReport+ ? ` Its status report is "${bound.statusReport.title}" (id ${bound.statusReport.id}, ${bound.statusReport.status}).`+ : " It has no status report yet.";+ return `Incident channel: <#${args.channelId}> belongs to managed incident "${bound.title}" (id ${bound.id}, ${bound.severity}, ${bound.status}${bound.closedAt ? ", closed" : ""}).${report} Notes and status changes discussed here are about this incident: use id ${bound.id} without asking.`;+}+/*** Tells an unlinked Slack user how to link their account. Passive surfaces* (mentions, DMs) send it at most once per window, so a chatty user isn't@@ -680,6 +693,12 @@ async function processEvent(body: SlackEvent, config: SlackConfig) {const context = contextChannel? channelContextTooling({ slack, channelId: contextChannel }): undefined;+ const incidentNote = await boundIncidentNote({+ workspace: resolved.workspace,+ actor,+ teamId,+ channelId: isAgentThread ? contextChannel : event.channel,+ });logger.info("slack agent invoked", {teamId,@@ -699,7 +718,9 @@ async function processEvent(body: SlackEvent, config: SlackConfig) {events: reply.progress,signal: turn.signal,tools: context?.tools,- contextNote: context?.contextNote,+ contextNote:+ [context?.contextNote, incidentNote].filter(Boolean).join("\n\n") ||+ undefined,},);diff --git a/apps/server/src/routes/slack/incident-analytics.ts b/apps/server/src/routes/slack/incident-analytics.tsnew file mode 100644index 000000000..6f5bd75a7--- /dev/null+++ b/apps/server/src/routes/slack/incident-analytics.ts@@ -0,0 +1,26 @@+import { Events, setupAnalytics } from "@openstatus/analytics";+import { type ServiceContext, tryGetActorUserId } from "@openstatus/services";++const EVENTS = {+ declare: Events.DeclareManagedIncident,+ status: Events.ChangeManagedIncidentStatus,+ note: Events.AddManagedIncidentNote,+} as const;++/** Fire-and-forget: analytics never fails a Slack action. */+export function trackSlackIncident(+ ctx: ServiceContext,+ kind: keyof typeof EVENTS,+ props: Record<string, string> = {},+): void {+ const userId = tryGetActorUserId(ctx.actor);+ setupAnalytics({+ userId: userId ? `usr_${userId}` : `slack_${ctx.workspace.id}`,+ workspaceId: String(ctx.workspace.id),+ plan: ctx.workspace.plan,+ })+ .then((analytics) =>+ analytics.track({ ...EVENTS[kind], source: "slack", ...props }),+ )+ .catch(() => undefined);+}diff --git a/apps/server/src/routes/slack/incident-commands.test.ts b/apps/server/src/routes/slack/incident-commands.test.tsnew file mode 100644index 000000000..30faf8708--- /dev/null+++ b/apps/server/src/routes/slack/incident-commands.test.ts@@ -0,0 +1,41 @@+import { expect } from "@std/expect";+import { describe, test } from "@std/testing/bdd";++import { parseDeclare, parseTarget } from "./incident-commands";++describe("parseDeclare", () => {+ test("title with a severity flag anywhere", () => {+ expect(parseDeclare(["API", "down", "--sev", "critical"])).toEqual({+ title: "API down",+ severity: "critical",+ });+ expect(parseDeclare(["--severity", "MINOR", "Slow", "search"])).toEqual({+ title: "Slow search",+ severity: "minor",+ });+ });++ test("defaults to major and ignores an unknown severity", () => {+ expect(parseDeclare(["Checkout", "--sev", "huge"])).toEqual({+ title: "Checkout",+ severity: "major",+ });+ });+});++describe("parseTarget", () => {+ test("leading #id or number names the incident", () => {+ expect(parseTarget(["#12", "rolled", "back"])).toEqual({+ id: 12,+ rest: "rolled back",+ });+ expect(parseTarget(["7"])).toEqual({ id: 7, rest: "" });+ });++ test("otherwise everything is the note", () => {+ expect(parseTarget(["rolled", "back"])).toEqual({+ id: null,+ rest: "rolled back",+ });+ });+});diff --git a/apps/server/src/routes/slack/incident-commands.ts b/apps/server/src/routes/slack/incident-commands.tsnew file mode 100644index 000000000..1e34dcb2d--- /dev/null+++ b/apps/server/src/routes/slack/incident-commands.ts@@ -0,0 +1,210 @@+import { getLogger } from "@logtape/logtape";+import {+ type IncidentStatus,+ isFeatureEnabled,+ type ServiceContext,+ ServiceError,+} from "@openstatus/services";+import {+ addIncidentNote,+ displayName,+ getIncident,+ getIncidentBySlackChannel,+ listIncidents,+} from "@openstatus/services/incident";+import { WebClient } from "@slack/web-api";++import type { SlackConfig } from "./config";+import { postConfirmationCard } from "./confirmation-card";+import { trackSlackIncident } from "./incident-analytics";+import { getIncidentDashboardUrl } from "./page-urls";+import type { SlackActor } from "./require-slack-member";+import type { SlackWorkspace } from "./workspace-resolver";++const logger = getLogger(["api-server", "slack", "incident-commands"]);++export const INCIDENT_HELP = [+ "*Incidents*",+ "• `/openstatus incident declare <title> [--sev critical|major|minor]` — declare an incident (approval card)",+ "• `/openstatus incident note <text>` — add to the timeline (in an incident channel)",+ "• `/openstatus incident mitigate|resolve|cancel|reopen [#id] [note]` — change its status (approval card)",+ "• `/openstatus incident status [#id]` — where it stands",+ "• `/openstatus incident list` — open incidents",+].join("\n");++const SEVERITIES = ["critical", "major", "minor"] as const;+type Severity = (typeof SEVERITIES)[number];++const STATUS_BY_VERB: Record<string, IncidentStatus> = {+ mitigate: "mitigated",+ resolve: "resolved",+ cancel: "canceled",+ reopen: "open",+};++/** `declare API down --sev critical` → title and severity, flag anywhere. */+export function parseDeclare(words: string[]): {+ title: string;+ severity: Severity;+} {+ let severity: Severity = "major";+ const title: string[] = [];+ for (let i = 0; i < words.length; i++) {+ const word = words[i];+ if (word === "--sev" || word === "--severity") {+ const value = SEVERITIES.find((s) => s === words[i + 1]?.toLowerCase());+ if (value) severity = value;+ i++;+ continue;+ }+ title.push(word);+ }+ return { title: title.join(" ").trim(), severity };+}++/** A leading `#12` or `12` names the incident; the rest is the note. */+export function parseTarget(words: string[]): {+ id: number | null;+ rest: string;+} {+ const match = words[0]?.match(/^#?(\d+)$/);+ if (!match) return { id: null, rest: words.join(" ").trim() };+ return { id: Number(match[1]), rest: words.slice(1).join(" ").trim() };+}++async function postCard(args: {+ slack: WebClient;+ ctx: ServiceContext;+ teamId: string;+ channelId: string;+ slackUserId: string;+ toolName: string;+ input: object;+}): Promise<string> {+ try {+ await postConfirmationCard({+ ...args,+ channel: args.channelId,+ });+ return "Review the approval card in this channel.";+ } catch (error) {+ if (+ !(error instanceof Error) ||+ !error.message.includes("not_in_channel")+ ) {+ throw error;+ }+ try {+ await args.slack.conversations.join({ channel: args.channelId });+ await postConfirmationCard({ ...args, channel: args.channelId });+ return "Review the approval card in this channel.";+ } catch {+ return "Invite @openstatus to this channel first (`/invite @openstatus`), then try again.";+ }+ }+}++export async function runIncidentCommand(args: {+ words: string[];+ teamId: string;+ channelId: string;+ resolved: SlackWorkspace;+ actor: SlackActor;+ config: SlackConfig;+}): Promise<string> {+ const { words, teamId, channelId, resolved, actor } = args;+ const ctx: ServiceContext = { workspace: resolved.workspace, actor };+ if (!isFeatureEnabled(resolved.workspace, "incident-management")) {+ return "Incident management isn't available for this workspace yet.";+ }+ const slack = new WebClient(resolved.botToken);+ const [verb = "help", ...rest] = words;+ const bound = await getIncidentBySlackChannel({+ ctx,+ input: { teamId, channelId },+ });++ try {+ switch (verb.toLowerCase()) {+ case "declare": {+ const { title, severity } = parseDeclare(rest);+ if (!title) {+ return "Usage: `/openstatus incident declare <title> [--sev critical|major|minor]`";+ }+ return postCard({+ slack,+ ctx,+ teamId,+ channelId,+ slackUserId: actor.slackUserId,+ toolName: "declare_incident",+ input: { title, severity },+ });+ }+ case "note": {+ const message = rest.join(" ").trim();+ if (!bound) {+ return "Run `note` in an incident's channel, or mention @openstatus and say which incident.";+ }+ if (!message) return "Usage: `/openstatus incident note <text>`";+ await addIncidentNote({ ctx, input: { id: bound.id, message } });+ trackSlackIncident(ctx, "note");+ return `Added to the timeline of *${bound.title}*.`;+ }+ case "mitigate":+ case "resolve":+ case "cancel":+ case "reopen": {+ const { id, rest: note } = parseTarget(rest);+ const incidentId = id ?? bound?.id;+ if (!incidentId) {+ return `Run this in an incident's channel, or name it: \`/openstatus incident ${verb} #12\`.`;+ }+ return postCard({+ slack,+ ctx,+ teamId,+ channelId,+ slackUserId: actor.slackUserId,+ toolName: "set_incident_status",+ input: {+ id: incidentId,+ status: STATUS_BY_VERB[verb.toLowerCase()],+ ...(note ? { note } : {}),+ },+ });+ }+ case "status": {+ const { id } = parseTarget(rest);+ const target =+ id !== null ? await getIncident({ ctx, input: { id } }) : bound;+ if (!target) {+ return "No incident here. Name one: `/openstatus incident status #12`.";+ }+ const commander = target.commander+ ? displayName(target.commander)+ : "none";+ return `*${target.title}* · ${target.severity} · ${target.status}${target.closedAt ? " (closed)" : ""}\nCommander: ${commander}${target.statusReport ? `\nStatus report: ${target.statusReport.title} (${target.statusReport.status})` : ""}\n<${getIncidentDashboardUrl(target.id)}|Open in openstatus>`;+ }+ case "list": {+ const open = await listIncidents({+ ctx,+ input: { status: ["open", "mitigated"], limit: 20 },+ });+ if (open.length === 0) return "No open incidents.";+ return open+ .map(+ (i) =>+ `• #${i.id} <${getIncidentDashboardUrl(i.id)}|${i.title}> · ${i.severity} · ${i.status}`,+ )+ .join("\n");+ }+ default:+ return INCIDENT_HELP;+ }+ } catch (error) {+ if (error instanceof ServiceError) return `:x: ${error.message}`;+ logger.error("slack incident command failed", { error, verb });+ return ":x: Something went wrong. Please try again.";+ }+}diff --git a/apps/server/src/routes/slack/incident-slack.ts b/apps/server/src/routes/slack/incident-slack.tsindex f355b7254..74e206e26 100644--- a/apps/server/src/routes/slack/incident-slack.ts+++ b/apps/server/src/routes/slack/incident-slack.ts@@ -1,9 +1,12 @@import { getLogger } from "@logtape/logtape";+import { sendIncidentCommander } from "@openstatus/emails";import { ServiceError, type ServiceContext } from "@openstatus/services";import {announceIncidentChange,bindIncidentSlackChannel,+ displayName,escapeMrkdwn,+ getIncident,openIncidentSlackChannel,type SlackClientFactory,} from "@openstatus/services/incident";@@ -11,6 +14,8 @@ import { WebClient } from "@slack/web-api";import { z } from "zod";import type { SlackConfig } from "./config";+import { postConfirmationCard } from "./confirmation-card";+import { trackSlackIncident } from "./incident-analytics";import { requireSlackMember, slackAgentAllowed } from "./require-slack-member";import type { SlackWorkspace } from "./workspace-resolver";@@ -28,6 +33,17 @@ function who(ctx: ServiceContext): string {return ctx.actor.type === "slack" ? `<@${ctx.actor.slackUserId}>` : "Someone";}+function quote(note: string | undefined): string {+ return note ? `\n>${escapeMrkdwn(note).replaceAll("\n", "\n>")}` : "";+}++const INCIDENT_TOOLS = new Set([+ "declare_incident",+ "update_incident",+ "resolve_incident",+ "set_incident_status",+]);+/** Slack side effects of an approved incident tool call. Best effort. */export async function afterIncidentTool(args: {ctx: ServiceContext;@@ -35,13 +51,24 @@ export async function afterIncidentTool(args: {input: object;output: object;config: SlackConfig;+ slack: WebClient;+ teamId: string;+ channelId: string;+ threadTs: string;}): Promise<void> {const { ctx, toolName, config } = args;+ if (!INCIDENT_TOOLS.has(toolName)) return;const output = incidentOutput.safeParse(args.output);if (!output.success) return;const incidentId = output.data.id;+ const status = output.data.status;+ const note = incidentInput.safeParse(args.input).data?.note;try {if (toolName === "declare_incident") {+ trackSlackIncident(ctx, "declare");+ await notifyCommander(ctx, incidentId, config).catch((error) =>+ logger.warn("incident commander email failed", { error, incidentId }),+ );const result = await openIncidentSlackChannel({ctx,incidentId,@@ -51,25 +78,102 @@ export async function afterIncidentTool(args: {logger.info("slack incident channel", { incidentId, ...result });return;}- if (toolName === "resolve_incident" || toolName === "update_incident") {- const note = incidentInput.safeParse(args.input).data?.note;- const text =- toolName === "resolve_incident"- ? `${who(ctx)} marked the incident *resolved*.${note ? `\n>${escapeMrkdwn(note).replaceAll("\n", "\n>")}` : ""}`- : `${who(ctx)} updated the incident.`;+ if (toolName === "update_incident") {await announceIncidentChange({ctx,incidentId,- text,+ text: `${who(ctx)} updated the incident.`,clientFor: slackClientFor,dashboardUrl: config.dashboardUrl,});+ return;+ }++ trackSlackIncident(ctx, "status", { status });+ const closed = status === "resolved" || status === "canceled";+ const row = closed+ ? await getIncident({ ctx, input: { id: incidentId } })+ : undefined;+ const report =+ row?.statusReport && row.statusReport.status !== "resolved"+ ? row.statusReport+ : undefined;+ // An archived channel can't take the resolve card, so keep it open.+ const cardInIncidentChannel =+ !!report && row?.slackChannelId === args.channelId;+ await announceIncidentChange({+ ctx,+ incidentId,+ text: `${who(ctx)} marked the incident *${status}*.${quote(note)}`,+ clientFor: slackClientFor,+ dashboardUrl: config.dashboardUrl,+ archive: status === "canceled" && !cardInIncidentChannel,+ });+ if (report) {+ await offerStatusReportResolve({+ ...args,+ statusReportId: report.id,+ note,+ status,+ });}} catch (error) {logger.warn("slack incident follow-up failed", { error, incidentId });}}+/** A linked status report still open gets a resolve card; never automatic. */+async function offerStatusReportResolve(args: {+ ctx: ServiceContext;+ slack: WebClient;+ teamId: string;+ channelId: string;+ threadTs: string;+ statusReportId: number;+ note: string | undefined;+ status: string;+}): Promise<void> {+ if (args.ctx.actor.type !== "slack") return;+ await postConfirmationCard({+ slack: args.slack,+ ctx: args.ctx,+ teamId: args.teamId,+ channel: args.channelId,+ threadTs: args.threadTs,+ slackUserId: args.ctx.actor.slackUserId,+ toolName: "resolve_status_report",+ input: {+ statusReportId: args.statusReportId,+ message:+ args.note ??+ (args.status === "resolved"+ ? "This incident has been resolved."+ : "This was a false alarm. Everything is operating normally."),+ },+ });+}++async function notifyCommander(+ ctx: ServiceContext,+ incidentId: number,+ config: SlackConfig,+): Promise<void> {+ const row = await getIncident({ ctx, input: { id: incidentId } });+ const commander = row?.commander;+ const actorUserId = ctx.actor.type === "slack" ? ctx.actor.userId : null;+ if (!row || !commander?.email || commander.id === actorUserId) return;+ const declarer = row.declaredByUser ? displayName(row.declaredByUser) : null;+ await sendIncidentCommander({+ to: commander.email,+ incidentTitle: row.title,+ severity: row.severity,+ workspaceName: ctx.workspace.name ?? ctx.workspace.slug,+ assignedBy: declarer ?? "A teammate",+ url: `${config.dashboardUrl}/incidents/${row.id}`,+ idempotencyKey: `incident-commander:${row.id}:${commander.id}:${row.updatedAt.getTime()}`,+ }).catch(() => undefined);+}+/** "Link this channel": the fallback when binding failed during declare. */export async function bindChannelFromButton(args: {resolved: SlackWorkspace;diff --git a/apps/server/src/routes/slack/interactions.ts b/apps/server/src/routes/slack/interactions.tsindex b1ee7253a..b5f29e20b 100644--- a/apps/server/src/routes/slack/interactions.ts+++ b/apps/server/src/routes/slack/interactions.ts@@ -292,7 +292,17 @@ async function runAndPresent(args: {runInBackground("incident-follow-up",() =>- afterIncidentTool({ ctx, toolName: tool.name, input, output, config }),+ afterIncidentTool({+ ctx,+ toolName: tool.name,+ input,+ output,+ config,+ slack,+ teamId: pending.teamId ?? actor.teamId,+ channelId,+ threadTs: pending.threadTs,+ }),{ toolName: tool.name },);}diff --git a/apps/server/src/routes/slack/presenters/incident.ts b/apps/server/src/routes/slack/presenters/incident.tsindex 7842bb35e..6981fe2ad 100644--- a/apps/server/src/routes/slack/presenters/incident.ts+++ b/apps/server/src/routes/slack/presenters/incident.ts@@ -25,3 +25,9 @@ export const resolveIncidentPresenter: Presenter = ({ input, output }) => {const o = output as AgentToolOutput<"resolve_incident">;return `:white_check_mark: Incident *${o.title}* resolved.${i.note ? `\n> ${i.note}` : ""}\n${link(o.id)}`;};++export const setIncidentStatusPresenter: Presenter = ({ input, output }) => {+ const i = input as AgentToolInput<"set_incident_status">;+ const o = output as AgentToolOutput<"set_incident_status">;+ return `:white_check_mark: Incident *${o.title}* is now ${o.status}.${i.note ? `\n> ${i.note}` : ""}\n${link(o.id)}`;+};diff --git a/apps/server/src/routes/slack/presenters/index.ts b/apps/server/src/routes/slack/presenters/index.tsindex c53ee7961..a48d1f74a 100644--- a/apps/server/src/routes/slack/presenters/index.ts+++ b/apps/server/src/routes/slack/presenters/index.ts@@ -5,6 +5,7 @@ import { defaultPresenter } from "./default";import {declareIncidentPresenter,resolveIncidentPresenter,+ setIncidentStatusPresenter,updateIncidentPresenter,} from "./incident";import { createMaintenancePresenter } from "./maintenance";@@ -25,6 +26,7 @@ export const presenters: Record<string, Presenter> = {declare_incident: declareIncidentPresenter,update_incident: updateIncidentPresenter,resolve_incident: resolveIncidentPresenter,+ set_incident_status: setIncidentStatusPresenter,};export async function renderToolResult(args: {diff --git a/apps/server/src/routes/slack/system-prompt.ts b/apps/server/src/routes/slack/system-prompt.tsindex 8fc4db525..aa0c0c7ac 100644--- a/apps/server/src/routes/slack/system-prompt.ts+++ b/apps/server/src/routes/slack/system-prompt.ts@@ -3,11 +3,13 @@const INCIDENT_SECTION = `Managed incidents (internal, never published):-- Three things are called "incident". A managed incident (list_incidents, get_incident, declare_incident, update_incident, resolve_incident, add_incident_note) is the team's internal record with a severity, a commander and a timeline. A status report is the PUBLIC communication. Monitor downtime is detected automatically.-- declare_incident, update_incident and resolve_incident render approval cards like the other write tools: nothing changes until the user clicks Approve, so never report them as done.+- Three things are called "incident". A managed incident (list_incidents, get_incident, declare_incident, update_incident, resolve_incident, set_incident_status, add_incident_note) is the team's internal record with a severity, a commander and a timeline. A status report is the PUBLIC communication. Monitor downtime is detected automatically.+- declare_incident, update_incident, resolve_incident and set_incident_status render approval cards like the other write tools: nothing changes until the user clicks Approve, so never report them as done.- "declare an incident", "open an incident" -> declare_incident (publishes nothing). Then offer a status report, passing incidentId to create_status_report to link them.- "note that…", "add to the timeline" -> add_incident_note (runs right away, no card).- "the incident is resolved" with a managed incident in play -> resolve_incident; if its linked status report is still open, draft resolve_status_report too.+- "mitigated", "the bleeding stopped" -> set_incident_status mitigated; "false alarm", "declared by mistake" -> set_incident_status canceled (closes it for good).+- In an incident channel (see the note below when there is one), notes and updates belong to that incident: use its id without asking.- Before referencing a managed incident, call list_incidents. Severity: critical = major outage or data loss, major = significant degradation, minor = limited impact.`;export function buildSystemPrompt(diff --git a/packages/services/src/agent-tools/incident.ts b/packages/services/src/agent-tools/incident.tsindex c5769cf25..ec2718307 100644--- a/packages/services/src/agent-tools/incident.ts+++ b/packages/services/src/agent-tools/incident.ts@@ -359,6 +359,48 @@ export const resolveIncidentTool: AgentTool<},};+const SetIncidentStatusInput = z.object({+ id: z.number().int().describe("Incident id, from list_incidents."),+ status: z+ .enum(incidentStatus)+ .describe(+ "mitigated: impact stopped, not fixed yet. resolved: fixed. canceled: false alarm or declared by mistake. open: reopen.",+ ),+ note: z.string().max(10_000).optional().describe("Why, in a sentence."),+});++export const setIncidentStatusTool: AgentTool<+ z.infer<typeof SetIncidentStatusInput>,+ z.infer<typeof IncidentWriteOutput>+> = {+ name: "set_incident_status",+ description:+ "Move a managed incident to mitigated, resolved, canceled (false alarm) or back to open. Canceling closes it for good. Does not touch its status report.",+ scope: "write",+ destructive: true,+ feature: FEATURE,+ inputSchema: SetIncidentStatusInput,+ outputSchema: IncidentWriteOutput,+ approval: {+ summarize: (input) => ({+ title: `Mark incident #${input.id} ${input.status}`,+ lines: optionalLines([["Note", input.note]]),+ }),+ verb: "updated",+ },+ async run({ ctx, input }) {+ const row = await setIncidentStatus({+ ctx,+ input: {+ id: input.id,+ status: input.status,+ note: input.note?.trim() || undefined,+ },+ });+ return writeOutput(row);+ },+};+const AddIncidentNoteInput = z.object({id: z.number().int().describe("Incident id, from list_incidents."),message: note.describe("The note, markdown."),diff --git a/packages/services/src/agent-tools/index.ts b/packages/services/src/agent-tools/index.tsindex ec49ddd98..e2fef14a3 100644--- a/packages/services/src/agent-tools/index.ts+++ b/packages/services/src/agent-tools/index.ts@@ -11,6 +11,7 @@ import {getIncidentTool,listIncidentsTool,resolveIncidentTool,+ setIncidentStatusTool,updateIncidentTool,} from "./incident";import { createMaintenanceTool, listMaintenancesTool } from "./maintenance";@@ -44,6 +45,7 @@ export {getIncidentTool,listIncidentsTool,resolveIncidentTool,+ setIncidentStatusTool,updateIncidentTool,} from "./incident";export { createMaintenanceTool, listMaintenancesTool } from "./maintenance";@@ -105,6 +107,7 @@ export const agentTools = {declare_incident: declareIncidentTool,update_incident: updateIncidentTool,resolve_incident: resolveIncidentTool,+ set_incident_status: setIncidentStatusTool,add_incident_note: addIncidentNoteTool,list_maintenances: listMaintenancesTool,create_maintenance: createMaintenanceTool,diff --git a/packages/services/src/agent-tools/prompt.ts b/packages/services/src/agent-tools/prompt.tsindex b4d016b58..9b2b0a519 100644--- a/packages/services/src/agent-tools/prompt.ts+++ b/packages/services/src/agent-tools/prompt.ts@@ -45,11 +45,12 @@ Exception: after get_doc_page or get_content_page, DO synthesize an answer from? `Managed incidents (internal):-- Three different things are called "incident". A managed incident (list_incidents, get_incident, declare_incident, update_incident, resolve_incident, add_incident_note) is the team's INTERNAL record: severity, commander, timeline. A status report is PUBLIC communication on a status page. Monitor downtime (activeIncidentCount on monitors) is detected automatically.+- Three different things are called "incident". A managed incident (list_incidents, get_incident, declare_incident, update_incident, resolve_incident, set_incident_status, add_incident_note) is the team's INTERNAL record: severity, commander, timeline. A status report is PUBLIC communication on a status page. Monitor downtime (activeIncidentCount on monitors) is detected automatically.- "declare an incident", "open an incident", "we have a SEV" → declare_incident. It publishes nothing. Offer to create a status report afterwards and pass incidentId to create_status_report to link them.- Before referencing a managed incident: call list_incidents. Never guess its id.- "note that…", "add to the timeline", "log that…" → add_incident_note (internal, runs without confirmation).- "the incident is fixed/resolved" with a managed incident in play → resolve_incident; if its linked status report is still open, ask whether to resolve that too (resolve_status_report).+- "mitigated", "the bleeding stopped" → set_incident_status mitigated; "false alarm", "declared by mistake" → set_incident_status canceled (this closes it).- severity: critical = major outage or data loss, major = significant degradation, minor = limited impact. Ask when unclear.`: "";diff --git a/packages/services/src/incident/index.ts b/packages/services/src/incident/index.tsindex 1d93c1010..c307352e7 100644--- a/packages/services/src/incident/index.ts+++ b/packages/services/src/incident/index.ts@@ -10,7 +10,12 @@ export {} from "./link-status-report";export { listIncidentEvents } from "./list-events";export { clearIncidentCommander } from "./members";-export { getIncident, getIncidentForStatusReport, listIncidents } from "./list";+export {+ getIncident,+ getIncidentBySlackChannel,+ getIncidentForStatusReport,+ listIncidents,+} from "./list";export {AddIncidentNoteInput,BindIncidentSlackChannelInput,diff --git a/packages/services/src/incident/list.ts b/packages/services/src/incident/list.tsindex 0f58f721c..48ec4b658 100644--- a/packages/services/src/incident/list.ts+++ b/packages/services/src/incident/list.ts@@ -2,7 +2,8 @@ import { and, desc, eq, inArray, sql } from "@openstatus/db";import { incident } from "@openstatus/db/src/schema";import { type ServiceContext, getReadDb } from "../context";-import { requireIncidentFeature } from "./internal";+import { isFeatureEnabled } from "../features";+import { INCIDENT_FEATURE, requireIncidentFeature } from "./internal";import { IncidentIdInput, ListIncidentsInput } from "./schemas";const userColumns = {@@ -81,3 +82,23 @@ export async function getIncidentForStatusReport(args: {).get();}++/** The incident bound to a Slack channel, or `undefined`. Never throws on the gate. */+export async function getIncidentBySlackChannel(args: {+ ctx: ServiceContext;+ input: { teamId: string; channelId: string };+}) {+ const { ctx } = args;+ if (!isFeatureEnabled(ctx.workspace, INCIDENT_FEATURE)) return undefined;+ return getReadDb(ctx).query.incident.findFirst({+ where: and(+ eq(incident.workspaceId, ctx.workspace.id),+ eq(incident.slackTeamId, args.input.teamId),+ eq(incident.slackChannelId, args.input.channelId),+ ),+ with: {+ commander: { columns: userColumns },+ statusReport: { columns: { id: true, title: true, status: true } },+ },+ });+}