@openclaw/crabline 0.1.9 → 0.1.11

package/dist/src/servers/slack.js

@@ -1,8 +1,12 @@
-import { randomBytes } from "node:crypto";
+import { createHmac, randomBytes, randomInt, timingSafeEqual } from "node:crypto";
 import path from "node:path";
-import { adminAuthError, hasAdminToken, jsonResponse, parseRequestBody, queryRecord, readInteger, readTrimmedString, startHttpJsonServer, } from "./http.js";
+import { adminAuthError, hasAdminToken, InvalidJsonBodyError, isJsonObject, isLoopbackHost, jsonResponse, parseUnknownRequestBody, queryRecord, readBody, readInteger, readTrimmedString, RequestBodyTooLargeError, startHttpJsonServer, } from "./http.js";
 import { SLACK_CHANNEL_ID_RULE, SLACK_SEND_TARGET_ID_RULE, SLACK_TS_RULE, SLACK_USER_ID_RULE, } from "../providers/slack-ids.js";
-import { recordServerEvent } from "./recorder.js";
+import { recordCommittedServerEvent, recordServerEvent, } from "./recorder.js";
+const SLACK_SIGNATURE_TOLERANCE_SECONDS = 5 * 60;
+const SLACK_EVENT_MAX_RETRIES = 3;
+const SLACK_EVENT_MAX_REDIRECTS = 2;
+const SLACK_EVENT_RETRY_DELAYS_MS = [0, 60_000, 5 * 60_000];
 function slackOk(result = {}) {
     return jsonResponse({ ok: true, ...result });
 }
@@ -18,10 +22,22 @@ function slackRateLimited(retryAfterSeconds = 1) {
         status: 429,
     });
 }
+function resolveChatPostMessageRateLimit(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Number.isSafeInteger(value.remaining) || value.remaining < 0) {
+        throw new Error("chatPostMessageRateLimit.remaining must be a non-negative safe integer.");
+    }
+    if (!Number.isSafeInteger(value.retryAfterSeconds) || value.retryAfterSeconds < 1) {
+        throw new Error("chatPostMessageRateLimit.retryAfterSeconds must be a positive safe integer.");
+    }
+    return { ...value };
+}
 function requireSlackToken(request, body, state) {
     const authorization = request.headers.authorization;
-    const tokenFromHeader = typeof authorization === "string" && authorization.startsWith("Bearer ")
-        ? authorization.slice("Bearer ".length).trim()
+    const tokenFromHeader = typeof authorization === "string"
+        ? /^Bearer\s+(.+)$/iu.exec(authorization.trim())?.[1]?.trim()
         : undefined;
     const token = tokenFromHeader ?? readTrimmedString(body.token);
     if (!token) {
@@ -76,6 +92,9 @@ function readBoolean(value) {
     }
     return undefined;
 }
+function readSlackText(value) {
+    return typeof value === "string" ? value : undefined;
+}
 function readStructuredValue(value) {
     if (typeof value !== "string") {
         return value;
@@ -91,6 +110,34 @@ function readStructuredValue(value) {
         return value;
     }
 }
+function readStructuredArray(value, error) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = readStructuredValue(value);
+    return Array.isArray(parsed) ? parsed : slackError(error);
+}
+function readSlackMetadata(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    let parsed = value;
+    if (typeof value === "string") {
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch {
+            return slackError("invalid_metadata_format");
+        }
+    }
+    if (!isJsonObject(parsed)) {
+        return slackError("invalid_metadata_format");
+    }
+    if (!readTrimmedString(parsed.event_type) || !isJsonObject(parsed.event_payload)) {
+        return slackError("invalid_metadata_schema");
+    }
+    return parsed;
+}
 function hasStructuredMessageContent(value) {
     if (Array.isArray(value)) {
         return value.length > 0;
@@ -101,16 +148,27 @@ function messagesForChannel(state, channel) {
     return state.messagesByChannel.get(channel) ?? [];
 }
 function hasThreadParent(state, params) {
-    return messagesForChannel(state, params.channel).some((message) => message.ts === params.threadTs || message.thread_ts === params.threadTs);
+    return messagesForChannel(state, params.channel).some((message) => message.ts === params.threadTs && message.thread_ts === undefined);
+}
+function resolveThreadTs(state, params) {
+    const message = messagesForChannel(state, params.channel).find((candidate) => candidate.ts === params.ts);
+    return message?.thread_ts ?? message?.ts;
 }
 function nextSlackTs(state) {
     const index = state.nextTsIndex++;
     return `${1_700_000_000 + Math.floor(index / 1_000_000)}.${String(index % 1_000_000).padStart(6, "0")}`;
 }
+function randomDecimalDigits(length) {
+    return Array.from({ length }, () => randomInt(10)).join("");
+}
 function nextDmChannelId(state) {
     const index = state.nextDmIndex++;
     return `D${String(index).padStart(9, "0")}`;
 }
+function nextMpimChannelId(state) {
+    const index = state.nextMpimIndex++;
+    return `G${String(index).padStart(9, "0")}`;
+}
 function dmChannelForUser(state, userId) {
     const existing = state.userDmChannels.get(userId);
     if (existing) {
@@ -120,14 +178,78 @@ function dmChannelForUser(state, userId) {
     state.userDmChannels.set(userId, channelId);
     return channelId;
 }
+function mpimChannelForUsers(state, users) {
+    const key = [...users].sort().join(",");
+    const existing = state.userMpimChannels.get(key);
+    if (existing) {
+        return existing;
+    }
+    const channel = { id: nextMpimChannelId(state), users: [...users] };
+    state.userMpimChannels.set(key, channel);
+    return channel;
+}
+function requireSlackUsers(value, botUserId) {
+    const rawUsers = readTrimmedString(value);
+    if (!rawUsers) {
+        return slackError("users_list_not_supplied");
+    }
+    const users = rawUsers.split(",").map((user) => user.trim());
+    if (users.length > 8) {
+        return slackError("too_many_users");
+    }
+    if (users.some((user) => !SLACK_USER_ID_RULE.pattern.test(user))) {
+        return slackError("user_not_found");
+    }
+    if (new Set(users).size !== users.length) {
+        return slackError("invalid_user_combination");
+    }
+    if (users.includes(botUserId)) {
+        return slackError("invalid_user_combination");
+    }
+    return users;
+}
+function requireSlackLimit(value) {
+    const limit = value === undefined ? 100 : readInteger(value);
+    if (limit === undefined || limit < 1 || limit > 1_000) {
+        return slackError("invalid_limit");
+    }
+    return limit;
+}
+function decodeSlackCursor(value, kind) {
+    if (value === undefined || value === "") {
+        return undefined;
+    }
+    if (typeof value !== "string" || !/^[A-Za-z0-9_-]+$/u.test(value)) {
+        return slackError("invalid_cursor");
+    }
+    const cursor = value;
+    try {
+        const decoded = Buffer.from(cursor, "base64url").toString("utf8");
+        const prefix = `${kind}:`;
+        if (!decoded.startsWith(prefix)) {
+            return slackError("invalid_cursor");
+        }
+        const boundary = decoded.slice(prefix.length);
+        return SLACK_TS_RULE.pattern.test(boundary) && encodeSlackCursor(kind, boundary) === cursor
+            ? boundary
+            : slackError("invalid_cursor");
+    }
+    catch {
+        return slackError("invalid_cursor");
+    }
+}
+function encodeSlackCursor(kind, boundary) {
+    return Buffer.from(`${kind}:${boundary}`, "utf8").toString("base64url");
+}
 function appendMessage(state, message) {
     const messages = state.messagesByChannel.get(message.channel) ?? [];
     messages.push(message);
     state.messagesByChannel.set(message.channel, messages);
     return message;
 }
-async function appendEvent(state, event) {
-    await recordServerEvent({ event, onEvent: state.onEvent, recorderPath: state.recorderPath });
+async function appendEvent(state, event, committed = false) {
+    const params = { event, onEvent: state.onEvent, recorderPath: state.recorderPath };
+    await (committed ? recordCommittedServerEvent(params) : recordServerEvent(params));
 }
 function redactSlackAuthFields(value) {
     return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
@@ -171,11 +293,175 @@ function asSlackEventCallback(message) {
         type: "event_callback",
     };
 }
-async function handleSlackApi(params) {
-    const authError = requireSlackToken(params.request, params.body, params.state);
-    if (authError) {
-        return authError;
+function slackRequestSignature(signingSecret, timestamp, body) {
+    const digest = createHmac("sha256", signingSecret)
+        .update(`v0:${timestamp}:${body}`)
+        .digest("hex");
+    return `v0=${digest}`;
+}
+function authenticateSlackEventsRequest(request, state, rawBody) {
+    const timestampHeader = request.headers["x-slack-request-timestamp"];
+    const signatureHeader = request.headers["x-slack-signature"];
+    const timestamp = Array.isArray(timestampHeader) ? timestampHeader[0] : timestampHeader;
+    const signature = Array.isArray(signatureHeader) ? signatureHeader[0] : signatureHeader;
+    const timestampSeconds = timestamp ? Number(timestamp) : Number.NaN;
+    if (!timestamp ||
+        !signature ||
+        !Number.isSafeInteger(timestampSeconds) ||
+        Math.abs(Date.now() / 1000 - timestampSeconds) > SLACK_SIGNATURE_TOLERANCE_SECONDS) {
+        return new Response("unauthorized", { status: 401 });
+    }
+    const expected = Buffer.from(slackRequestSignature(state.signingSecret, timestamp, rawBody));
+    const actual = Buffer.from(signature);
+    if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
+        return new Response("unauthorized", { status: 401 });
+    }
+    return undefined;
+}
+function errorChain(error) {
+    const chain = [];
+    let current = error;
+    while (current && typeof current === "object" && chain.length < 4) {
+        const entry = current;
+        chain.push(entry);
+        current = entry.cause;
+    }
+    return chain;
+}
+function classifySlackRetryReason(error) {
+    const chain = errorChain(error);
+    const names = chain.map((entry) => String(entry.name ?? ""));
+    const codes = chain.map((entry) => String(entry.code ?? "").toUpperCase());
+    const messages = chain.map((entry) => String(entry.message ?? "").toLowerCase());
+    if (codes.includes("UND_ERR_REDIRECT") ||
+        messages.some((message) => message.includes("redirect count exceeded"))) {
+        return "too_many_redirects";
+    }
+    if (names.some((name) => name === "AbortError" || name === "TimeoutError") ||
+        codes.some((code) => ["ETIMEDOUT", "UND_ERR_BODY_TIMEOUT", "UND_ERR_HEADERS_TIMEOUT"].includes(code))) {
+        return "http_timeout";
+    }
+    if (codes.some((code) => code.includes("CERT") ||
+        code.includes("SSL") ||
+        code.includes("TLS") ||
+        code === "UNABLE_TO_VERIFY_LEAF_SIGNATURE")) {
+        return "ssl_error";
     }
+    if (codes.some((code) => [
+        "EAI_AGAIN",
+        "ECONNREFUSED",
+        "ECONNRESET",
+        "EHOSTUNREACH",
+        "ENETUNREACH",
+        "ENOTFOUND",
+        "UND_ERR_CONNECT_TIMEOUT",
+        "UND_ERR_SOCKET",
+    ].includes(code))) {
+        return "connection_failed";
+    }
+    return "unknown_error";
+}
+async function waitForSlackRetry(delayMs, signal) {
+    if (signal.aborted) {
+        return false;
+    }
+    return await new Promise((resolve) => {
+        let settled = false;
+        const finish = (completed) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            resolve(completed);
+        };
+        const onAbort = () => finish(false);
+        const timer = setTimeout(() => finish(true), delayMs);
+        timer.unref();
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted) {
+            onAbort();
+        }
+    });
+}
+async function deliverSlackEvent(state, event, lifecycleSignal) {
+    if (!state.eventsRequestUrl) {
+        return undefined;
+    }
+    const body = JSON.stringify(event);
+    let retryReason;
+    for (let attempt = 0; attempt <= SLACK_EVENT_MAX_RETRIES; attempt += 1) {
+        if (lifecycleSignal.aborted) {
+            return;
+        }
+        try {
+            const timestamp = Math.floor(Date.now() / 1000).toString();
+            const headers = {
+                "content-type": "application/json",
+                ...(attempt > 0
+                    ? {
+                        "x-slack-retry-num": String(attempt),
+                        "x-slack-retry-reason": retryReason ?? "unknown_error",
+                    }
+                    : {}),
+                "x-slack-request-timestamp": timestamp,
+                "x-slack-signature": slackRequestSignature(state.signingSecret, timestamp, body),
+            };
+            const signal = AbortSignal.any([lifecycleSignal, AbortSignal.timeout(3_000)]);
+            let requestUrl = state.eventsRequestUrl;
+            let response;
+            for (let redirectCount = 0;; redirectCount += 1) {
+                response = await fetch(requestUrl, {
+                    body,
+                    headers,
+                    method: "POST",
+                    redirect: "manual",
+                    signal,
+                });
+                const location = response.headers.get("location");
+                if (![301, 302].includes(response.status) || !location) {
+                    break;
+                }
+                await response.body?.cancel();
+                if (redirectCount >= SLACK_EVENT_MAX_REDIRECTS) {
+                    response = undefined;
+                    retryReason = "too_many_redirects";
+                    break;
+                }
+                requestUrl = new URL(location, requestUrl).toString();
+            }
+            if (response) {
+                const noRetry = response.headers.get("x-slack-no-retry") === "1";
+                await response.body?.cancel();
+                if (response.ok || noRetry) {
+                    return;
+                }
+                retryReason = "http_error";
+            }
+        }
+        catch (error) {
+            if (lifecycleSignal.aborted) {
+                return;
+            }
+            retryReason = classifySlackRetryReason(error);
+        }
+        const retryDelay = SLACK_EVENT_RETRY_DELAYS_MS[attempt];
+        if (retryDelay !== undefined && !(await waitForSlackRetry(retryDelay, lifecycleSignal))) {
+            return;
+        }
+    }
+}
+function scheduleSlackEventDelivery(state, event) {
+    if (!state.eventsRequestUrl || state.closing) {
+        return;
+    }
+    const delivery = deliverSlackEvent(state, event, state.deliveryAbortController.signal).finally(() => {
+        state.activeEventDeliveries.delete(delivery);
+    });
+    state.activeEventDeliveries.add(delivery);
+}
+async function handleSlackApi(params) {
     switch (params.method) {
         case "auth.test":
             return slackOk({
@@ -196,17 +482,30 @@ async function handleSlackApi(params) {
                 user_id: params.state.botUserId,
             });
         case "chat.postMessage": {
-            if (readBoolean(params.body.simulate_rate_limit) === true) {
-                return slackRateLimited(readInteger(params.body.retry_after) ?? 1);
+            const rateLimit = params.state.chatPostMessageRateLimit;
+            if (rateLimit && rateLimit.remaining <= 0) {
+                return slackRateLimited(rateLimit.retryAfterSeconds);
+            }
+            if (rateLimit) {
+                rateLimit.remaining -= 1;
             }
             const channel = requireSlackSendTargetId(params.body.channel);
             if (channel instanceof Response) {
                 return channel;
             }
-            const text = readTrimmedString(params.body.text) ?? "";
-            const attachments = readStructuredValue(params.body.attachments);
-            const blocks = readStructuredValue(params.body.blocks);
-            const metadata = readStructuredValue(params.body.metadata);
+            const text = readSlackText(params.body.text) ?? "";
+            const attachments = readStructuredArray(params.body.attachments, "invalid_attachments");
+            if (attachments instanceof Response) {
+                return attachments;
+            }
+            const blocks = readStructuredArray(params.body.blocks, "invalid_blocks");
+            if (blocks instanceof Response) {
+                return blocks;
+            }
+            const metadata = readSlackMetadata(params.body.metadata);
+            if (metadata instanceof Response) {
+                return metadata;
+            }
             if (!text &&
                 !hasStructuredMessageContent(blocks) &&
                 !hasStructuredMessageContent(attachments)) {
@@ -237,12 +536,23 @@ async function handleSlackApi(params) {
             return slackOk({ channel, message, ts: message.ts });
         }
         case "conversations.open": {
-            const users = readTrimmedString(params.body.users);
-            const firstUser = users?.split(",")[0]?.trim();
-            const user = requireSlackUserId(firstUser);
-            if (user instanceof Response) {
-                return user;
+            const users = requireSlackUsers(params.body.users, params.state.botUserId);
+            if (users instanceof Response) {
+                return users;
+            }
+            if (users.length > 1) {
+                const channel = mpimChannelForUsers(params.state, users);
+                return slackOk({
+                    channel: {
+                        id: channel.id,
+                        is_group: false,
+                        is_mpim: true,
+                        is_private: true,
+                        members: [params.state.botUserId, ...channel.users],
+                    },
+                });
             }
+            const user = users[0];
             return slackOk({
                 channel: {
                     id: dmChannelForUser(params.state, user),
@@ -256,12 +566,20 @@ async function handleSlackApi(params) {
             if (channel instanceof Response) {
                 return channel;
             }
+            const mpim = [...params.state.userMpimChannels.values()].find((candidate) => candidate.id === channel);
             return slackOk({
                 channel: {
                     id: channel,
                     is_channel: channel.startsWith("C"),
-                    is_group: channel.startsWith("G"),
+                    is_group: mpim ? false : channel.startsWith("G"),
                     is_im: channel.startsWith("D"),
+                    ...(mpim
+                        ? {
+                            is_mpim: true,
+                            is_private: true,
+                            members: [params.state.botUserId, ...mpim.users],
+                        }
+                        : {}),
                     name: "crabline",
                 },
             });
@@ -279,8 +597,18 @@ async function handleSlackApi(params) {
             if (latest instanceof Response) {
                 return latest;
             }
-            const limit = readInteger(params.body.limit) ?? 100;
+            const limit = requireSlackLimit(params.body.limit);
+            if (limit instanceof Response) {
+                return limit;
+            }
+            const boundary = decodeSlackCursor(params.body.cursor, "history");
+            if (boundary instanceof Response) {
+                return boundary;
+            }
             const messages = messagesForChannel(params.state, channel).filter((message) => {
+                if (message.thread_ts !== undefined && message.reply_broadcast !== true) {
+                    return false;
+                }
                 if (oldest && message.ts <= oldest) {
                     return false;
                 }
@@ -289,9 +617,18 @@ async function handleSlackApi(params) {
                 }
                 return true;
             });
+            const ordered = [...messages]
+                .reverse()
+                .filter((message) => boundary === undefined || message.ts < boundary);
+            const page = ordered.slice(0, limit);
+            const hasMore = page.length < ordered.length;
+            const nextBoundary = page.at(-1)?.ts;
             return slackOk({
-                has_more: messages.length > limit,
-                messages: [...messages].reverse().slice(0, limit),
+                has_more: hasMore,
+                messages: page,
+                response_metadata: {
+                    next_cursor: hasMore && nextBoundary ? encodeSlackCursor("history", nextBoundary) : "",
+                },
             });
         }
         case "conversations.replies": {
@@ -306,12 +643,30 @@ async function handleSlackApi(params) {
             if (!ts) {
                 return slackError("message_not_found");
             }
-            const limit = readInteger(params.body.limit) ?? 100;
-            const messages = messagesForChannel(params.state, channel).filter((message) => message.ts === ts || message.thread_ts === ts);
-            if (messages.length === 0) {
+            const threadTs = resolveThreadTs(params.state, { channel, ts });
+            if (!threadTs) {
                 return slackError("thread_not_found");
             }
-            return slackOk({ has_more: messages.length > limit, messages: messages.slice(0, limit) });
+            const limit = requireSlackLimit(params.body.limit);
+            if (limit instanceof Response) {
+                return limit;
+            }
+            const boundary = decodeSlackCursor(params.body.cursor, "replies");
+            if (boundary instanceof Response) {
+                return boundary;
+            }
+            const messages = messagesForChannel(params.state, channel).filter((message) => (message.ts === threadTs || message.thread_ts === threadTs) &&
+                (boundary === undefined || message.ts > boundary));
+            const page = messages.slice(0, limit);
+            const hasMore = page.length < messages.length;
+            const nextBoundary = page.at(-1)?.ts;
+            return slackOk({
+                has_more: hasMore,
+                messages: page,
+                response_metadata: {
+                    next_cursor: hasMore && nextBoundary ? encodeSlackCursor("replies", nextBoundary) : "",
+                },
+            });
         }
         default:
             return slackError("unknown_method", 404);
@@ -322,9 +677,17 @@ async function handleAdminInbound(params) {
     if (channel instanceof Response) {
         return channel;
     }
-    const text = readTrimmedString(params.body.text);
-    if (!text) {
-        return slackError("text is required", 400);
+    if (params.body.text !== undefined && typeof params.body.text !== "string") {
+        return slackError("invalid_text", 400);
+    }
+    const text = readSlackText(params.body.text) ?? "";
+    const attachments = readStructuredArray(params.body.attachments, "invalid_attachments");
+    if (attachments instanceof Response) {
+        return attachments;
+    }
+    const blocks = readStructuredArray(params.body.blocks, "invalid_blocks");
+    if (blocks instanceof Response) {
+        return blocks;
     }
     const user = requireSlackUserId(params.body.user ?? "UCRABUSER");
     if (user instanceof Response) {
@@ -334,18 +697,25 @@ async function handleAdminInbound(params) {
     if (threadTs instanceof Response) {
         return threadTs;
     }
+    if (threadTs && !hasThreadParent(params.state, { channel, threadTs })) {
+        return slackError("thread_not_found");
+    }
     const ts = requireSlackThreadTs(params.body.ts);
     if (ts instanceof Response) {
         return ts;
     }
     const message = appendMessage(params.state, createSlackMessage(params.state, {
+        attachments,
+        blocks,
         channel,
         text,
         threadTs,
         ts,
         user,
     }));
-    return slackOk({ event: asSlackEventCallback(message), message });
+    const event = asSlackEventCallback(message);
+    scheduleSlackEventDelivery(params.state, event);
+    return slackOk({ event, message });
 }
 async function handleRequest(params) {
     const url = new URL(params.request.url ?? "/", "http://127.0.0.1");
@@ -354,9 +724,13 @@ async function handleRequest(params) {
             return new Response("not found", { status: 404 });
         }
         if (!hasAdminToken(params.request, params.state.adminToken)) {
+            params.request.resume();
             return adminAuthError();
         }
-        const body = await parseRequestBody(params.request);
+        const body = await parseUnknownRequestBody(params.request);
+        if (!isJsonObject(body)) {
+            return slackError("invalid_json", 400);
+        }
         await appendEvent(params.state, {
             at: new Date().toISOString(),
             body,
@@ -368,49 +742,138 @@ async function handleRequest(params) {
         return await handleAdminInbound({ body, state: params.state });
     }
     const query = queryRecord(url);
-    const body = params.request.method === "GET" ? query : await parseRequestBody(params.request);
-    await appendEvent(params.state, {
-        at: new Date().toISOString(),
-        body: redactSlackAuthFields(body),
-        method: params.request.method ?? "GET",
-        path: url.pathname,
-        query: redactSlackAuthQuery(query),
-        type: "api",
-    });
     if (url.pathname === "/slack/events") {
+        if (params.request.method !== "POST") {
+            params.request.resume();
+            return new Response("method not allowed", {
+                headers: { allow: "POST" },
+                status: 405,
+            });
+        }
+        if (!params.request.headers["x-slack-request-timestamp"] ||
+            !params.request.headers["x-slack-signature"]) {
+            params.request.resume();
+            return new Response("unauthorized", { status: 401 });
+        }
+        const rawBody = (await readBody(params.request)).toString("utf8");
+        const authError = authenticateSlackEventsRequest(params.request, params.state, rawBody);
+        if (authError) {
+            return authError;
+        }
+        let body;
+        try {
+            body = rawBody ? JSON.parse(rawBody) : {};
+        }
+        catch (error) {
+            throw new InvalidJsonBodyError(error);
+        }
+        if (!isJsonObject(body)) {
+            return slackError("invalid_json", 400);
+        }
         if (body.type === "url_verification") {
             return jsonResponse({ challenge: readTrimmedString(body.challenge) ?? "" });
         }
-        return slackOk();
+        if (!readTrimmedString(body.type)) {
+            return slackError("invalid_payload", 400);
+        }
+        return new Response(null, { status: 200 });
     }
     const methodMatch = /^\/api\/([a-z]+(?:\.[a-zA-Z]+)*)$/u.exec(url.pathname);
     if (!methodMatch?.[1]) {
         return new Response("not found", { status: 404 });
     }
-    return await handleSlackApi({
+    const requestMethod = params.request.method ?? "GET";
+    if (requestMethod !== "GET" && requestMethod !== "POST") {
+        params.request.resume();
+        return new Response("method not allowed", {
+            headers: { allow: "GET, POST" },
+            status: 405,
+        });
+    }
+    if (params.request.headers.authorization) {
+        const headerAuthError = requireSlackToken(params.request, {}, params.state);
+        if (headerAuthError) {
+            params.request.resume();
+            return headerAuthError;
+        }
+    }
+    const body = requestMethod === "GET" ? query : await parseUnknownRequestBody(params.request);
+    if (!isJsonObject(body)) {
+        return slackError("json_not_object", 400);
+    }
+    const authError = requireSlackToken(params.request, body, params.state);
+    if (authError) {
+        return authError;
+    }
+    const event = {
+        at: new Date().toISOString(),
+        body: redactSlackAuthFields(body),
+        method: params.request.method ?? "GET",
+        path: url.pathname,
+        query: redactSlackAuthQuery(query),
+        type: "api",
+    };
+    const response = await handleSlackApi({
         body,
         method: methodMatch[1],
-        request: params.request,
         state: params.state,
     });
+    const mutation = ["chat.postMessage", "conversations.open"].includes(methodMatch[1]);
+    const payload = mutation
+        ? (await response
+            .clone()
+            .json()
+            .catch(() => undefined))
+        : undefined;
+    const committed = isJsonObject(payload) && payload.ok === true;
+    if (methodMatch[1] === "chat.postMessage") {
+        event.accepted = committed;
+    }
+    await appendEvent(params.state, event, committed);
+    return response;
 }
 export async function startSlackServer(params = {}) {
+    const host = params.host ?? "127.0.0.1";
+    const externallyBound = !isLoopbackHost(host);
     const state = {
+        activeEventDeliveries: new Set(),
         adminToken: params.adminToken ?? randomBytes(24).toString("base64url"),
         botId: params.botId ?? "BCRABLINE",
         botToken: params.botToken ?? "xoxb-crabline-slack-token",
         botUserId: params.botUserId ?? "UCRABBOT",
+        chatPostMessageRateLimit: resolveChatPostMessageRateLimit(params.chatPostMessageRateLimit),
+        closing: false,
+        deliveryAbortController: new AbortController(),
+        eventsRequestUrl: params.eventsRequestUrl,
         nextDmIndex: 1,
+        nextMpimIndex: 1,
         nextTsIndex: 100,
         onEvent: params.onEvent,
         recorderPath: params.recorderPath ?? path.resolve(".crabline", "servers", "slack.jsonl"),
         signingSecret: params.signingSecret ?? "crabline-slack-signing-secret",
         userDmChannels: new Map(),
+        userMpimChannels: new Map(),
         messagesByChannel: new Map(),
     };
-    const host = params.host ?? "127.0.0.1";
+    if (externallyBound && !params.botToken) {
+        const generatedBotValue = `xoxb-${randomDecimalDigits(12)}-${randomDecimalDigits(12)}-${randomBytes(18).toString("base64url")}`;
+        state.botToken = generatedBotValue;
+    }
+    if (externallyBound && !params.signingSecret) {
+        const generatedSigningValue = randomBytes(16).toString("hex");
+        state.signingSecret = generatedSigningValue;
+    }
     const httpServer = await startHttpJsonServer({
         handle: (request) => handleRequest({ request, state }),
+        handleError: (error) => {
+            if (error instanceof InvalidJsonBodyError) {
+                return slackError("invalid_json", 400);
+            }
+            if (error instanceof RequestBodyTooLargeError) {
+                return slackError("request_too_large", 413);
+            }
+            return undefined;
+        },
         host,
         port: params.port ?? 0,
         serverName: "Slack",
@@ -419,6 +882,9 @@ export async function startSlackServer(params = {}) {
     const apiRoot = `${baseUrl}/api/`;
     return {
         async close() {
+            state.closing = true;
+            state.deliveryAbortController.abort();
+            await Promise.allSettled(state.activeEventDeliveries);
             await httpServer.close();
         },
         manifest: {