import { test } from "node:test"; import assert from "node:assert/strict"; import { createHmac } from "node:crypto"; import { buildServer, type ServerDeps } from "../src/server.ts"; import type { AppConfig } from "../src/config.ts"; import { verifySlackSignature } from "../src/slack/signature.ts"; import type { SlackClient } from "../src/slack/slack.ts"; const config: AppConfig = { SLACK_SIGNING_SECRET: "test-secret", SLACK_TOKEN: "xoxb-test", SLACK_ADMIN_TOKEN: "xoxp-test", SLACK_INVITE_WEBHOOK_TOKEN: "invite-secret", SLACK_INVITE_CHANNEL: "C-invites", }; function fakes(): ServerDeps { return { eventsClient: { async getUpcomingEvents() { return [ { name: "devict hack night", slug: "devict-hack-night", location: "devict", startDate: Temporal.Instant.from("2026-07-11T00:00:00.000Z").toZonedDateTimeISO("UTC"), endDate: Temporal.Instant.from("2026-07-11T01:00:00.000Z").toZonedDateTimeISO("UTC"), }, ]; }, }, slackClient: { async sendMessage() { /* no-op */ }, async inviteUser() { /* no-op */ }, async getThreadParent() { return { text: "" }; }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }; } function sign(secret: string, timestamp: number, body: string): string { const base = `v0:${timestamp}:${body}`; const mac = createHmac("sha256", secret).update(base).digest("hex"); return `v0=${mac}`; } test("GET /health returns ok", async () => { const app = buildServer(fakes(), { logger: false }); const res = await app.inject({ method: "GET", url: "/health" }); assert.equal(res.statusCode, 200); assert.deepEqual(res.json(), { status: "ok" }); await app.close(); }); test("POST /slack/webhook rejects missing signature headers", async () => { const app = buildServer(fakes(), { logger: false }); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers: { "content-type": "application/json" }, payload: "{}", }); assert.equal(res.statusCode, 401); await app.close(); }); test("POST /slack/webhook rejects an invalid signature", async () => { const app = buildServer(fakes(), { logger: false }); const body = JSON.stringify({ type: "event_callback", event: { type: "message", text: "hi" } }); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers: { "content-type": "application/json", "x-slack-request-timestamp": String(Math.floor(Date.now() / 1000)), "x-slack-signature": "v0=deadbeef", }, payload: body, }); assert.equal(res.statusCode, 401); await app.close(); }); test("POST /slack/webhook echoes challenge for url_verification", async () => { const app = buildServer(fakes(), { logger: false }); const body = JSON.stringify({ type: "url_verification", challenge: "abc123" }); const ts = Math.floor(Date.now() / 1000); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers: { "content-type": "application/json", "x-slack-request-timestamp": String(ts), "x-slack-signature": sign(config.SLACK_SIGNING_SECRET, ts, body), }, payload: body, }); assert.equal(res.statusCode, 200); assert.deepEqual(res.json(), { challenge: "abc123" }); await app.close(); }); test("POST /slack/webhook dispatches a message command", async () => { let sent: { msg: string; channel: string; thread_ts?: string } | undefined; const slackClient: SlackClient = { async sendMessage(args) { sent = args; }, async inviteUser() { /* no-op */ }, async getThreadParent() { return { text: "" }; }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }; const app = buildServer( { eventsClient: fakes().eventsClient, slackClient, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }, { logger: false }, ); const event = { type: "app_mention", text: "<@U0> !events", channel: "C1", ts: "1700000000.000100", }; const body = JSON.stringify({ type: "event_callback", event }); const ts = Math.floor(Date.now() / 1000); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers: { "content-type": "application/json", "x-slack-request-timestamp": String(ts), "x-slack-signature": sign(config.SLACK_SIGNING_SECRET, ts, body), }, payload: body, }); assert.equal(res.statusCode, 200); assert.ok(sent, "slackClient.sendMessage was called"); assert.equal(sent?.channel, "C1"); assert.equal(sent?.thread_ts, "1700000000.000100"); await app.close(); }); test("POST /invites/request rejects missing Authorization header", async () => { const app = buildServer(fakes(), { logger: false }); const res = await app.inject({ method: "POST", url: "/invites/slack/request", headers: { "content-type": "application/json" }, payload: JSON.stringify({ name: "Jane", email: "jane@example.com", reason: "friends" }), }); assert.equal(res.statusCode, 401); await app.close(); }); test("POST /invites/request rejects an invalid token", async () => { const app = buildServer(fakes(), { logger: false }); const res = await app.inject({ method: "POST", url: "/invites/slack/request", headers: { "content-type": "application/json", authorization: "Bearer wrong-token", }, payload: JSON.stringify({ name: "Jane", email: "jane@example.com", reason: "friends" }), }); assert.equal(res.statusCode, 401); await app.close(); }); test("POST /invites/request posts the request to the invite channel and returns 202", async () => { let sent: { msg: string; channel: string; thread_ts?: string } | undefined; const slackClient: SlackClient = { async sendMessage(args) { sent = args; }, async inviteUser() { /* no-op */ }, async getThreadParent() { return { text: "" }; }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }; const app = buildServer( { eventsClient: fakes().eventsClient, slackClient, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }, { logger: false }, ); const res = await app.inject({ method: "POST", url: "/invites/slack/request", headers: { "content-type": "application/json", authorization: `Bearer ${config.SLACK_INVITE_WEBHOOK_TOKEN}`, }, payload: JSON.stringify({ name: "Jane Doe", email: "jane@example.com", reason: "community" }), }); assert.equal(res.statusCode, 202); assert.equal(sent?.channel, "C-invites"); assert.ok(sent?.msg.includes("Email: jane@example.com"), "message contains the email"); assert.ok(sent?.msg.includes("Name: Jane Doe"), "message contains the name"); assert.ok(sent?.msg.includes("community"), "message contains the reason"); assert.ok(sent?.msg.includes("!invite"), "message tells the approver how to approve"); await app.close(); }); test("POST /invites/request returns 500 when sendMessage fails", async () => { const slackClient: SlackClient = { async sendMessage() { throw new Error("slack down"); }, async inviteUser() { /* no-op */ }, async getThreadParent() { return { text: "" }; }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }; const app = buildServer( { eventsClient: fakes().eventsClient, slackClient, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }, { logger: false }, ); const res = await app.inject({ method: "POST", url: "/invites/slack/request", headers: { "content-type": "application/json", authorization: `Bearer ${config.SLACK_INVITE_WEBHOOK_TOKEN}`, }, payload: JSON.stringify({ name: "Jane", email: "jane@example.com", reason: "x" }), }); assert.equal(res.statusCode, 500); await app.close(); }); function signEvent(event: Record): { body: string; ts: number; headers: Record; } { const body = JSON.stringify({ type: "event_callback", event }); const ts = Math.floor(Date.now() / 1000); return { body, ts, headers: { "content-type": "application/json", "x-slack-request-timestamp": String(ts), "x-slack-signature": sign(config.SLACK_SIGNING_SECRET, ts, body), }, }; } test("!invite in invite channel thread invites the user from the parent message", async () => { let invitedEmail: string | undefined; let reply: { msg: string; channel: string; thread_ts?: string } | undefined; const slackClient: SlackClient = { async sendMessage(args) { reply = args; }, async inviteUser({ email }) { invitedEmail = email; }, async getThreadParent() { // Slack auto-linkifies emails in message text to . return { text: "Name: Jane Doe\nEmail: \nWhat brings you: community", }; }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }; const app = buildServer( { eventsClient: fakes().eventsClient, slackClient, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }, { logger: false }, ); const event = { type: "app_mention", text: "<@U0> !invite", channel: config.SLACK_INVITE_CHANNEL, ts: "1700000000.000200", thread_ts: "1700000000.000100", }; const { body, headers } = signEvent(event); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers, payload: body }); assert.equal(res.statusCode, 200); assert.equal(invitedEmail, "jane@example.com"); assert.equal(reply?.channel, config.SLACK_INVITE_CHANNEL); assert.equal(reply?.thread_ts, "1700000000.000100"); assert.match(reply?.msg ?? "", /Invited `jane@example\.com`/); await app.close(); }); test("!invite outside the invite channel is ignored", async () => { let invited = false; const slackClient: SlackClient = { async sendMessage() {}, async inviteUser() { invited = true; }, async getThreadParent() { return { text: "Email: jane@example.com" }; }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }; const app = buildServer( { eventsClient: fakes().eventsClient, slackClient, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }, { logger: false }, ); const event = { type: "app_mention", text: "<@U0> !invite", channel: "C-elsewhere", ts: "1700000000.000200", thread_ts: "1700000000.000100", }; const { body, headers } = signEvent(event); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers, payload: body }); assert.equal(res.statusCode, 200); assert.equal(invited, false); await app.close(); }); test("!invite without a thread is ignored", async () => { let invited = false; const slackClient: SlackClient = { async sendMessage() {}, async inviteUser() { invited = true; }, async getThreadParent() { return { text: "Email: jane@example.com" }; }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }; const app = buildServer( { eventsClient: fakes().eventsClient, slackClient, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }, { logger: false }, ); // no thread_ts: top-level mention, not a reply const event = { type: "app_mention", text: "<@U0> !invite", channel: config.SLACK_INVITE_CHANNEL, ts: "1700000000.000200", }; const { body, headers } = signEvent(event); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers, payload: body }); assert.equal(res.statusCode, 200); assert.equal(invited, false); await app.close(); }); test("!invite replies with error when getThreadParent fails", async () => { let reply: { msg: string; channel: string; thread_ts?: string } | undefined; let invited = false; const slackClient: SlackClient = { async sendMessage(args) { reply = args; }, async inviteUser() { invited = true; }, async getThreadParent() { throw new Error("slack down"); }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }; const app = buildServer( { eventsClient: fakes().eventsClient, slackClient, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }, { logger: false }, ); const event = { type: "app_mention", text: "<@U0> !invite", channel: config.SLACK_INVITE_CHANNEL, ts: "1700000000.000200", thread_ts: "1700000000.000100", }; const { body, headers } = signEvent(event); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers, payload: body }); assert.equal(res.statusCode, 200); assert.equal(invited, false); assert.match(reply?.msg ?? "", /couldn't look up/i); assert.equal(reply?.thread_ts, "1700000000.000100"); await app.close(); }); test("!invite replies with error when no email found in parent message", async () => { let reply: { msg: string; channel: string; thread_ts?: string } | undefined; let invited = false; const slackClient: SlackClient = { async sendMessage(args) { reply = args; }, async inviteUser() { invited = true; }, async getThreadParent() { return { text: "a message with no email" }; }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }; const app = buildServer( { eventsClient: fakes().eventsClient, slackClient, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }, { logger: false }, ); const event = { type: "app_mention", text: "<@U0> !invite", channel: config.SLACK_INVITE_CHANNEL, ts: "1700000000.000200", thread_ts: "1700000000.000100", }; const { body, headers } = signEvent(event); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers, payload: body }); assert.equal(res.statusCode, 200); assert.equal(invited, false); assert.match(reply?.msg ?? "", /couldn't find an email/i); await app.close(); }); test("!invite replies with error when inviteUser fails", async () => { let reply: { msg: string; channel: string; thread_ts?: string } | undefined; const slackClient: SlackClient = { async sendMessage(args) { reply = args; }, async inviteUser() { throw new Error("already_in_team"); }, async getThreadParent() { return { text: "Email: jane@example.com" }; }, verifySignature({ timestamp, rawBody, signature }) { return verifySlackSignature({ signingSecret: config.SLACK_SIGNING_SECRET, timestamp, rawBody, signature, }); }, }; const app = buildServer( { eventsClient: fakes().eventsClient, slackClient, inviteWebhookToken: config.SLACK_INVITE_WEBHOOK_TOKEN, inviteChannel: config.SLACK_INVITE_CHANNEL, }, { logger: false }, ); const event = { type: "app_mention", text: "<@U0> !invite", channel: config.SLACK_INVITE_CHANNEL, ts: "1700000000.000200", thread_ts: "1700000000.000100", }; const { body, headers } = signEvent(event); const res = await app.inject({ method: "POST", url: "/slack/webhook", headers, payload: body }); assert.equal(res.statusCode, 200); assert.match(reply?.msg ?? "", /Invite failed for `jane@example\.com`: already_in_team/); await app.close(); });