Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import {
currentImpactsFromUpdates,
statusReportStatusSchema,
} from "@openstatus/db/src/schema";
import { z } from "zod";
import { attributedUserSchema, toAgentUser } from "../attribution";
import type { ServiceContext } from "../context";
import {
addStatusReportUpdate,
deleteStatusReportUpdate,
getStatusReport,
listStatusReports,
notifyStatusReport,
resolveStatusReport,
updateStatusReport,
updateStatusReportUpdate,
} from "../status-report";
import { createStatusReport } from "../status-report/create";
import {
type ComponentImpacts,
componentImpactsSchema,
type StatusReportStatus,
} from "../status-report/schemas";
import { formatComponentImpacts } from "../status-report/utils";
import type { AgentTool, SummaryLine } from "./types";
// Agent surfaces send only the impacts that CHANGED (see system prompt). Carry
// the report's current non-operational impacts into the update so each update's
// rows are self-contained for the per-update render — and so the confirmation
// preview shows the full impact, not just the delta.
async function withCarriedImpacts(
ctx: ServiceContext,
statusReportId: number,
status: StatusReportStatus,
componentImpacts: ComponentImpacts | undefined,
): Promise<ComponentImpacts | undefined> {
// resolve clears every still-active component the update doesn't name; carrying
// them forward would mark them named and defeat that, so skip carry on resolve.
if (status === "resolved") return componentImpacts;
const report = await getStatusReport({
ctx,
input: { id: statusReportId },
});
const current = currentImpactsFromUpdates(
report.updates.map((u) => ({
id: u.id,
date: u.date,
componentImpacts: u.componentImpacts,
})),
);
const merged: ComponentImpacts = [...(componentImpacts ?? [])];
const named = new Set(merged.map((ci) => ci.pageComponentId));
for (const [pageComponentId, impact] of current) {
if (impact !== "operational" && !named.has(pageComponentId)) {
merged.push({ pageComponentId, impact });
}
}
return merged.length > 0 ? merged : componentImpacts;
}
const componentImpactsInputShape = componentImpactsSchema
.optional()
.describe(
"Per-component impact (operational | degraded_performance | partial_outage | major_outage). Component ids MUST come from list_page_components. Omit entirely for a report without impact tracking.",
);
const PER_PAGE_DEFAULT = 50;
const PER_PAGE_MAX = 200;
/**
* "Active" statuses are computed at module load — extending the
* `statusReportStatusSchema` enum (e.g. adding `degraded`) automatically
* widens the filter without touching this file.
*/
const ACTIVE_STATUSES = statusReportStatusSchema.options.filter(
(s) => s !== "resolved",
);
// keeps list output bounded for long-running incidents
const LIST_UPDATES_LIMIT = 10;
const ListStatusReportsInputShape = z.object({
filter: z
.enum(["active", "all"])
.default("active")
.describe(
"active = exclude resolved reports (default). all = every report regardless of status.",
),
pageId: z
.number()
.int()
.optional()
.describe("If set, only reports attached to this page id."),
page: z
.number()
.int()
.min(1)
.default(1)
.describe("1-indexed page number (default 1)."),
perPage: z
.number()
.int()
.min(1)
.max(PER_PAGE_MAX)
.default(PER_PAGE_DEFAULT)
.describe(
`Items per page (default ${PER_PAGE_DEFAULT}, max ${PER_PAGE_MAX}).`,
),
});
const ListStatusReportsOutput = z.object({
items: z.array(
z.object({
id: z.number().int(),
title: z.string(),
status: statusReportStatusSchema,
pageId: z.number().int().nullable(),
createdAt: z.string().nullable(),
updatedAt: z.string().nullable(),
createdBy: attributedUserSchema.nullable(),
updatedBy: attributedUserSchema.nullable(),
latestUpdate: z
.object({
id: z.number().int(),
message: z.string(),
status: statusReportStatusSchema,
date: z.string().nullable(),
createdBy: attributedUserSchema.nullable(),
})
.nullable(),
updates: z.array(
z.object({
id: z.number().int(),
status: statusReportStatusSchema,
message: z.string(),
date: z.string().nullable(),
}),
),
}),
),
pagination: z.object({
page: z.number().int(),
perPage: z.number().int(),
totalSize: z.number().int(),
totalPages: z.number().int(),
}),
});
export const listStatusReportsTool: AgentTool<
z.infer<typeof ListStatusReportsInputShape>,
z.infer<typeof ListStatusReportsOutput>
> = {
name: "list_status_reports",
description:
"List status reports in this workspace, newest first. Filter by status (e.g. exclude 'resolved' to see active incidents). Returns each report's timeline newest-first under `updates`, capped at the 10 most recent entries (ids feed update_status_report_update / delete_status_report_update; call get_status_report for the full timeline), plus `latestUpdate` with its author. Paginated via `page` (1-indexed) and `perPage`.",
scope: "read",
destructive: false,
inputSchema: ListStatusReportsInputShape,
outputSchema: ListStatusReportsOutput,
async run({ ctx, input }) {
const { filter, pageId, page, perPage } = input;
const result = await listStatusReports({
ctx,
input: {
limit: perPage,
offset: (page - 1) * perPage,
statuses: filter === "active" ? ACTIVE_STATUSES : [],
pageId,
order: "desc",
},
});
return {
items: result.items.map((r) => {
const latestUpdate = r.updates[0] ?? null;
return {
id: r.id,
title: r.title,
status: r.status,
pageId: r.pageId,
createdAt: r.createdAt?.toISOString() ?? null,
updatedAt: r.updatedAt?.toISOString() ?? null,
createdBy: toAgentUser(r.createdByUser),
updatedBy: toAgentUser(r.updatedByUser),
latestUpdate: latestUpdate
? {
id: latestUpdate.id,
message: latestUpdate.message,
status: latestUpdate.status,
date: latestUpdate.date?.toISOString() ?? null,
createdBy: toAgentUser(latestUpdate.createdByUser),
}
: null,
updates: r.updates.slice(0, LIST_UPDATES_LIMIT).map((u) => ({
id: u.id,
status: u.status,
message: u.message,
date: u.date?.toISOString() ?? null,
})),
};
}),
pagination: {
page,
perPage,
totalSize: result.totalSize,
totalPages: Math.max(1, Math.ceil(result.totalSize / perPage)),
},
};
},
};
const GetStatusReportInput = z.object({
id: z
.number()
.int()
.describe("Status report id from list_status_reports — never guess."),
});
const GetStatusReportOutput = z.object({
id: z.number().int(),
title: z.string(),
status: statusReportStatusSchema,
pageId: z.number().int().nullable(),
pageComponentIds: z.array(z.number().int()),
createdAt: z.string().nullable(),
updatedAt: z.string().nullable(),
createdBy: attributedUserSchema.nullable(),
updatedBy: attributedUserSchema.nullable(),
updates: z.array(
z.object({
id: z.number().int(),
status: statusReportStatusSchema,
message: z.string(),
date: z.string().nullable(),
createdBy: attributedUserSchema.nullable(),
componentImpacts: componentImpactsSchema,
}),
),
});
export const getStatusReportTool: AgentTool<
z.infer<typeof GetStatusReportInput>,
z.infer<typeof GetStatusReportOutput>
> = {
name: "get_status_report",
description:
"Get one status report with its FULL timeline newest-first under `updates` (no cap — list_status_reports stops at the 10 most recent). Use it to find the id of an older entry for update_status_report_update / delete_status_report_update.",
scope: "read",
destructive: false,
inputSchema: GetStatusReportInput,
outputSchema: GetStatusReportOutput,
async run({ ctx, input }) {
const r = await getStatusReport({ ctx, input: { id: input.id } });
return {
id: r.id,
title: r.title,
status: r.status,
pageId: r.pageId,
pageComponentIds: r.pageComponentIds,
createdAt: r.createdAt?.toISOString() ?? null,
updatedAt: r.updatedAt?.toISOString() ?? null,
createdBy: toAgentUser(r.createdByUser),
updatedBy: toAgentUser(r.updatedByUser),
updates: r.updates.map((u) => ({
id: u.id,
status: u.status,
message: u.message,
date: u.date?.toISOString() ?? null,
createdBy: toAgentUser(u.createdByUser),
componentImpacts: u.componentImpacts,
})),
};
},
};
const CreateStatusReportInputShape = z.object({
title: z.string().min(1).max(256).describe("Short, public-facing title."),
status: statusReportStatusSchema.describe("Initial status for the report."),
message: z
.string()
.min(1)
.describe("Initial public update message customers will see."),
pageId: z
.number()
.int()
.describe(
"Status page to attach to. Resolve via list_status_pages — never guess.",
),
pageComponentIds: z
.array(z.number().int())
.default([])
.describe(
"Optional component ids affected by the incident. Resolve via list_page_components({ pageId }) — never guess. Must belong to pageId.",
),
componentImpacts: componentImpactsInputShape,
date: z.iso
.datetime()
.optional()
.describe("Override the initial update's date. Defaults to now."),
incidentId: z
.number()
.int()
.optional()
.describe(
"Managed incident this report communicates, from list_incidents. Links them.",
),
notify: z
.boolean()
.describe(
"Whether to dispatch subscriber notifications for the initial update. true = notify on creation. false = create silently; subscribers will NEVER hear about this update (no retroactive notify).",
),
});
const CreateStatusReportOutput = z.object({
statusReport: z.object({
id: z.number().int(),
title: z.string(),
status: statusReportStatusSchema,
pageId: z.number().int().nullable(),
createdAt: z.string().nullable(),
}),
initialUpdateId: z.number().int(),
notified: z.boolean(),
});
export const createStatusReportTool: AgentTool<
z.infer<typeof CreateStatusReportInputShape>,
z.infer<typeof CreateStatusReportOutput>
> = {
name: "create_status_report",
description:
"Create a new status report on a public status page. PUBLIC, AUDIT-LOGGED, AND POTENTIALLY NOTIFIES SUBSCRIBERS — irreversible side effects. Subscriber notifications dispatch as part of this call only — no retroactive notify. The report persists even if the notify dispatch fails; `notified` reports the actual outcome. pageId MUST come from list_status_pages — never guess. pageComponentIds (if supplied) MUST come from list_page_components({ pageId }) and belong to the same page.",
scope: "write",
destructive: true,
inputSchema: CreateStatusReportInputShape,
outputSchema: CreateStatusReportOutput,
approval: {
extraFlags: [{ id: "notify", label: "Notify subscribers" }],
applyFlags: (input, flags) => ({ ...input, notify: flags.notify ?? false }),
summarize: (input) => ({
title: `Create Status Report: ${input.title}`,
lines: [
{ label: "Title", value: input.title },
{ label: "Status", value: input.status },
{
label: "Page ID",
value: String(input.pageId),
ref: { kind: "page", pageId: input.pageId },
},
...(input.pageComponentIds?.length
? [
{
label: "Components",
value: input.pageComponentIds.join(", "),
ref: {
kind: "components" as const,
componentIds: input.pageComponentIds,
},
},
]
: []),
...(input.componentImpacts?.length
? [
{
label: "Impacts",
value: formatComponentImpacts(input.componentImpacts).join(
", ",
),
ref: {
kind: "componentImpacts" as const,
impacts: input.componentImpacts,
},
},
]
: []),
...(input.incidentId
? [{ label: "Incident", value: `#${input.incidentId}` }]
: []),
{ label: "Message", value: input.message },
],
}),
verb: "created",
},
async run({ ctx, input }) {
const result = await createStatusReport({
ctx,
input: {
title: input.title,
status: input.status,
message: input.message,
pageId: input.pageId,
pageComponentIds: input.pageComponentIds ?? [],
componentImpacts: input.componentImpacts,
date: input.date ? new Date(input.date) : new Date(),
incidentId: input.incidentId,
},
});
let notified = false;
if (input.notify) {
try {
notified = await notifyStatusReport({
ctx,
input: { statusReportUpdateId: result.initialUpdate.id },
});
} catch (err) {
console.warn(
"notifyStatusReport failed after create_status_report",
err,
);
}
}
return {
statusReport: {
id: result.statusReport.id,
title: result.statusReport.title,
status: result.statusReport.status,
pageId: result.statusReport.pageId,
createdAt: result.statusReport.createdAt?.toISOString() ?? null,
},
initialUpdateId: result.initialUpdate.id,
notified,
};
},
};
const AddStatusReportUpdateInputShape = z.object({
statusReportId: z
.number()
.int()
.describe("Status report to update. Resolve via list_status_reports."),
status: statusReportStatusSchema.describe(
"New status to set on the report. The update entry inherits this status.",
),
message: z
.string()
.min(1)
.describe("Public update message customers will see."),
componentImpacts: componentImpactsInputShape,
date: z.iso
.datetime()
.optional()
.describe("Override the update's date. Defaults to now."),
notify: z
.boolean()
.describe(
"Whether to dispatch subscriber notifications for this update. No retroactive notify — false means subscribers will never hear about this update.",
),
});
const AddStatusReportUpdateOutput = z.object({
statusReportUpdateId: z.number().int(),
notified: z.boolean(),
statusReport: z.object({
id: z.number().int(),
title: z.string(),
status: statusReportStatusSchema,
pageId: z.number().int().nullable(),
}),
});
export const addStatusReportUpdateTool: AgentTool<
z.infer<typeof AddStatusReportUpdateInputShape>,
z.infer<typeof AddStatusReportUpdateOutput>
> = {
name: "add_status_report_update",
description:
"Append a new public update to an existing status report. PUBLIC, AUDIT-LOGGED, AND POTENTIALLY NOTIFIES SUBSCRIBERS — irreversible side effects. Sets the report's status to the new value (use resolve_status_report instead if the new status would be 'resolved'). Subscriber notifications dispatch as part of this call only — no retroactive notify. The update persists even if the notify dispatch fails; `notified` reports the actual outcome.",
scope: "write",
destructive: true,
inputSchema: AddStatusReportUpdateInputShape,
outputSchema: AddStatusReportUpdateOutput,
approval: {
extraFlags: [{ id: "notify", label: "Notify subscribers" }],
applyFlags: (input, flags) => ({ ...input, notify: flags.notify ?? false }),
prepareDraftInput: async ({ ctx, input }) => ({
...input,
componentImpacts: await withCarriedImpacts(
ctx,
input.statusReportId,
input.status,
input.componentImpacts,
),
}),
summarize: (input) => ({
title: `Add Status Report Update (${input.status})`,
lines: [
{ label: "Report ID", value: String(input.statusReportId) },
{ label: "New Status", value: input.status },
...(input.componentImpacts?.length
? [
{
label: "Impacts",
value: formatComponentImpacts(input.componentImpacts).join(
", ",
),
ref: {
kind: "componentImpacts" as const,
impacts: input.componentImpacts,
},
},
]
: []),
{ label: "Message", value: input.message },
],
}),
verb: "added",
},
async run({ ctx, input }) {
const result = await addStatusReportUpdate({
ctx,
input: {
statusReportId: input.statusReportId,
status: input.status,
message: input.message,
componentImpacts: await withCarriedImpacts(
ctx,
input.statusReportId,
input.status,
input.componentImpacts,
),
date: input.date ? new Date(input.date) : undefined,
},
});
let notified = false;
if (input.notify) {
try {
notified = await notifyStatusReport({
ctx,
input: { statusReportUpdateId: result.statusReportUpdate.id },
});
} catch (err) {
console.warn(
"notifyStatusReport failed after add_status_report_update",
err,
);
}
}
return {
statusReportUpdateId: result.statusReportUpdate.id,
notified,
statusReport: {
id: result.statusReport.id,
title: result.statusReport.title,
status: result.statusReport.status,
pageId: result.statusReport.pageId,
},
};
},
};
const UpdateStatusReportInputShape = z.object({
statusReportId: z
.number()
.int()
.describe("Report to edit. Resolve via list_status_reports."),
title: z.string().min(1).max(256).optional().describe("New title."),
status: statusReportStatusSchema
.refine((s) => s !== "resolved", {
error:
"update_status_report cannot set status to 'resolved' — use resolve_status_report instead, which also publishes a final resolution update.",
})
.optional()
.describe(
"New status (without appending a public update entry). Cannot be 'resolved'.",
),
pageComponentIds: z
.array(z.number().int())
.optional()
.describe(
"Replace the full set of associated component ids. Resolve via list_page_components — never guess. Empty array clears the association.",
),
});
const UpdateStatusReportOutput = z.object({
id: z.number().int(),
title: z.string(),
status: statusReportStatusSchema,
});
export const updateStatusReportTool: AgentTool<
z.infer<typeof UpdateStatusReportInputShape>,
z.infer<typeof UpdateStatusReportOutput>
> = {
name: "update_status_report",
description:
"Edit metadata on an existing status report (title, status, affected components). Does NOT add a public update — use add_status_report_update for that. Does NOT and CANNOT notify subscribers — there is no notify path on this tool because metadata edits do not create a new update entry to dispatch. Audit-logged.",
scope: "write",
destructive: true,
inputSchema: UpdateStatusReportInputShape,
outputSchema: UpdateStatusReportOutput,
approval: {
summarize: (input) => {
const lines: SummaryLine[] = [
{ label: "Report ID", value: String(input.statusReportId) },
];
if (input.title) lines.push({ label: "New Title", value: input.title });
if (input.status)
lines.push({ label: "New Status", value: input.status });
// Distinguish "don't touch components" (undefined) from
// "clear all associations" ([]). The latter is destructive and
// MUST be visible on the approval card.
if (input.pageComponentIds !== undefined) {
lines.push({
label: "Components",
value: input.pageComponentIds.length
? input.pageComponentIds.join(", ")
: "(clear all)",
...(input.pageComponentIds.length
? {
ref: {
kind: "components" as const,
componentIds: input.pageComponentIds,
},
}
: {}),
});
}
return {
title: `Update Status Report${input.title ? `: ${input.title}` : ""}`,
lines,
};
},
verb: "updated",
},
async run({ ctx, input }) {
const report = await updateStatusReport({
ctx,
input: {
id: input.statusReportId,
title: input.title,
status: input.status,
pageComponentIds: input.pageComponentIds,
},
});
return { id: report.id, title: report.title, status: report.status };
},
};
const ResolveStatusReportInputShape = z.object({
statusReportId: z
.number()
.int()
.describe("Report to resolve. Resolve via list_status_reports."),
message: z
.string()
.min(1)
.describe(
"Resolution message customers will see explaining what was fixed.",
),
date: z.iso
.datetime()
.optional()
.describe("Override the resolution date. Defaults to now."),
notify: z
.boolean()
.describe(
"Whether to dispatch subscriber notifications for the resolution update. No retroactive notify — false means subscribers will never hear about this resolution.",
),
});
const ResolveStatusReportOutput = z.object({
statusReportUpdateId: z.number().int(),
notified: z.boolean(),
statusReport: z.object({
id: z.number().int(),
title: z.string(),
pageId: z.number().int().nullable(),
}),
});
export const resolveStatusReportTool: AgentTool<
z.infer<typeof ResolveStatusReportInputShape>,
z.infer<typeof ResolveStatusReportOutput>
> = {
name: "resolve_status_report",
description:
"Resolve an active status report. Appends a final public update with the supplied message and flips status to 'resolved'. PUBLIC, AUDIT-LOGGED, AND POTENTIALLY NOTIFIES SUBSCRIBERS — irreversible side effects. Subscriber notifications dispatch as part of this call only — no retroactive notify. The report flips to resolved even if the notify dispatch fails; `notified` reports the actual outcome.",
scope: "write",
destructive: true,
inputSchema: ResolveStatusReportInputShape,
outputSchema: ResolveStatusReportOutput,
approval: {
extraFlags: [{ id: "notify", label: "Notify subscribers" }],
applyFlags: (input, flags) => ({ ...input, notify: flags.notify ?? false }),
summarize: (input) => ({
title: "Resolve Status Report",
lines: [
{ label: "Report ID", value: String(input.statusReportId) },
{ label: "Message", value: input.message },
],
}),
verb: "resolved",
},
async run({ ctx, input }) {
const result = await resolveStatusReport({
ctx,
input: {
statusReportId: input.statusReportId,
message: input.message,
date: input.date ? new Date(input.date) : undefined,
},
});
let notified = false;
if (input.notify) {
try {
notified = await notifyStatusReport({
ctx,
input: { statusReportUpdateId: result.statusReportUpdate.id },
});
} catch (err) {
console.warn(
"notifyStatusReport failed after resolve_status_report",
err,
);
}
}
return {
statusReportUpdateId: result.statusReportUpdate.id,
notified,
statusReport: {
id: result.statusReport.id,
title: result.statusReport.title,
pageId: result.statusReport.pageId,
},
};
},
};
const UpdateStatusReportUpdateInputShape = z.object({
id: z
.number()
.int()
.describe(
"Status report update id from list_status_reports (`updates[].id`; `latestUpdate.id` is the newest) or a prior create/add result — never guess.",
),
status: statusReportStatusSchema
.optional()
.describe(
"New status for this entry. 'resolved' is allowed: on the latest entry it resolves the report without notifying subscribers (use resolve_status_report to publish a new resolution update).",
),
message: z.string().min(1).optional().describe("New public message."),
date: z.iso.datetime().optional().describe("New date for this entry."),
componentImpacts: componentImpactsSchema
.optional()
.describe(
"Replace this entry's full impact set (empty array clears it). Omit to leave impacts untouched. Component ids MUST come from list_page_components.",
),
});
const UpdateStatusReportUpdateOutput = z.object({
id: z.number().int(),
statusReportId: z.number().int(),
status: statusReportStatusSchema,
message: z.string(),
date: z.string(),
});
export const updateStatusReportUpdateTool: AgentTool<
z.infer<typeof UpdateStatusReportUpdateInputShape>,
z.infer<typeof UpdateStatusReportUpdateOutput>
> = {
name: "update_status_report_update",
description:
"Edit an existing status report timeline entry (message, date, status, component impacts). PUBLIC and AUDIT-LOGGED. Does not notify subscribers. Editing the latest entry's status re-derives the report's status, including to 'resolved'. The update id MUST come from list_status_reports (`updates[].id`; `latestUpdate.id` is the newest) or a prior create/add result.",
scope: "write",
destructive: true,
inputSchema: UpdateStatusReportUpdateInputShape,
outputSchema: UpdateStatusReportUpdateOutput,
approval: {
summarize: (input) => ({
title: `Edit Status Report Update #${input.id}`,
lines: [
...(input.status ? [{ label: "Status", value: input.status }] : []),
...(input.date ? [{ label: "Date", value: input.date }] : []),
...(input.componentImpacts
? [
{
label: "Impacts",
value: input.componentImpacts.length
? formatComponentImpacts(input.componentImpacts).join(", ")
: "cleared",
ref: {
kind: "componentImpacts" as const,
impacts: input.componentImpacts,
},
},
]
: []),
...(input.message ? [{ label: "Message", value: input.message }] : []),
],
}),
verb: "updated",
},
async run({ ctx, input }) {
const update = await updateStatusReportUpdate({
ctx,
input: {
id: input.id,
status: input.status,
message: input.message,
date: input.date ? new Date(input.date) : undefined,
componentImpacts: input.componentImpacts,
},
});
return {
id: update.id,
statusReportId: update.statusReportId,
status: update.status,
message: update.message,
date: update.date.toISOString(),
};
},
};
const DeleteStatusReportUpdateInputShape = z.object({
id: z
.number()
.int()
.describe(
"Status report update id from list_status_reports (`updates[].id`; `latestUpdate.id` is the newest) or a prior create/add result — never guess.",
),
});
const DeleteStatusReportUpdateOutput = z.object({
id: z.number().int(),
success: z.boolean(),
});
export const deleteStatusReportUpdateTool: AgentTool<
z.infer<typeof DeleteStatusReportUpdateInputShape>,
z.infer<typeof DeleteStatusReportUpdateOutput>
> = {
name: "delete_status_report_update",
description:
"Delete a status report timeline entry. PUBLIC, AUDIT-LOGGED, AND IRREVERSIBLE. The report's status is re-derived from the remaining entries. A report must retain at least one update — to remove the only entry, delete the report from the dashboard instead. The update id MUST come from list_status_reports (`updates[].id`; `latestUpdate.id` is the newest) or a prior create/add result.",
scope: "write",
destructive: true,
inputSchema: DeleteStatusReportUpdateInputShape,
outputSchema: DeleteStatusReportUpdateOutput,
approval: {
summarize: (input) => ({
title: `Delete Status Report Update #${input.id}`,
lines: [{ label: "Update ID", value: String(input.id) }],
}),
verb: "deleted",
},
async run({ ctx, input }) {
await deleteStatusReportUpdate({ ctx, input });
return { id: input.id, success: true };
},
};