Skip to content

Open-source status page, incident response and uptime monitoring

slack: hardening (Redis dedup, server-side plan limit, audited uninstall) (#2792)

Thibault Le Ouayaa4e19629d62
diff --git a/apps/server/src/routes/slack/commands.test.ts b/apps/server/src/routes/slack/commands.test.ts
index 81e97e973..f417389d9 100644
--- a/apps/server/src/routes/slack/commands.test.ts
+++ b/apps/server/src/routes/slack/commands.test.ts
@@ -54,7 +54,7 @@ describe("handleSlackCommand (members only)", () => {
slackTestState.resolveWorkspace = (teamId: string) =>
teamId === "T_KNOWN"
? Promise.resolve({
- workspace: { id: 1 },
+ workspace: { id: 1, limits: { "slack-agent": true } },
botToken: "xoxb-test",
botUserId: "UBOT",
})
diff --git a/apps/server/src/routes/slack/commands.ts b/apps/server/src/routes/slack/commands.ts
index 91966fdd4..d5762db54 100644
--- a/apps/server/src/routes/slack/commands.ts
+++ b/apps/server/src/routes/slack/commands.ts
@@ -16,7 +16,12 @@ import {
LINK_ACCOUNT_TEXT,
} from "./blocks";
import type { SlackConfig, SlackEnv } from "./config";
-import { linkAccountUrl, requireSlackMember } from "./require-slack-member";
+import {
+ linkAccountUrl,
+ planRequiredMessage,
+ requireSlackMember,
+ slackAgentAllowed,
+} from "./require-slack-member";
import { resolvePageFromUrl } from "./resolve-page";
import { resolveWorkspace } from "./workspace-resolver";
@@ -144,6 +149,9 @@ async function runMemberCommand(
text: "openstatus isn't connected to this Slack workspace. Connect it from the openstatus dashboard.",
};
}
+ if (!slackAgentAllowed(resolved.workspace)) {
+ return planRequiredMessage(config);
+ }
const actor = await requireSlackMember({
workspace: resolved.workspace,
teamId: command.team_id,
diff --git a/apps/server/src/routes/slack/handler.test.ts b/apps/server/src/routes/slack/handler.test.ts
index 457418bc6..d325579fc 100644
--- a/apps/server/src/routes/slack/handler.test.ts
+++ b/apps/server/src/routes/slack/handler.test.ts
@@ -1,5 +1,8 @@
import crypto from "node:crypto";
+import { db, eq } from "@openstatus/db";
+import { 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";
@@ -19,7 +22,7 @@ import {
looksLikeUncardedDraft,
toolTaskTitle,
} from "./handler";
-import { abortTurn, endTurn, startTurn } from "./running-turns";
+import { abortTurn, broadcastStop, endTurn, startTurn } from "./running-turns";
import { verifySlackSignature } from "./verify";
function createTestApp() {
@@ -104,7 +107,7 @@ function resetSlackTestState() {
name: "Test Workspace",
slug: "test",
plan: "free",
- limits: {},
+ limits: { "slack-agent": true },
},
botToken: "xoxb-test",
botUserId: "UBOT",
@@ -1047,21 +1050,27 @@ describe("streaming the agent's answer", () => {
]);
});
- test("falls back to the placeholder when the workspace has no streaming", async () => {
+ test("falls back to the thread status when the workspace has no streaming", async () => {
slackTestState.chatStreamEnabled = false;
streamTurn(async () => {});
await mention("3");
await new Promise((r) => setTimeout(r, 100));
- // No agent session and no stream leaves the oldest path: a "Thinking..."
- // message posted up front and overwritten with the answer.
- const placeholder = slackTestState.calls.find(
+ // No agent session and no stream leaves the thread status as the only
+ // loading indicator; the answer is posted as a message of its own.
+ expect(
+ slackTestState.calls.some(
+ (m) => m.method === "assistant.threads.setStatus",
+ ),
+ ).toBe(true);
+ const posts = slackTestState.calls.filter(
(m) => m.method === "postMessage",
);
- expect(placeholder?.args.text).toContain("Thinking...");
- const answer = slackTestState.calls.find((m) => m.method === "update");
- expect(answer?.args.text).toBe("All five monitors are healthy.");
+ expect(posts.map((m) => m.args.text)).toEqual([
+ "All five monitors are healthy.",
+ ]);
+ expect(slackTestState.calls.some((m) => m.method === "update")).toBe(false);
expect(slackTestState.calls.some((m) => m.method === "chatStream")).toBe(
false,
);
@@ -1783,3 +1792,143 @@ describe("members only", () => {
expect(view.blocks.some((b) => b.type === "actions")).toBe(true);
});
});
+
+describe("hardening", () => {
+ const app = createTestApp();
+ const redisStore = (globalThis as Record<string, unknown>)
+ .__testRedisStore as Map<string, string>;
+
+ beforeEach(resetSlackTestState);
+
+ test("a workspace without the Slack agent gets a plan notice", async () => {
+ slackTestState.resolveWorkspace = () =>
+ Promise.resolve({
+ workspace: {
+ id: 1,
+ name: "Free",
+ slug: "free",
+ plan: "free",
+ limits: {},
+ },
+ botToken: "xoxb-test",
+ botUserId: "UBOT",
+ });
+ const user = `U_FREE_${crypto.randomUUID()}`;
+ await signAndPost(app, {
+ type: "event_callback",
+ team_id: "T_FREE",
+ event_id: `evt_free_${Date.now()}`,
+ event: {
+ type: "app_mention",
+ text: "<@UBOT> hi",
+ user,
+ channel: "C1",
+ channel_type: "channel",
+ ts: `${Date.now()}.61`,
+ },
+ });
+ const notice = await waitForCall("postEphemeral");
+ expect(String(notice?.args.text)).toContain("/settings/billing");
+ // The plan notice must not use up the account-link card's window.
+ expect(redisStore.has(`slack:linkcard:T_FREE:${user}`)).toBe(false);
+ });
+
+ test("the same event id is processed once, across instances", async () => {
+ const eventId = `evt_dup_${Date.now()}`;
+ const body = {
+ type: "event_callback",
+ team_id: "T_KNOWN",
+ event_id: eventId,
+ event: {
+ type: "app_mention",
+ text: "<@UBOT> status?",
+ user: "U1",
+ channel: "C1",
+ channel_type: "channel",
+ ts: `${Date.now()}.62`,
+ },
+ };
+ await signAndPost(app, body);
+ await signAndPost(app, body);
+ expect(redisStore.has(`slack:event:${eventId}`)).toBe(true);
+ await new Promise((r) => setTimeout(r, 150));
+ const thinking = slackTestState.calls.filter(
+ (c) =>
+ c.method === "chatStream" ||
+ (c.method === "postMessage" &&
+ String(c.args.text).includes("Thinking")),
+ );
+ expect(thinking).toHaveLength(1);
+ });
+
+ test("a stop from another instance aborts the running turn", async () => {
+ const turn = startTurn("C_REMOTE", "7.7");
+ await new Promise((r) => setTimeout(r, 10));
+ await broadcastStop("C_REMOTE", "7.7");
+ await new Promise((r) => setTimeout(r, 1_200));
+ expect(turn.signal.aborted).toBe(true);
+ endTurn("C_REMOTE", "7.7", turn);
+ });
+
+ test("an earlier stop does not abort a newer turn", async () => {
+ await broadcastStop("C_OLD", "8.8");
+ const turn = startTurn("C_OLD", "8.8");
+ await new Promise((r) => setTimeout(r, 1_200));
+ expect(turn.signal.aborted).toBe(false);
+ endTurn("C_OLD", "8.8", turn);
+ });
+
+ async function seedSlackInstall() {
+ const teamId = `T_REVOKED_${crypto.randomUUID()}`;
+ const { workspace } = await createTestWorkspace();
+ const row = await db
+ .insert(integration)
+ .values({
+ name: "slack-agent",
+ workspaceId: workspace.id,
+ externalId: teamId,
+ data: {},
+ })
+ .returning()
+ .get();
+ return { teamId, id: row.id };
+ }
+
+ async function revokeTokens(
+ teamId: string,
+ tokens: Record<string, string[]>,
+ ) {
+ const res = await signAndPost(app, {
+ type: "event_callback",
+ team_id: teamId,
+ event_id: `evt_revoked_${crypto.randomUUID()}`,
+ event: { type: "tokens_revoked", tokens },
+ });
+ expect(res.status).toBe(200);
+ await settleBackgroundTasks();
+ }
+
+ function findIntegration(id: number) {
+ return db.select().from(integration).where(eq(integration.id, id)).get();
+ }
+
+ test("tokens_revoked without a bot token leaves the install alone", async () => {
+ const install = await seedSlackInstall();
+ try {
+ await revokeTokens(install.teamId, { oauth: ["U1"] });
+ expect(await findIntegration(install.id)).toBeDefined();
+ } finally {
+ await db.delete(integration).where(eq(integration.id, install.id));
+ }
+ });
+
+ test("tokens_revoked with a bot token uninstalls", async () => {
+ const install = await seedSlackInstall();
+ try {
+ await revokeTokens(install.teamId, { bot: ["UBOT"] });
+ expect(await findIntegration(install.id)).toBeUndefined();
+ } finally {
+ await db.delete(integration).where(eq(integration.id, install.id));
+ }
+ });
+});
diff --git a/apps/server/src/routes/slack/handler.ts b/apps/server/src/routes/slack/handler.ts
index c5cfb531b..ac8fc4d2e 100644
--- a/apps/server/src/routes/slack/handler.ts
+++ b/apps/server/src/routes/slack/handler.ts
@@ -1,10 +1,11 @@
import { getLogger } from "@logtape/logtape";
-import { and, db, eq, isNull, sql } from "@openstatus/db";
-import { integration, pageSubscriber } from "@openstatus/db/src/schema";
+import { uninstallSlackTeam } from "@openstatus/services/integration";
import { WebClient } from "@slack/web-api";
import type { Context } from "hono";
import { z } from "zod";
+import { redis } from "@/libs/clients";
+
import { type AgentEvents, runAgent } from "./agent";
import { greetOnce, setAssistantStatus, setSessionStatus } from "./assistant";
import { runInBackground } from "./background";
@@ -41,11 +42,14 @@ import {
} from "./registry-runner";
import {
claimLinkCardWindow,
+ claimPlanNoticeWindow,
linkAccountUrl,
+ planRequiredMessage,
releaseLinkCardWindow,
requireSlackMember,
+ slackAgentAllowed,
} from "./require-slack-member";
-import { abortTurn, endTurn, startTurn } from "./running-turns";
+import { abortTurn, broadcastStop, endTurn, startTurn } from "./running-turns";
import {
buildThreadTitle,
isThreadTitled,
@@ -65,16 +69,24 @@ function makeRefResolvers(workspaceId: number): RefResolvers {
const logger = getLogger("api-server");
-const processedEvents = new Map<string, number>();
+const DEDUP_TTL_SECONDS = 10 * 60;
-function dedup(eventId: string): boolean {
- const now = Date.now();
- for (const [id, ts] of processedEvents) {
- if (now - ts > 300_000) processedEvents.delete(id);
+/**
+ * Whether this event was already claimed, by this instance or another. If
+ * Redis is unreachable the event is processed: a duplicate turn beats a
+ * dropped one.
+ */
+async function isDuplicate(key: string): Promise<boolean> {
+ try {
+ const claimed = await redis.set(`slack:event:${key}`, "1", {
+ nx: true,
+ ex: DEDUP_TTL_SECONDS,
+ });
+ return claimed === null;
+ } catch (error) {
+ logger.warn("slack dedup unavailable", { error, key });
+ return false;
}
- if (processedEvents.has(eventId)) return true;
- processedEvents.set(eventId, now);
- return false;
}
const slackEventSchema = z.object({
@@ -91,6 +103,13 @@ const slackEventSchema = z.object({
thread_ts: z.string().optional(),
bot_id: z.string().optional(),
tab: z.string().optional(),
+ // `tokens_revoked`: which tokens went. Only a revoked bot token matters.
+ tokens: z
+ .object({
+ bot: z.array(z.string()).optional(),
+ oauth: z.array(z.string()).optional(),
+ })
+ .optional(),
assistant_thread: z
.object({
channel_id: z.string(),
@@ -233,7 +252,7 @@ export async function handleSlackEvent(c: Context<SlackEnv>) {
return c.json({ ok: true });
}
- if (body.event_id && dedup(body.event_id)) {
+ if (body.event_id && (await isDuplicate(body.event_id))) {
return c.json({ ok: true });
}
@@ -286,27 +305,13 @@ async function processEvent(body: SlackEvent, config: SlackConfig) {
if (event.type === "app_uninstalled" || event.type === "tokens_revoked") {
const teamId = body.team_id;
- if (teamId) {
- await db
- .delete(integration)
- .where(
- and(
- eq(integration.name, "slack-agent"),
- eq(integration.externalId, teamId),
- ),
- );
- await db
- .update(pageSubscriber)
- .set({ unsubscribedAt: new Date(), updatedAt: new Date() })
- .where(
- and(
- eq(pageSubscriber.channelType, "slack"),
- isNull(pageSubscriber.unsubscribedAt),
- sql`json_extract(${pageSubscriber.channelConfig}, '$.teamId') = ${teamId}`,
- ),
- );
- logger.info("slack integration cleaned up", { teamId });
- }
+ if (!teamId) return;
+ if (event.type === "tokens_revoked" && !event.tokens?.bot?.length) return;
+ const result = await uninstallSlackTeam({
+ input: { teamId },
+ job: `slack-${event.type}`,
+ });
+ logger.info("slack integration cleaned up", { teamId, ...result });
return;
}
@@ -464,6 +469,9 @@ async function processEvent(body: SlackEvent, config: SlackConfig) {
if (!teamId || !channel || !threadTs) return;
const wasRunning = abortTurn(channel, threadTs);
+ await broadcastStop(channel, threadTs).catch((error) =>
+ logger.warn("slack failed to broadcast stop", { error, teamId }),
+ );
logger.info("slack turn stopped by user", {
teamId,
channel,
@@ -515,8 +523,7 @@ async function processEvent(body: SlackEvent, config: SlackConfig) {
// A single mention arrives as BOTH an `app_mention` and a `message.*` event
// (distinct event_ids, same message ts), so the event_id dedup above doesn't
// catch the pair. Dedup on the message identity so we only respond once.
- // Runs before the first `await` so concurrent deliveries can't both pass.
- if (dedup(`msg:${event.channel}:${event.ts}`)) return;
+ if (await isDuplicate(`msg:${event.channel}:${event.ts}`)) return;
const resolved = await resolveWorkspace(teamId);
if (!resolved) {
@@ -574,6 +581,24 @@ async function processEvent(body: SlackEvent, config: SlackConfig) {
const channel = event.channel;
const slackUserId = event.user;
if (!slackUserId) return;
+ if (!slackAgentAllowed(resolved.workspace)) {
+ if (await claimPlanNoticeWindow(teamId, slackUserId)) {
+ const message = planRequiredMessage(config);
+ await (
+ isAgentThread
+ ? slack.chat.postMessage({ channel, thread_ts: threadTs, ...message })
+ : slack.chat.postEphemeral({
+ channel,
+ user: slackUserId,
+ thread_ts: event.thread_ts,
+ ...message,
+ })
+ ).catch((error) =>
+ logger.error("slack failed to send plan notice", { error, teamId }),
+ );
+ }
+ return;
+ }
const actor = await requireSlackMember({
workspace: resolved.workspace,
teamId,
@@ -615,7 +640,6 @@ async function processEvent(body: SlackEvent, config: SlackConfig) {
userId: event.user,
isAgentThread,
});
- if (!reply) return;
if (turn.signal.aborted) {
logger.info("slack turn stopped before it started", {
@@ -631,9 +655,7 @@ async function processEvent(body: SlackEvent, config: SlackConfig) {
if (prefetchedThread) {
thread = prefetchedThread;
} else if (event.thread_ts) {
- thread = (
- await fetchThread(slack, event.channel, event.thread_ts)
- ).filter((msg) => msg.ts !== reply?.placeholderTs);
+ thread = await fetchThread(slack, event.channel, event.thread_ts);
} else {
thread = [{ user: event.user, text: event.text, ts: event.ts }];
}
@@ -850,8 +872,7 @@ async function titleThread(args: {
/**
* Where the agent's output goes, in descending order of how much the user gets
* to see while they wait: a streamed message that fills in as the model writes,
- * with a task entry per tool call; a native "working" status on the thread; or
- * a "Thinking..." message we post up front and overwrite.
+ * with a task entry per tool call; or a native "working" status on the thread.
*/
interface Reply {
/**
@@ -869,8 +890,6 @@ interface Reply {
stopped(): Promise<void>;
/** Progress to report while the turn runs, when the surface can show it. */
progress?: AgentEvents;
- /** Our own "Thinking..." message, to keep it out of the agent's context. */
- placeholderTs?: string;
/** Runs once the turn is over, whether it succeeded or not. */
finish?: () => Promise<void>;
}
@@ -1083,8 +1102,8 @@ async function createReply(args: {
teamId: string;
userId: string | undefined;
isAgentThread: boolean;
-}): Promise<Reply | undefined> {
- const { slack, channel, threadTs, teamId, userId, isAgentThread } = args;
+}): Promise<Reply> {
+ const { slack, channel, threadTs, teamId, userId } = args;
const session = await acknowledgeWithSession(
slack,
@@ -1094,9 +1113,9 @@ async function createReply(args: {
userId,
);
- // The status is the loading indicator, not the delivery: a streamed turn in
- // the agent pane still needs it when agent sessions aren't available.
- if (!session && isAgentThread) {
+ // The status is the loading indicator, not the delivery: a streamed turn
+ // still needs it when agent sessions aren't available.
+ if (!session) {
// Best-effort: a missing status only loses the loading indicator.
await setAssistantStatus(slack, channel, threadTs, "is thinking...").catch(
(err: unknown) =>
@@ -1120,9 +1139,7 @@ async function createReply(args: {
});
}
- if (session) return session;
- if (isAgentThread) return acknowledgeInAgentThread(slack, channel, threadTs);
- return acknowledgeInChannel(slack, channel, threadTs, teamId);
+ return session ?? acknowledgeWithStatus(slack, channel, threadTs);
}
function postInThread(
@@ -1201,7 +1218,7 @@ async function acknowledgeWithSession(
// The status was already set by `createReply`; Slack clears it as soon as the
// app posts in the thread, so there is no matching "clear" call.
-function acknowledgeInAgentThread(
+function acknowledgeWithStatus(
slack: WebClient,
channel: string,
threadTs: string,
@@ -1216,79 +1233,6 @@ function acknowledgeInAgentThread(
};
}
-async function acknowledgeInChannel(
- slack: WebClient,
- channel: string,
- threadTs: string,
- teamId: string,
-): Promise<Reply | undefined> {
- let thinkingTs: string | undefined;
- try {
- const thinkingMsg = await slack.chat.postMessage({
- channel,
- thread_ts: threadTs,
- text: ":hourglass_flowing_sand: Thinking...",
- });
- thinkingTs = thinkingMsg.ts;
- } catch (err) {
- if (isSlackPlatformError(err, "cannot_reply_to_message")) {
- logger.warn("slack cannot reply to message, falling back to top-level", {
- channel,
- teamId,
- threadTs,
- });
- try {
- const fallbackMsg = await slack.chat.postMessage({
- channel,
- text: ":hourglass_flowing_sand: Thinking...",
- });
- thinkingTs = fallbackMsg.ts;
- } catch (fallbackErr) {
- logger.error("slack failed to post fallback thinking message", {
- error: fallbackErr,
- channel,
- teamId,
- });
- return;
- }
- } else {
- logger.error("slack failed to post thinking message", {
- error: err,
- channel,
- teamId,
- threadTs,
- });
- return;
- }
- }
-
- if (!thinkingTs) {
- logger.error("slack thinking message returned no ts", { channel, teamId });
- return;
- }
-
- const ts = thinkingTs;
- const postNew = postInThread(slack, channel, threadTs);
- let placeholderUsed = false;
- // The first message takes over "Thinking..."; any after it (a second
- // confirmation card) is a message of its own, or it would overwrite the first.
- const send: Reply["send"] = async ({ text, blocks }) => {
- if (placeholderUsed) return postNew({ text, blocks });
- placeholderUsed = true;
- await slack.chat.update({ channel, ts, text, blocks });
- return ts;
- };
- return {
- placeholderTs: ts,
- send,
- answer: (text) => send(buildAnswerMessage(text)),
- // Overwrites "Thinking...", which would otherwise stand forever.
- stopped: async () => {
- await send({ text: STOPPED_NOTICE });
- },
- };
-}
-
async function handleConfirmation(
slack: WebClient,
reply: Reply,
@@ -1316,10 +1260,8 @@ async function handleConfirmation(
// findByThread + replace isn't atomic on its own — two concurrent
// events on the same thread could both see `existing` and race on
- // replace. Atomicity here relies on the `dedup` map at the top of this
- // file suppressing duplicate event_ids, plus Slack's own per-thread
- // event throttling. Cross-process dedup is *not* covered; see note in
- // processedEvents.
+ // replace. The Redis event dedup at the top of this file suppresses
+ // duplicate deliveries across instances, and Slack throttles per thread.
const existing = await findByThread(threadTs, payload);
if (existing) {
await replace(existing.id, payload);
diff --git a/apps/server/src/routes/slack/interactions.test.ts b/apps/server/src/routes/slack/interactions.test.ts
index 75c0e5034..09b9109c0 100644
--- a/apps/server/src/routes/slack/interactions.test.ts
+++ b/apps/server/src/routes/slack/interactions.test.ts
@@ -48,7 +48,10 @@ function configureSlackDoubles() {
});
slackTestState.resolveWorkspace = (teamId: string) =>
teamId === "T_KNOWN"
- ? Promise.resolve({ botToken: "xoxb-fallback", workspace: { id: 1 } })
+ ? Promise.resolve({
+ botToken: "xoxb-fallback",
+ workspace: { id: 1, limits: { "slack-agent": true } },
+ })
: Promise.resolve(null);
}
@@ -249,7 +252,10 @@ describe("handleSlackInteraction (dispatch)", () => {
slackTestState.resolveWorkspace = (teamId: string) => {
resolveCalls++;
return teamId === "T_KNOWN"
- ? Promise.resolve({ botToken: "xoxb-fresh", workspace: { id: 1 } })
+ ? Promise.resolve({
+ botToken: "xoxb-fresh",
+ workspace: { id: 1, limits: { "slack-agent": true } },
+ })
: Promise.resolve(null);
};
@@ -273,7 +279,10 @@ describe("handleSlackInteraction (dispatch)", () => {
// A reinstall can point the team at a different workspace than the one the
// card was drafted for; executing it there would hit the wrong status page.
slackTestState.resolveWorkspace = () =>
- Promise.resolve({ botToken: "xoxb-other", workspace: { id: 2 } });
+ Promise.resolve({
+ botToken: "xoxb-other",
+ workspace: { id: 2, limits: { "slack-agent": true } },
+ });
await signAndPost(app, {
type: "block_actions",
@@ -475,7 +484,7 @@ describe("registry-runner execution paths", () => {
slackTestState.resolveWorkspace = () =>
Promise.resolve({
botToken: "xoxb-fallback",
- workspace: { id: workspace.id },
+ workspace: { id: workspace.id, limits: { "slack-agent": true } },
});
slackTestState.usersInfoImpl = () =>
Promise.resolve({
diff --git a/apps/server/src/routes/slack/interactions.ts b/apps/server/src/routes/slack/interactions.ts
index 1398a87ea..62bb1d2d8 100644
--- a/apps/server/src/routes/slack/interactions.ts
+++ b/apps/server/src/routes/slack/interactions.ts
@@ -17,8 +17,10 @@ import { renderToolResult } from "./presenters";
import { executeRegistryAction, getRegistryTool } from "./registry-runner";
import {
linkAccountUrl,
+ planRequiredMessage,
requireSlackMember,
type SlackActor,
+ slackAgentAllowed,
} from "./require-slack-member";
import { toServiceCtx } from "./service-adapter";
import { resolveWorkspace } from "./workspace-resolver";
@@ -126,6 +128,14 @@ async function processInteraction(
// exempt: the initiator can always dismiss their own draft.
let actor: SlackActor | null = null;
if (parsed.kind !== "cancel") {
+ if (!slackAgentAllowed(resolved.workspace)) {
+ await slack.chat.postEphemeral({
+ channel: channelId,
+ user: userId,
+ ...planRequiredMessage(config),
+ });
+ return;
+ }
actor = await requireSlackMember({
workspace: resolved.workspace,
teamId: workspaceTeamId,
diff --git a/apps/server/src/routes/slack/require-slack-member.ts b/apps/server/src/routes/slack/require-slack-member.ts
index a42ccf7f6..5292527b9 100644
--- a/apps/server/src/routes/slack/require-slack-member.ts
+++ b/apps/server/src/routes/slack/require-slack-member.ts
@@ -61,6 +61,19 @@ export async function claimLinkCardWindow(
return claimed !== null;
}
+/** Claims the per-user plan-notice window, kept apart from the link card's. */
+export async function claimPlanNoticeWindow(
+ teamId: string,
+ slackUserId: string,
+): Promise<boolean> {
+ const claimed = await redis.set(
+ `slack:plannotice:${teamId}:${slackUserId}`,
+ "1",
+ { nx: true, ex: LINK_CARD_WINDOW_SECONDS },
+ );
+ return claimed !== null;
+}
+
/** Frees the window again when the card never made it out. */
export async function releaseLinkCardWindow(
teamId: string,
@@ -68,3 +81,13 @@ export async function releaseLinkCardWindow(
): Promise<void> {
await redis.del(linkCardKey(teamId, slackUserId));
}
+
+export function slackAgentAllowed(workspace: Workspace): boolean {
+ return workspace.limits["slack-agent"] === true;
+}
+
+export function planRequiredMessage(config: SlackConfig): { text: string } {
+ return {
+ text: `openstatus in Slack isn't included in this workspace's plan. <${config.dashboardUrl}/settings/billing|Upgrade> to use it.`,
+ };
+}
diff --git a/apps/server/src/routes/slack/running-turns.ts b/apps/server/src/routes/slack/running-turns.ts
index added666d..71a0b450f 100644
--- a/apps/server/src/routes/slack/running-turns.ts
+++ b/apps/server/src/routes/slack/running-turns.ts
@@ -1,27 +1,54 @@
+import { redis } from "@/libs/clients";
+
/**
* Turns currently being processed, so Slack's stop button can cancel them.
*
* Keyed by thread, which is what the user's stop acts on. A thread can hold
- * more than one: the dedup in `handler.ts` is per message, so two messages
- * sent in quick succession overlap, and stop means "stop this thread".
- *
- * Process-local: with more than one server instance the stop event can land
- * where the turn isn't running, and that instance simply finds nothing to
- * abort. The handler clears the session status either way, so the user always
- * gets out of the loading state.
+ * more than one: two messages sent in quick succession overlap, and stop
+ * means "stop this thread". A stop is also written to Redis, and every
+ * running turn polls for it, so it reaches the instance running the turn.
*/
const turns = new Map<string, Set<AbortController>>();
+const pollers = new Map<AbortController, ReturnType<typeof setInterval>>();
+
+const STOP_POLL_MS = 1_000;
+const STOP_TTL_SECONDS = 10 * 60;
function key(channel: string, threadTs: string): string {
return `${channel}:${threadTs}`;
}
+function stopKey(channel: string, threadTs: string): string {
+ return `slack:stop:${key(channel, threadTs)}`;
+}
+
export function startTurn(channel: string, threadTs: string): AbortController {
const controller = new AbortController();
const id = key(channel, threadTs);
const running = turns.get(id);
if (running) running.add(controller);
else turns.set(id, new Set([controller]));
+
+ // Stops are ordered by a Redis counter, not host clocks, so only a stop
+ // counted after this turn started aborts it.
+ const readStopSeq = async () =>
+ Number((await redis.get(stopKey(channel, threadTs))) ?? 0);
+ let baseline: number | undefined;
+ readStopSeq()
+ .then((seq) => {
+ baseline ??= seq;
+ })
+ .catch(() => {});
+ const poller = setInterval(async () => {
+ try {
+ const seq = await readStopSeq();
+ if (baseline === undefined) baseline = seq;
+ else if (seq > baseline) controller.abort();
+ } catch {
+ // A Redis hiccup only delays a cross-instance stop until the next poll.
+ }
+ }, STOP_POLL_MS);
+ pollers.set(controller, poller);
return controller;
}
@@ -30,6 +57,8 @@ export function endTurn(
threadTs: string,
controller: AbortController,
): void {
+ clearInterval(pollers.get(controller));
+ pollers.delete(controller);
const id = key(channel, threadTs);
const running = turns.get(id);
if (!running) return;
@@ -44,3 +73,13 @@ export function abortTurn(channel: string, threadTs: string): boolean {
for (const controller of running) controller.abort();
return true;
}
+
+/** Tells turns of this thread running on other instances to stop. */
+export async function broadcastStop(
+ channel: string,
+ threadTs: string,
+): Promise<void> {
+ const k = stopKey(channel, threadTs);
+ await redis.incr(k);
+ await redis.expire(k, STOP_TTL_SECONDS);
+}
diff --git a/packages/services/src/integration/__tests__/uninstall-slack-agent.test.ts b/packages/services/src/integration/__tests__/uninstall-slack-agent.test.ts
new file mode 100644
index 000000000..862c87f95
--- /dev/null
+++ b/packages/services/src/integration/__tests__/uninstall-slack-agent.test.ts
@@ -0,0 +1,130 @@
+import { and, eq } from "@openstatus/db";
+import {
+ integration,
+ pageSubscriber,
+ slackUser,
+} from "@openstatus/db/src/schema";
+import { createPage, createSlackUser } from "@openstatus/db/src/test/factories";
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import {
+ createWorkspaceFixture,
+ expectAuditRow,
+ makeSlackCtx,
+ withTestTransaction,
+} from "../../../test/helpers";
+import { ForbiddenError } from "../../errors";
+import { createSlackSubscriber } from "../../page-subscriber/slack";
+import { installSlackAgent } from "../install-slack-agent";
+import { uninstallSlackTeam } from "../uninstall-slack-agent";
+
+const input = (teamId: string) => ({
+ externalId: teamId,
+ credential: { botToken: "xoxb-secret", botUserId: "B_BOT" },
+ data: {
+ teamId,
+ teamName: "Fixture Team",
+ appId: "A_APP",
+ scopes: "chat:write",
+ installedBy: "U_INSTALLER",
+ },
+});
+
+describe("installSlackAgent plan check", () => {
+ test("a plan without the Slack agent is refused", async () => {
+ const free = await createWorkspaceFixture("free");
+ const ctx = makeSlackCtx(free.workspace, {
+ teamId: "T_FREE",
+ slackUserId: "U1",
+ userId: free.userId,
+ });
+ await expect(
+ installSlackAgent({ ctx, input: input("T_FREE") }),
+ ).rejects.toThrow(ForbiddenError);
+ });
+});
+
+describe("uninstallSlackTeam", () => {
+ test("removes the integration, links and subscriptions, all audited", async () => {
+ const teamId = `T_UNINSTALL_${crypto.randomUUID()}`;
+ const team = await createWorkspaceFixture("team");
+ const page = await createPage(team.workspace.id);
+
+ await withTestTransaction(async (tx) => {
+ const ctx = {
+ ...makeSlackCtx(team.workspace, {
+ teamId,
+ slackUserId: "U1",
+ userId: team.userId,
+ }),
+ db: tx,
+ };
+ const installed = await installSlackAgent({ ctx, input: input(teamId) });
+ const link = await createSlackUser(
+ team.workspace.id,
+ team.userId,
+ { slackTeamId: teamId },
+ tx,
+ );
+ const sub = await createSlackSubscriber({
+ input: { pageId: page.id, teamId, channelId: "C_UNINSTALL" },
+ db: tx,
+ });
+
+ const result = await uninstallSlackTeam({
+ input: { teamId },
+ job: "slack-app_uninstalled",
+ db: tx,
+ });
+ expect(result).toEqual({ workspaces: 1, unsubscribed: 1 });
+
+ expect(
+ await tx
+ .select()
+ .from(integration)
+ .where(eq(integration.id, installed.id))
+ .get(),
+ ).toBeUndefined();
+ expect(
+ await tx
+ .select()
+ .from(slackUser)
+ .where(and(eq(slackUser.id, link.id)))
+ .get(),
+ ).toBeUndefined();
+ const subscriber = await tx
+ .select()
+ .from(pageSubscriber)
+ .where(eq(pageSubscriber.id, sub.id))
+ .get();
+ expect(subscriber).toBeDefined();
+ expect(subscriber?.unsubscribedAt).not.toBeNull();
+
+ await expectAuditRow({
+ workspaceId: team.workspace.id,
+ action: "integration.delete",
+ entityType: "integration",
+ entityId: installed.id,
+ actorType: "system",
+ db: tx,
+ });
+ await expectAuditRow({
+ workspaceId: team.workspace.id,
+ action: "slack_user.delete",
+ entityType: "slack_user",
+ entityId: link.id,
+ actorType: "system",
+ db: tx,
+ });
+ await expectAuditRow({
+ workspaceId: team.workspace.id,
+ action: "page_subscriber.update",
+ entityType: "page_subscriber",
+ entityId: sub.id,
+ actorType: "system",
+ db: tx,
+ });
+ });
+ });
+});
diff --git a/packages/services/src/integration/index.ts b/packages/services/src/integration/index.ts
index f6819105f..893bf7903 100644
--- a/packages/services/src/integration/index.ts
+++ b/packages/services/src/integration/index.ts
@@ -1,9 +1,14 @@
export { deleteIntegration } from "./delete";
export { installSlackAgent } from "./install-slack-agent";
+export {
+ uninstallSlackAgent,
+ uninstallSlackTeam,
+} from "./uninstall-slack-agent";
export { listIntegrations, type IntegrationSummary } from "./list";
export {
DeleteIntegrationInput,
InstallSlackAgentInputSchema,
type InstallSlackAgentInput,
ListIntegrationsInput,
+ UninstallSlackTeamInput,
} from "./schemas";
diff --git a/packages/services/src/integration/install-slack-agent.ts b/packages/services/src/integration/install-slack-agent.ts
index 62961bfdf..0f8a2611b 100644
--- a/packages/services/src/integration/install-slack-agent.ts
+++ b/packages/services/src/integration/install-slack-agent.ts
@@ -4,7 +4,7 @@ import { integration } from "@openstatus/db/src/schema";
import { emitAudit } from "../audit";
import { requireScope } from "../auth";
import { type ServiceContext, withTransaction } from "../context";
-import { InternalServiceError, NotFoundError } from "../errors";
+import { ForbiddenError, InternalServiceError, NotFoundError } from "../errors";
import {
type InstallSlackAgentInput,
InstallSlackAgentInputSchema,
@@ -27,6 +27,9 @@ export async function installSlackAgent(args: {
const { ctx } = args;
requireScope(ctx, "write");
const input = InstallSlackAgentInputSchema.parse(args.input);
+ if (!ctx.workspace.limits["slack-agent"]) {
+ throw new ForbiddenError("The Slack agent is not included in your plan");
+ }
return withTransaction(ctx, async (tx) => {
// The DB has no `UNIQUE (workspace_id, name)` constraint, so a race
diff --git a/packages/services/src/integration/schemas.ts b/packages/services/src/integration/schemas.ts
index 5bc815619..a07166068 100644
--- a/packages/services/src/integration/schemas.ts
+++ b/packages/services/src/integration/schemas.ts
@@ -23,3 +23,6 @@ export const InstallSlackAgentInputSchema = z.object({
export type InstallSlackAgentInput = z.infer<
typeof InstallSlackAgentInputSchema
>;
+
+export const UninstallSlackTeamInput = z.object({ teamId: z.string().min(1) });
+export type UninstallSlackTeamInput = z.infer<typeof UninstallSlackTeamInput>;
diff --git a/packages/services/src/integration/uninstall-slack-agent.ts b/packages/services/src/integration/uninstall-slack-agent.ts
new file mode 100644
index 000000000..32fdfe16b
--- /dev/null
+++ b/packages/services/src/integration/uninstall-slack-agent.ts
@@ -0,0 +1,100 @@
+import { and, db as defaultDb, eq, inArray } from "@openstatus/db";
+import { integration, workspace } from "@openstatus/db/src/schema";
+
+import { emitAudit } from "../audit";
+import { requireScope } from "../auth";
+import { type DB, type ServiceContext, withTransaction } from "../context";
+import { parseWorkspaceForContext } from "../page-subscriber/internal";
+import { removeSlackTeamSubscribers } from "../page-subscriber/slack";
+import { deleteSlackUserMappings } from "../slack-user/internal";
+import { UninstallSlackTeamInput } from "./schemas";
+import { snapshotIntegration } from "./snapshot";
+
+/**
+ * Removes the workspace's link to a Slack team after Slack reports the app
+ * uninstalled or its bot token revoked: the integration row and the team's
+ * Slack account links go, each with its audit row.
+ */
+export async function uninstallSlackAgent(args: {
+ ctx: ServiceContext;
+ input: UninstallSlackTeamInput;
+}): Promise<void> {
+ const { ctx } = args;
+ requireScope(ctx, "write");
+ const input = UninstallSlackTeamInput.parse(args.input);
+
+ await withTransaction(ctx, async (tx) => {
+ const removed = await tx
+ .delete(integration)
+ .where(
+ and(
+ eq(integration.name, "slack-agent"),
+ eq(integration.workspaceId, ctx.workspace.id),
+ eq(integration.externalId, input.teamId),
+ ),
+ )
+ .returning();
+ for (const row of removed) {
+ await emitAudit(tx, ctx, {
+ action: "integration.delete",
+ entityType: "integration",
+ entityId: row.id,
+ before: await snapshotIntegration(row),
+ });
+ }
+ await deleteSlackUserMappings({
+ tx,
+ ctx,
+ where: { slackTeamId: input.teamId },
+ });
+ // TODO(incident/15-slack-channel): unbind every incident bound to this team.
+ });
+}
+
+/**
+ * Every workspace connected to the Slack team is uninstalled, and every
+ * channel of that team stops receiving status-page updates, whichever
+ * workspace owns the page.
+ */
+export async function uninstallSlackTeam(args: {
+ input: UninstallSlackTeamInput;
+ job: string;
+ db?: DB;
+}): Promise<{ workspaces: number; unsubscribed: number }> {
+ const input = UninstallSlackTeamInput.parse(args.input);
+ const readDb = args.db ?? defaultDb;
+ const rows = await readDb
+ .select()
+ .from(workspace)
+ .where(
+ inArray(
+ workspace.id,
+ readDb
+ .select({ id: integration.workspaceId })
+ .from(integration)
+ .where(
+ and(
+ eq(integration.name, "slack-agent"),
+ eq(integration.externalId, input.teamId),
+ ),
+ ),
+ ),
+ )
+ .all();
+ for (const row of rows) {
+ await uninstallSlackAgent({
+ ctx: {
+ workspace: parseWorkspaceForContext(row),
+ actor: { type: "system", job: args.job },
+ db: args.db,
+ },
+ input,
+ });
+ }
+ const unsubscribed = await removeSlackTeamSubscribers({
+ input,
+ job: args.job,
+ db: args.db,
+ });
+ return { workspaces: rows.length, unsubscribed };
+}
diff --git a/packages/services/src/page-subscriber/slack.ts b/packages/services/src/page-subscriber/slack.ts
index 5cf39b903..ba9057b98 100644
--- a/packages/services/src/page-subscriber/slack.ts
+++ b/packages/services/src/page-subscriber/slack.ts
@@ -226,6 +226,62 @@ export async function removeSlackSubscriber(args: {
});
}
+/**
+ * Unsubscribes every channel of a Slack team, on any workspace's page, when
+ * the app is removed from that team. Audited per subscriber as `system`.
+ */
+// Called by `uninstallSlackTeam` for a team, not a workspace: each row is
+// audited in its page's workspace, and a system actor has no scope to check.
+// oxlint-disable-next-line openstatus/services-mutation-guards
+export async function removeSlackTeamSubscribers(args: {
+ input: { teamId: string };
+ job: string;
+ db?: DB;
+}): Promise<number> {
+ const { teamId } = args.input;
+ return withTransaction({ db: args.db } as ServiceContext, async (tx) => {
+ const rows = await tx.query.pageSubscriber.findMany({
+ where: and(
+ eq(pageSubscriber.channelType, "slack"),
+ isNull(pageSubscriber.unsubscribedAt),
+ sql`json_extract(${pageSubscriber.channelConfig}, '$.teamId') = ${teamId}`,
+ ),
+ with: { page: { with: { workspace: true } } },
+ });
+ for (const existing of rows) {
+ const updated = await tx
+ .update(pageSubscriber)
+ .set({ unsubscribedAt: new Date(), updatedAt: new Date() })
+ .where(eq(pageSubscriber.id, existing.id))
+ .returning()
+ .get();
+ if (!existing.page?.workspace) continue;
+ const { page: _page, ...existingRow } = existing;
+ const { token: _bt, ...beforeSnap } =
+ selectPageSubscriberSchema.parse(existingRow);
+ const { token: _at, ...afterSnap } = selectPageSubscriberSchema.parse(
+ updated ?? existingRow,
+ );
+ await emitAudit(
+ tx,
+ {
+ workspace: parseWorkspaceForContext(existing.page.workspace),
+ actor: { type: "system", job: args.job },
+ db: tx,
+ },
+ {
+ action: "page_subscriber.update",
+ entityType: "page_subscriber",
+ entityId: existing.id,
+ before: beforeSnap,
+ after: afterSnap,
+ },
+ );
+ }
+ return rows.length;
+ });
+}
+
export interface SlackSubscriptionSummary {
id: number;
pageId: number;