@capybara-hq/testing 0.0.0-stage → 0.1.0-rc.1

package/dist/fake-slack.js

@@ -0,0 +1,654 @@
+import { createHmac, createSign, generateKeyPairSync, randomUUID, } from "node:crypto";
+import { createServer } from "node:http";
+import { WebSocketServer } from "ws";
+const readBody = (req) => new Promise((resolve) => {
+    let body = "";
+    req.on("data", (c) => {
+        body += c.toString();
+    });
+    req.on("end", () => resolve(body));
+});
+const JSON_FIELDS = new Set(["blocks", "attachments", "metadata"]);
+function parseBody(raw, contentType) {
+    if (raw === "")
+        return {};
+    if (contentType?.includes("application/json"))
+        return JSON.parse(raw);
+    const out = {};
+    for (const [k, v] of new URLSearchParams(raw)) {
+        if (JSON_FIELDS.has(k)) {
+            try {
+                out[k] = JSON.parse(v);
+                continue;
+            }
+            catch {
+                // 原样保留，交给方法自己报 invalid_blocks
+            }
+        }
+        out[k] = v;
+    }
+    return out;
+}
+/** 启动假 Slack（监听 127.0.0.1 随机端口）。 */
+export async function startFakeSlack(opts = {}) {
+    const teamId = opts.teamId ?? "T0001";
+    const botUserId = opts.botUserId ?? "UBOT";
+    const botId = opts.botId ?? "B0001";
+    const botName = opts.botName ?? "capybara";
+    const botToken = opts.botToken ?? "xoxb-fake-bot-token";
+    const appToken = opts.appToken ?? "xapp-fake-app-token";
+    const clientId = opts.clientId ?? "cli-fake-slack";
+    const clientSecret = opts.clientSecret ?? "fake-slack-client-secret";
+    const signing = generateKeyPairSync("rsa", { modulusLength: 2048 });
+    const foreign = generateKeyPairSync("rsa", { modulusLength: 2048 });
+    const kid = "fake-slack-key-1";
+    /** 未兑换的授权码 → 登录信息。 */
+    const codes = new Map();
+    /** access token → user id。 */
+    const accessTokens = new Map();
+    let tamper;
+    const messages = [];
+    const updates = [];
+    const calls = [];
+    const acks = [];
+    const users = new Map();
+    const failures = [];
+    const sockets = [];
+    const peerPorts = new WeakMap();
+    /** Every app by app token; the default app first. */
+    const apps = new Map();
+    apps.set(appToken, { appToken, botToken, teamId, botUserId, botId });
+    for (const a of opts.apps ?? []) {
+        if (apps.has(a.appToken))
+            throw new Error(`fake slack: duplicate app token ${a.appToken}`);
+        apps.set(a.appToken, {
+            appToken: a.appToken,
+            botToken: a.botToken,
+            teamId: a.teamId ?? teamId,
+            botUserId: a.botUserId ?? botUserId,
+            botId: a.botId ?? botId,
+        });
+    }
+    const appOfBot = (token) => [...apps.values()].find((a) => a.botToken === token);
+    const redeliver = opts.redeliverUnacked ?? false;
+    /** Which app each socket belongs to; the ticket from `apps.connections.open` names the app. */
+    const socketApp = new WeakMap();
+    const ticketApp = new Map();
+    const openedBy = new Map();
+    const peakBy = new Map();
+    /** Pushed, not yet acked envelopes in push order; `ws` is set while delivered to an open socket. */
+    const pending = new Map();
+    const ackWaiters = new Map();
+    const delays = new Map();
+    let dropLeft = 0;
+    let opened = 0;
+    let peak = 0;
+    let seq = 0;
+    let envSeq = 0;
+    let base = "";
+    const reply = (res, body, status = 200, headers = {}) => {
+        res.writeHead(status, { "content-type": "application/json", ...headers });
+        res.end(JSON.stringify(body));
+    };
+    const nextTs = () => {
+        seq++;
+        return `${1_760_000_000 + seq}.${String(seq).padStart(6, "0")}`;
+    };
+    const str = (v) => (typeof v === "string" ? v : undefined);
+    const api = async (req, res, method) => {
+        const body = parseBody(await readBody(req), req.headers["content-type"]);
+        const auth = String(req.headers.authorization ?? "");
+        const token = auth.startsWith("Bearer ") ? auth.slice(7) : (str(body.token) ?? "");
+        calls.push({ method, token, body });
+        const wait = delays.get(method) ?? 0;
+        if (wait > 0)
+            await new Promise((r) => setTimeout(r, wait));
+        const f = failures.find((x) => x.method === method && x.left > 0);
+        if (f) {
+            f.left--;
+            const { status, error, retryAfter } = f.failure;
+            if (f.failure.body !== undefined)
+                return reply(res, f.failure.body);
+            if (status !== undefined && status !== 200) {
+                const headers = retryAfter !== undefined ? { "retry-after": String(retryAfter) } : {};
+                return reply(res, { ok: false, error: error ?? "ratelimited" }, status, headers);
+            }
+            return reply(res, { ok: false, error: error ?? "internal_error" });
+        }
+        if (method === "openid.connect.token")
+            return oidcToken(res, body);
+        if (method === "openid.connect.userInfo") {
+            const u = users.get(accessTokens.get(token) ?? "");
+            if (!u)
+                return reply(res, { ok: false, error: "invalid_auth" });
+            return reply(res, { ok: true, ...profileClaims(u) });
+        }
+        const app = method === "apps.connections.open" ? apps.get(token) : appOfBot(token);
+        if (!app)
+            return reply(res, { ok: false, error: "invalid_auth" });
+        switch (method) {
+            case "auth.test":
+                return reply(res, {
+                    ok: true,
+                    url: "https://fake.slack.com/",
+                    team: "Fake Team",
+                    user: botName,
+                    team_id: app.teamId,
+                    user_id: app.botUserId,
+                    bot_id: app.botId,
+                });
+            case "apps.connections.open":
+                opened++;
+                ticketApp.set(opened, app.appToken);
+                openedBy.set(app.appToken, (openedBy.get(app.appToken) ?? 0) + 1);
+                return reply(res, {
+                    ok: true,
+                    url: `${base.replace(/^http/, "ws")}/link?ticket=${opened}`,
+                });
+            case "users.info": {
+                const u = users.get(str(body.user) ?? "");
+                if (!u)
+                    return reply(res, { ok: false, error: "user_not_found" });
+                return reply(res, {
+                    ok: true,
+                    user: {
+                        id: u.id,
+                        team_id: u.teamId,
+                        name: u.name,
+                        real_name: u.realName ?? u.name,
+                        is_bot: u.isBot ?? false,
+                        profile: {
+                            display_name: u.displayName ?? "",
+                            real_name: u.realName ?? u.name,
+                            ...(u.image72 !== undefined && { image_72: u.image72 }),
+                        },
+                    },
+                });
+            }
+            case "chat.postMessage": {
+                const channel = str(body.channel);
+                const text = str(body.text) ?? "";
+                if (!channel)
+                    return reply(res, { ok: false, error: "channel_not_found" });
+                if (text === "" && body.blocks === undefined)
+                    return reply(res, { ok: false, error: "no_text" });
+                if (text.length > 40_000)
+                    return reply(res, { ok: false, error: "msg_too_long" });
+                if (body.blocks !== undefined && !Array.isArray(body.blocks))
+                    return reply(res, { ok: false, error: "invalid_blocks_format" });
+                const threadTs = str(body.thread_ts);
+                const m = {
+                    channel,
+                    ts: nextTs(),
+                    text,
+                    ...(Array.isArray(body.blocks) && { blocks: body.blocks }),
+                    ...(threadTs !== undefined && { threadTs }),
+                    at: Date.now(),
+                };
+                messages.push(m);
+                return reply(res, { ok: true, channel, ts: m.ts, message: { text, ts: m.ts } });
+            }
+            case "chat.update": {
+                const channel = str(body.channel);
+                const ts = str(body.ts);
+                const text = str(body.text) ?? "";
+                const orig = messages.find((m) => m.channel === channel && m.ts === ts);
+                if (!orig || channel === undefined || ts === undefined)
+                    return reply(res, { ok: false, error: "message_not_found" });
+                if (text.length > 4000)
+                    return reply(res, { ok: false, error: "msg_too_long" });
+                updates.push({
+                    channel,
+                    ts,
+                    text,
+                    ...(Array.isArray(body.blocks) && { blocks: body.blocks }),
+                    ...(orig.threadTs !== undefined && { threadTs: orig.threadTs }),
+                    at: Date.now(),
+                });
+                return reply(res, { ok: true, channel, ts, text });
+            }
+            case "users.list": {
+                const limit = Math.max(1, Math.min(1000, Number(body.limit ?? 100) || 100));
+                const offset = str(body.cursor)
+                    ? Number(Buffer.from(str(body.cursor), "base64url").toString())
+                    : 0;
+                if (!Number.isInteger(offset) || offset < 0)
+                    return reply(res, { ok: false, error: "invalid_cursor" });
+                const all = [
+                    {
+                        id: "USLACKBOT",
+                        team_id: teamId,
+                        name: "slackbot",
+                        deleted: false,
+                        is_bot: false,
+                        is_app_user: false,
+                        real_name: "Slackbot",
+                        profile: { real_name: "Slackbot", display_name: "Slackbot" },
+                    },
+                    ...[...users.values()].map((u) => ({
+                        id: u.id,
+                        team_id: u.teamId,
+                        name: u.name,
+                        deleted: u.deleted ?? false,
+                        is_bot: u.isBot ?? false,
+                        is_app_user: false,
+                        is_restricted: u.isRestricted ?? false,
+                        is_ultra_restricted: u.isUltraRestricted ?? false,
+                        real_name: u.realName ?? u.name,
+                        profile: {
+                            real_name: u.realName ?? u.name,
+                            display_name: u.displayName ?? "",
+                            ...(u.email !== undefined && { email: u.email }),
+                            ...(u.image72 !== undefined && { image_72: u.image72 }),
+                        },
+                    })),
+                ];
+                const page = all.slice(offset, offset + limit);
+                const end = offset + limit;
+                const next = end < all.length ? Buffer.from(String(end)).toString("base64url") : "";
+                return reply(res, {
+                    ok: true,
+                    members: page,
+                    cache_ts: Math.floor(Date.now() / 1000),
+                    response_metadata: { next_cursor: next },
+                });
+            }
+            default:
+                return reply(res, { ok: false, error: "unknown_method" });
+        }
+    };
+    /** OIDC 的用户资料声明（userInfo 与 ID token 共用）。 */
+    const profileClaims = (u) => ({
+        sub: u.id,
+        "https://slack.com/user_id": u.id,
+        "https://slack.com/team_id": u.teamId,
+        name: u.realName ?? u.name,
+        given_name: (u.realName ?? u.name).split(" ")[0],
+        ...(u.email !== undefined && { email: u.email, email_verified: u.emailVerified ?? false }),
+        ...(u.image72 !== undefined && { picture: u.image72 }),
+        locale: "en-US",
+    });
+    const b64 = (v) => Buffer.from(JSON.stringify(v)).toString("base64url");
+    const signJwt = (claims, key, keyId = kid) => {
+        const input = `${b64({ alg: "RS256", typ: "JWT", kid: keyId })}.${b64(claims)}`;
+        const sig = createSign("RSA-SHA256").update(input).sign(key).toString("base64url");
+        return `${input}.${sig}`;
+    };
+    const oidcToken = (res, body) => {
+        if (str(body.client_id) !== clientId)
+            return reply(res, { ok: false, error: "invalid_client_id" });
+        if (str(body.client_secret) !== clientSecret)
+            return reply(res, { ok: false, error: "bad_client_secret" });
+        const code = str(body.code) ?? "";
+        const c = codes.get(code);
+        if (!c)
+            return reply(res, { ok: false, error: "invalid_code" });
+        codes.delete(code);
+        if (str(body.redirect_uri) !== c.redirectUri)
+            return reply(res, { ok: false, error: "bad_redirect_uri" });
+        const u = users.get(c.userId);
+        if (!u)
+            return reply(res, { ok: false, error: "invalid_code" });
+        const access = `xoxp-oidc-${randomUUID()}`;
+        accessTokens.set(access, u.id);
+        const now = Math.floor(Date.now() / 1000);
+        const t = tamper;
+        tamper = undefined;
+        const claims = {
+            iss: "https://slack.com",
+            aud: clientId,
+            exp: now + 300,
+            iat: now,
+            auth_time: now,
+            nonce: c.nonce,
+            ...profileClaims(u),
+            ...t?.claims,
+        };
+        const idToken = signJwt(claims, t?.foreignKey ? foreign.privateKey : signing.privateKey, t?.kid ?? kid);
+        return reply(res, { ok: true, access_token: access, token_type: "Bearer", id_token: idToken });
+    };
+    const authorize = (res, u) => {
+        const q = u.searchParams;
+        const redirectUri = q.get("redirect_uri");
+        if (!redirectUri)
+            return reply(res, { error: "missing redirect_uri" }, 400);
+        const back = new URL(redirectUri);
+        const state = q.get("state");
+        if (state !== null)
+            back.searchParams.set("state", state);
+        const user = users.get(q.get("as") ?? "");
+        if (q.get("client_id") !== clientId || q.get("response_type") !== "code" || !user) {
+            back.searchParams.set("error", "access_denied");
+        }
+        else {
+            const code = `code-${randomUUID()}`;
+            codes.set(code, { userId: user.id, nonce: q.get("nonce") ?? "", redirectUri });
+            back.searchParams.set("code", code);
+        }
+        res.writeHead(302, { location: back.toString() }).end();
+    };
+    const server = createServer((req, res) => {
+        void (async () => {
+            const u = new URL(req.url ?? "/", "http://x");
+            const m = /^\/api\/([A-Za-z.]+)$/.exec(u.pathname);
+            if (m && req.method === "POST")
+                return api(req, res, m[1]);
+            if (u.pathname === "/openid/connect/authorize" && req.method === "GET")
+                return authorize(res, u);
+            if (u.pathname === "/openid/connect/keys" && req.method === "GET") {
+                const jwk = signing.publicKey.export({ format: "jwk" });
+                return reply(res, { keys: [{ ...jwk, kid, alg: "RS256", use: "sig" }] });
+            }
+            res.writeHead(404).end();
+        })().catch(() => {
+            if (!res.headersSent)
+                res.writeHead(500);
+            res.end();
+        });
+    });
+    const wss = new WebSocketServer({ noServer: true });
+    server.on("upgrade", (req, socket, head) => {
+        const u = new URL(req.url ?? "/", "http://x");
+        if (u.pathname !== "/link") {
+            socket.destroy();
+            return;
+        }
+        const app = ticketApp.get(Number(u.searchParams.get("ticket"))) ?? appToken;
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            sockets.push(ws);
+            socketApp.set(ws, app);
+            if (req.socket.remotePort !== undefined)
+                peerPorts.set(ws, req.socket.remotePort);
+            peak = Math.max(peak, sockets.length);
+            peakBy.set(app, Math.max(peakBy.get(app) ?? 0, socketsOf(app).length));
+            ws.on("close", () => {
+                const i = sockets.indexOf(ws);
+                if (i >= 0)
+                    sockets.splice(i, 1);
+                // Envelopes this socket never acked: retried on the app's next socket, or dropped
+                for (const [id, p] of pending) {
+                    if (p.ws !== ws)
+                        continue;
+                    if (!redeliver) {
+                        pending.delete(id);
+                        continue;
+                    }
+                    p.ws = undefined;
+                    p.attempt++;
+                }
+                flush(app);
+            });
+            ws.on("message", (data) => {
+                let msg;
+                try {
+                    msg = JSON.parse(String(data));
+                }
+                catch {
+                    return;
+                }
+                if (typeof msg.envelope_id !== "string")
+                    return;
+                const a = {
+                    envelopeId: msg.envelope_id,
+                    payload: msg.payload,
+                    at: Date.now(),
+                };
+                acks.push(a);
+                pending.delete(a.envelopeId);
+                for (const w of ackWaiters.get(a.envelopeId) ?? [])
+                    w(a);
+                ackWaiters.delete(a.envelopeId);
+            });
+            ws.send(JSON.stringify({
+                type: "hello",
+                num_connections: sockets.length,
+                debug_info: { host: "fake-slack" },
+                connection_info: { app_id: "A0001" },
+            }));
+            if (dropLeft > 0) {
+                dropLeft--;
+                ws.close(1011);
+                return;
+            }
+            flush(app);
+        });
+    });
+    await new Promise((r) => server.listen(0, "127.0.0.1", r));
+    base = `http://127.0.0.1:${server.address().port}`;
+    function socketsOf(app) {
+        return sockets.filter((ws) => socketApp.get(ws) === app);
+    }
+    /** Delivers the app's queued envelopes (push order) to its most recently opened open socket. */
+    function flush(app) {
+        const ws = socketsOf(app)
+            .filter((s) => s.readyState === s.OPEN)
+            .at(-1);
+        if (!ws)
+            return;
+        for (const [envelope_id, p] of pending) {
+            if (p.app !== app || p.ws !== undefined)
+                continue;
+            p.ws = ws;
+            ws.send(JSON.stringify({
+                ...p.envelope,
+                envelope_id,
+                accepts_response_payload: false,
+                ...(p.attempt > 0 && { retry_attempt: p.attempt, retry_reason: "timeout" }),
+            }));
+        }
+    }
+    const appTokenOf = (target) => {
+        const app = target?.appToken ?? appToken;
+        if (!apps.has(app))
+            throw new Error(`fake slack: unknown app token ${app}`);
+        return app;
+    };
+    const push = (envelope, target) => {
+        const app = appTokenOf(target);
+        const envelope_id = envelope.envelope_id ?? `env-${++envSeq}`;
+        const { envelope_id: _, ...rest } = envelope;
+        pending.set(envelope_id, { app, envelope: rest, attempt: 0 });
+        flush(app);
+        return envelope_id;
+    };
+    return {
+        url: base,
+        apiUrl: `${base}/api/`,
+        teamId,
+        botUserId,
+        botId,
+        botToken,
+        appToken,
+        clientId,
+        clientSecret,
+        messages,
+        updates,
+        calls,
+        acks,
+        users,
+        connectionsOpened: (app) => (app === undefined ? opened : (openedBy.get(app) ?? 0)),
+        openSockets: (app) => (app === undefined ? sockets : socketsOf(app)).length,
+        maxConcurrentSockets: (app) => (app === undefined ? peak : (peakBy.get(app) ?? 0)),
+        pendingEnvelopes: (app) => [...pending.values()].filter((p) => app === undefined || p.app === app).length,
+        socketPeerPorts: (app) => (app === undefined ? sockets : socketsOf(app)).flatMap((ws) => {
+            const port = peerPorts.get(ws);
+            return port === undefined ? [] : [port];
+        }),
+        failNext(method, failure, count = 1) {
+            failures.push({ method, failure, left: count });
+        },
+        delay(method, ms) {
+            delays.set(method, ms);
+        },
+        dropNextConnections(count) {
+            dropLeft = count;
+        },
+        push,
+        pushEvent(event, o = {}) {
+            const app = appTokenOf(o);
+            return push({
+                type: "events_api",
+                payload: slackEventCallback(event, {
+                    teamId: o.teamId ?? apps.get(app)?.teamId ?? teamId,
+                    eventId: o.eventId ?? `Ev${++envSeq}`,
+                }),
+            }, { appToken: app });
+        },
+        pushInteractive(payload, target) {
+            return push({ type: "interactive", payload }, { appToken: appTokenOf(target) });
+        },
+        waitForAck(envelopeId, timeoutMs = 5000) {
+            const done = acks.find((a) => a.envelopeId === envelopeId);
+            if (done)
+                return Promise.resolve(done);
+            return new Promise((resolve, reject) => {
+                const t = setTimeout(() => reject(new Error(`fake slack: envelope ${envelopeId} not acked`)), timeoutMs);
+                const list = ackWaiters.get(envelopeId) ?? [];
+                list.push((a) => {
+                    clearTimeout(t);
+                    resolve(a);
+                });
+                ackWaiters.set(envelopeId, list);
+            });
+        },
+        acked: (id) => acks.some((a) => a.envelopeId === id),
+        disconnectAll(reason = "refresh_requested") {
+            for (const ws of [...sockets]) {
+                ws.send(JSON.stringify({ type: "disconnect", reason }));
+                ws.close(1000);
+            }
+        },
+        tamperNextIdToken(claims, o = {}) {
+            tamper = {
+                claims,
+                foreignKey: o.foreignKey ?? false,
+                ...(o.kid !== undefined && { kid: o.kid }),
+            };
+        },
+        finalText(m) {
+            return updates.filter((u) => u.channel === m.channel && u.ts === m.ts).at(-1)?.text ?? m.text;
+        },
+        finalBlocks(m) {
+            const u = updates.filter((x) => x.channel === m.channel && x.ts === m.ts).at(-1);
+            return u ? u.blocks : m.blocks;
+        },
+        async stop() {
+            for (const ws of [...sockets])
+                ws.terminate();
+            wss.close();
+            server.closeAllConnections();
+            await new Promise((r) => server.close(() => r()));
+        },
+    };
+}
+/** 私聊消息事件（`message.im`；默认频道 `D<user>`）。 */
+export function slackDmEvent(user, text, opts = {}) {
+    return {
+        type: "message",
+        channel_type: "im",
+        channel: opts.channel ?? `D${user}`,
+        user,
+        text,
+        ts: opts.ts ?? `${1_750_000_000 + Math.floor(Math.random() * 1e6)}.000100`,
+        ...(opts.team !== undefined && { team: opts.team }),
+        ...opts.extra,
+    };
+}
+/** 频道里 @ 机器人的事件（`app_mention`；`threadTs` 给了表示在话题里）。 */
+export function slackMentionEvent(user, botUserId, text, opts = {}) {
+    return {
+        type: "app_mention",
+        channel: opts.channel ?? "C0001",
+        user,
+        text: `<@${botUserId}> ${text}`,
+        ts: opts.ts ?? `${1_750_000_000 + Math.floor(Math.random() * 1e6)}.000200`,
+        ...(opts.threadTs !== undefined && { thread_ts: opts.threadTs }),
+        ...(opts.team !== undefined && { team: opts.team }),
+    };
+}
+/**
+ * 用户点了某条消息上的按钮（`block_actions`）。`message` 为假 Slack 记下的那条消息，`actionId` / `value`
+ * 取自其 blocks 里的按钮；`stateValues` 为 `state.values`（多选提交时带上勾选项）。
+ */
+export function slackBlockAction(user, message, action, opts = {}) {
+    return {
+        type: "block_actions",
+        user: { id: user.id, team_id: user.teamId, username: user.name ?? user.id, name: user.name },
+        team: { id: user.teamId, domain: "fake" },
+        api_app_id: "A0001",
+        trigger_id: opts.triggerId ?? `trig-${Math.random().toString(36).slice(2)}`,
+        container: {
+            type: "message",
+            message_ts: message.ts,
+            channel_id: message.channel,
+            is_ephemeral: false,
+            ...(message.threadTs !== undefined && { thread_ts: message.threadTs }),
+        },
+        channel: { id: message.channel, name: message.channel.startsWith("D") ? "directmessage" : "c" },
+        message: {
+            type: "message",
+            ts: message.ts,
+            text: message.text,
+            blocks: message.blocks,
+            ...(message.threadTs !== undefined && { thread_ts: message.threadTs }),
+        },
+        state: { values: opts.stateValues ?? {} },
+        actions: [
+            {
+                type: "button",
+                action_id: action.actionId,
+                block_id: action.blockId ?? "b",
+                ...(action.value !== undefined && { value: action.value }),
+                action_ts: opts.actionTs ?? `${Date.now() / 1000}`,
+            },
+        ],
+    };
+}
+/** 在消息的 blocks 里找按钮（按 action_id 前缀或谓词），返回 `{ actionId, value, blockId }`。 */
+export function findSlackButton(blocks, match) {
+    for (const b of blocks ?? []) {
+        const block = b;
+        if (block.type !== "actions")
+            continue;
+        for (const e of block.elements ?? []) {
+            const el = e;
+            if (el.type === "button" && match(el)) {
+                return {
+                    actionId: el.action_id,
+                    ...(el.value !== undefined && { value: el.value }),
+                    ...(block.block_id !== undefined && { blockId: block.block_id }),
+                    ...(el.url !== undefined && { url: el.url }),
+                };
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * An Events API `event_callback` body: what Slack posts to a webhook Request URL, and the payload
+ * of a Socket Mode `events_api` envelope (the same object, so both inbound modes see one shape).
+ */
+export function slackEventCallback(event, opts = {}) {
+    return {
+        token: "verification-token",
+        team_id: opts.teamId ?? "T0001",
+        api_app_id: "A0001",
+        type: "event_callback",
+        event_id: opts.eventId ?? `Ev${Math.random().toString(36).slice(2, 10)}`,
+        event_time: Math.floor(Date.now() / 1000),
+        event,
+    };
+}
+/**
+ * Signs a Slack webhook request the way Slack does
+ * (https://docs.slack.dev/authentication/verifying-requests-from-slack/): returns the
+ * `x-slack-request-timestamp` and `x-slack-signature` headers, where the signature is
+ * `v0=` + hex HMAC-SHA256(signingSecret, `v0:<ts>:<raw body>`). `ts` is in seconds.
+ */
+export function signSlackWebhook(body, signingSecret, ts) {
+    const raw = typeof body === "string" ? Buffer.from(body) : Buffer.from(body);
+    const mac = createHmac("sha256", signingSecret).update(`v0:${ts}:`).update(raw).digest("hex");
+    return { "x-slack-request-timestamp": String(ts), "x-slack-signature": `v0=${mac}` };
+}
+/** The form body Slack posts for an interactive payload (`payload=<url-encoded JSON>`). */
+export const slackInteractiveForm = (payload) => new URLSearchParams({ payload: JSON.stringify(payload) }).toString();