Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { and, db, desc, eq } from "@openstatus/db";
import { integration, pageSubscriber } from "@openstatus/db/src/schema";
import type {
ChatPostMessageArguments,
ChatUpdateArguments,
} from "@slack/web-api";
import { WebClient } from "@slack/web-api";
import type { PageUpdate, Subscription } from "../types";
import { buildReplyMessage, buildRootMessage } from "./slack-blocks";
import {
type SlackAnchorStore,
type SlackThreadEvent,
createRedisAnchorStore,
} from "./slack-store";
interface SlackPostResult {
ts?: string;
}
export interface SlackClient {
postMessage(args: ChatPostMessageArguments): Promise<SlackPostResult>;
update(args: ChatUpdateArguments): Promise<SlackPostResult>;
}
export interface SlackChannelDeps {
store: SlackAnchorStore;
createClient: (token: string) => SlackClient;
getBotToken: (teamId: string) => Promise<string | null>;
softUnsubscribe: (subscriberId: number) => Promise<void>;
}
// Channel-scoped terminal errors: this subscriber's destination is gone for
// good, so we stop delivering to that one subscriber.
const CHANNEL_TERMINAL_ERRORS = new Set([
"channel_not_found",
"is_archived",
"channel_is_archived",
]);
// Token-scoped errors: the team's bot token is invalid. This affects every
// subscriber on the team and is recoverable by reinstalling the app, so we
// abort the team's batch WITHOUT unsubscribing anyone — otherwise a broken
// token silently and permanently drops every subscription on the team.
const TOKEN_TERMINAL_ERRORS = new Set([
"invalid_auth",
"account_inactive",
"token_revoked",
"not_authed",
]);
// Returned by a delivery when the team token is invalid, signalling the caller
// to abort the remaining members of that team.
const TEAM_TOKEN_INVALID = Symbol("slack_team_token_invalid");
type DeliveryOutcome = typeof TEAM_TOKEN_INVALID | undefined;
// WebClient throws `WebAPIPlatformError` carrying `data.error`; this is the
// only place we reach into that SDK error shape.
function slackErrorCode(error: Error): string | undefined {
const data = (error as Error & { data?: { error?: string } }).data;
return typeof data?.error === "string" ? data.error : undefined;
}
function parseTeamId(channelConfig?: string): string | null {
if (!channelConfig) return null;
try {
const parsed = JSON.parse(channelConfig) as { teamId?: string };
return parsed.teamId ?? null;
} catch {
return null;
}
}
async function getBotTokenFromDb(teamId: string): Promise<string | null> {
const row = await db
.select({ credential: integration.credential })
.from(integration)
.where(
and(
eq(integration.name, "slack-agent"),
eq(integration.externalId, teamId),
),
)
// Slack keeps one live token per (app, team); a reinstall invalidates all
// earlier ones. If the team is linked to several workspaces, the newest row
// is the only one holding a valid token.
.orderBy(desc(integration.updatedAt))
.get();
const credential = row?.credential as { botToken?: string } | null;
return credential?.botToken ?? null;
}
async function softUnsubscribeInDb(subscriberId: number): Promise<void> {
await db
.update(pageSubscriber)
.set({ unsubscribedAt: new Date(), updatedAt: new Date() })
.where(eq(pageSubscriber.id, subscriberId))
.run();
}
export function createSlackChannel(deps: SlackChannelDeps) {
async function runSlack(
subscriberId: number,
fn: () => Promise<SlackPostResult>,
): Promise<SlackPostResult | null | typeof TEAM_TOKEN_INVALID> {
try {
return await fn();
} catch (error) {
if (error instanceof Error) {
const code = slackErrorCode(error);
if (code && TOKEN_TERMINAL_ERRORS.has(code)) {
return TEAM_TOKEN_INVALID;
}
if (code && CHANNEL_TERMINAL_ERRORS.has(code)) {
await deps.softUnsubscribe(subscriberId);
console.error(
`slack: terminal error '${code}' for subscriber ${subscriberId} — unsubscribed`,
);
return null;
}
console.error(
`slack: delivery failed for subscriber ${subscriberId}: ${error.message}`,
);
} else {
console.error(`slack: delivery failed for subscriber ${subscriberId}`);
}
return null;
}
}
// Every event kind threads: the first delivered update becomes the root,
// later ones reply under it and re-render the root.
async function deliverThreaded(
client: SlackClient,
sub: Subscription,
channelId: string,
pageUpdate: PageUpdate,
): Promise<DeliveryOutcome> {
const event: SlackThreadEvent = {
kind: pageUpdate.status === "maintenance" ? "maintenance" : "report",
id: pageUpdate.id,
};
const updateId = pageUpdate.updateId;
if (updateId == null) {
console.error(`slack: ${event.kind} ${event.id} missing updateId`);
return;
}
// Atomic dedupe: only the caller that wins this reservation posts. On a
// failed post we release it below so the delivery stays retriable.
if (!(await deps.store.reserveDelivery(event, sub.id, updateId))) return;
const anchor = await deps.store.getAnchor(event, sub.id);
const root = buildRootMessage(pageUpdate, sub);
if (!anchor) {
const res = await runSlack(sub.id, () =>
client.postMessage({
channel: channelId,
attachments: root.attachments,
}),
);
if (!res || res === TEAM_TOKEN_INVALID) {
await deps.store.releaseDelivery(event, sub.id, updateId);
return res === TEAM_TOKEN_INVALID ? TEAM_TOKEN_INVALID : undefined;
}
if (res.ts) {
// Stash this first update so the next one can backfill it into the
// thread before the root is re-rendered and its content lost.
await deps.store.setAnchor(event, sub.id, {
ts: res.ts,
channelId,
pendingRootReply: buildReplyMessage(pageUpdate),
});
}
return;
}
// The first update only ever lived in the root. Before we overwrite the
// root below, post it into the thread so its history is preserved.
if (anchor.pendingRootReply) {
const backfill = anchor.pendingRootReply;
const backfillRes = await runSlack(sub.id, () =>
client.postMessage({
channel: anchor.channelId,
thread_ts: anchor.ts,
text: backfill.text,
blocks: backfill.blocks,
}),
);
if (!backfillRes || backfillRes === TEAM_TOKEN_INVALID) {
await deps.store.releaseDelivery(event, sub.id, updateId);
return backfillRes === TEAM_TOKEN_INVALID
? TEAM_TOKEN_INVALID
: undefined;
}
// Clear before posting the current reply: if that reply fails and the
// delivery is retried, the first update must not be backfilled twice.
await deps.store.setAnchor(event, sub.id, {
ts: anchor.ts,
channelId: anchor.channelId,
});
}
const reply = buildReplyMessage(pageUpdate);
const replyRes = await runSlack(sub.id, () =>
client.postMessage({
channel: anchor.channelId,
thread_ts: anchor.ts,
text: reply.text,
blocks: reply.blocks,
}),
);
if (!replyRes || replyRes === TEAM_TOKEN_INVALID) {
await deps.store.releaseDelivery(event, sub.id, updateId);
return replyRes === TEAM_TOKEN_INVALID ? TEAM_TOKEN_INVALID : undefined;
}
// Re-render the root so its emoji/status track the latest state.
const updateRes = await runSlack(sub.id, () =>
client.update({
channel: anchor.channelId,
ts: anchor.ts,
attachments: root.attachments,
}),
);
if (updateRes === TEAM_TOKEN_INVALID) return TEAM_TOKEN_INVALID;
}
async function sendNotifications(
subscriptions: Subscription[],
pageUpdate: PageUpdate,
): Promise<void> {
const byTeam = new Map<
string,
{ sub: Subscription; channelId: string }[]
>();
for (const sub of subscriptions) {
if (sub.channelType !== "slack") continue;
const channelId = sub.slackChannelId;
const teamId = parseTeamId(sub.channelConfig);
if (!channelId || !teamId) {
console.error(`slack: subscriber ${sub.id} missing channelId/teamId`);
continue;
}
const members = byTeam.get(teamId) ?? [];
members.push({ sub, channelId });
byTeam.set(teamId, members);
}
await Promise.allSettled(
[...byTeam.entries()].map(async ([teamId, members]) => {
const token = await deps.getBotToken(teamId);
if (!token) {
console.error(`slack: no bot token for team ${teamId}`);
return;
}
const client = deps.createClient(token);
// Sequential per team so a token failure aborts the batch before
// hammering Slack with N calls that will all fail identically.
for (const { sub, channelId } of members) {
const outcome = await deliverThreaded(
client,
sub,
channelId,
pageUpdate,
);
if (outcome === TEAM_TOKEN_INVALID) {
console.error(
`slack: team ${teamId} bot token invalid — aborting ${members.length} deliveries; subscribers left intact (reconnect the Slack app)`,
);
break;
}
}
}),
);
}
return { sendNotifications };
}
const defaultChannel = createSlackChannel({
store: createRedisAnchorStore(),
createClient: (token) => {
const web = new WebClient(token);
return {
postMessage: (args) => web.chat.postMessage(args),
update: (args) => web.chat.update(args),
};
},
getBotToken: getBotTokenFromDb,
softUnsubscribe: softUnsubscribeInDb,
});
export async function sendSlackNotifications(
subscriptions: Subscription[],
pageUpdate: PageUpdate,
): Promise<void> {
return defaultChannel.sendNotifications(subscriptions, pageUpdate);
}
export async function validateSlackConfig(
config: unknown,
): Promise<{ valid: boolean; error?: string }> {
if (
config !== null &&
typeof config === "object" &&
typeof (config as { teamId?: unknown }).teamId === "string" &&
(config as { teamId: string }).teamId.length > 0 &&
typeof (config as { channelId?: unknown }).channelId === "string" &&
(config as { channelId: string }).channelId.length > 0
) {
return { valid: true };
}
return { valid: false, error: "slack config requires teamId and channelId" };
}