@openclaw/crabline 0.1.10 → 0.1.12

package/dist/src/servers/slack.js

@@ -3,10 +3,27 @@ import path from "node:path";
 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 { recordCommittedServerEvent, recordServerEvent, } from "./recorder.js";
+import { postWebhookRequestWithResponse, validateWebhookTarget, } from "./webhook-target.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];
+class SlackEventHttpError extends Error {
+    status;
+    constructor(status) {
+        super(`Slack Events API delivery failed with HTTP ${status}.`);
+        this.status = status;
+        this.name = "SlackEventHttpError";
+    }
+}
+class SlackEventTargetError extends Error {
+    retryReason;
+    constructor(retryReason, targetError) {
+        super(`Slack Events API target rejected: ${targetError}`);
+        this.retryReason = retryReason;
+        this.name = "SlackEventTargetError";
+    }
+}
 function slackOk(result = {}) {
     return jsonResponse({ ok: true, ...result });
 }
@@ -162,12 +179,24 @@ function randomDecimalDigits(length) {
     return Array.from({ length }, () => randomInt(10)).join("");
 }
 function nextDmChannelId(state) {
-    const index = state.nextDmIndex++;
-    return `D${String(index).padStart(9, "0")}`;
+    for (;;) {
+        const index = state.nextDmIndex++;
+        const channelId = `D${String(index).padStart(9, "0")}`;
+        if (!state.messagesByChannel.has(channelId) &&
+            ![...state.userDmChannels.values()].includes(channelId)) {
+            return channelId;
+        }
+    }
 }
 function nextMpimChannelId(state) {
-    const index = state.nextMpimIndex++;
-    return `G${String(index).padStart(9, "0")}`;
+    for (;;) {
+        const index = state.nextMpimIndex++;
+        const channelId = `G${String(index).padStart(9, "0")}`;
+        if (!state.messagesByChannel.has(channelId) &&
+            ![...state.userMpimChannels.values()].some((channel) => channel.id === channelId)) {
+            return channelId;
+        }
+    }
 }
 function dmChannelForUser(state, userId) {
     const existing = state.userDmChannels.get(userId);
@@ -178,6 +207,16 @@ function dmChannelForUser(state, userId) {
     state.userDmChannels.set(userId, channelId);
     return channelId;
 }
+function rememberDmChannel(state, userId, channelId) {
+    if (!channelId.startsWith("D")) {
+        return;
+    }
+    const mappedUser = [...state.userDmChannels].find(([, value]) => value === channelId)?.[0];
+    if (mappedUser && mappedUser !== userId) {
+        return;
+    }
+    state.userDmChannels.set(userId, channelId);
+}
 function mpimChannelForUsers(state, users) {
     const key = [...users].sort().join(",");
     const existing = state.userMpimChannels.get(key);
@@ -230,7 +269,10 @@ function decodeSlackCursor(value, kind) {
             return slackError("invalid_cursor");
         }
         const boundary = decoded.slice(prefix.length);
-        return SLACK_TS_RULE.pattern.test(boundary) && encodeSlackCursor(kind, boundary) === cursor
+        const validBoundary = kind === "list"
+            ? SLACK_CHANNEL_ID_RULE.pattern.test(boundary)
+            : SLACK_TS_RULE.pattern.test(boundary);
+        return validBoundary && encodeSlackCursor(kind, boundary) === cursor
             ? boundary
             : slackError("invalid_cursor");
     }
@@ -247,6 +289,72 @@ function appendMessage(state, message) {
     state.messagesByChannel.set(message.channel, messages);
     return message;
 }
+function slackConversation(state, channelId) {
+    const dmUser = [...state.userDmChannels].find(([, value]) => value === channelId)?.[0];
+    const mpim = [...state.userMpimChannels.values()].find((candidate) => candidate.id === channelId);
+    const hasMessages = state.messagesByChannel.has(channelId);
+    if (!dmUser && !mpim && !hasMessages) {
+        return undefined;
+    }
+    if (dmUser) {
+        return {
+            id: channelId,
+            is_channel: false,
+            is_group: false,
+            is_im: true,
+            is_mpim: false,
+            user: dmUser,
+        };
+    }
+    if (mpim) {
+        return {
+            id: channelId,
+            is_channel: false,
+            is_group: false,
+            is_im: false,
+            is_mpim: true,
+            is_private: true,
+            members: [state.botUserId, ...mpim.users],
+            name: "crabline",
+        };
+    }
+    return {
+        id: channelId,
+        is_channel: channelId.startsWith("C"),
+        is_group: channelId.startsWith("G"),
+        is_im: channelId.startsWith("D"),
+        is_mpim: false,
+        name: "crabline",
+    };
+}
+function slackConversations(state) {
+    const ids = new Set([
+        ...state.messagesByChannel.keys(),
+        ...state.userDmChannels.values(),
+        ...[...state.userMpimChannels.values()].map((channel) => channel.id),
+    ]);
+    return [...ids]
+        .sort()
+        .map((channelId) => slackConversation(state, channelId))
+        .filter((channel) => channel !== undefined);
+}
+function requireSlackConversationTypes(value) {
+    const types = new Set((readTrimmedString(value) ?? "public_channel")
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean));
+    const supported = new Set(["im", "mpim", "private_channel", "public_channel"]);
+    return [...types].every((type) => supported.has(type)) ? types : slackError("invalid_types");
+}
+function slackConversationType(conversation) {
+    if (conversation.is_im === true) {
+        return "im";
+    }
+    if (conversation.is_mpim === true) {
+        return "mpim";
+    }
+    return conversation.is_group === true ? "private_channel" : "public_channel";
+}
 async function appendEvent(state, event, committed = false) {
     const params = { event, onEvent: state.onEvent, recorderPath: state.recorderPath };
     await (committed ? recordCommittedServerEvent(params) : recordServerEvent(params));
@@ -281,10 +389,18 @@ function createSlackMessage(state, params) {
         user: params.user ?? (params.bot ? state.botUserId : "UCRABUSER"),
     };
 }
-function asSlackEventCallback(message) {
+function asSlackEventCallback(state, message) {
     return {
         api_app_id: "ACRABLINE",
-        authorizations: [],
+        authorizations: [
+            {
+                enterprise_id: null,
+                is_bot: true,
+                is_enterprise_install: false,
+                team_id: "TCRABLINE",
+                user_id: state.botUserId,
+            },
+        ],
         event: message,
         event_id: `Ev${message.ts.replace(".", "")}`,
         event_time: Number(message.ts.slice(0, 10)),
@@ -328,7 +444,14 @@ function errorChain(error) {
     }
     return chain;
 }
-function classifySlackRetryReason(error) {
+/** @internal */
+export function classifySlackRetryReason(error) {
+    if (error instanceof SlackEventHttpError) {
+        return "http_error";
+    }
+    if (error instanceof SlackEventTargetError) {
+        return error.retryReason;
+    }
     const chain = errorChain(error);
     const names = chain.map((entry) => String(entry.name ?? ""));
     const codes = chain.map((entry) => String(entry.code ?? "").toUpperCase());
@@ -361,6 +484,62 @@ function classifySlackRetryReason(error) {
     }
     return "unknown_error";
 }
+function slackResponseHeader(response, name) {
+    const value = response.headers[name];
+    return Array.isArray(value) ? value[0] : value;
+}
+function slackTargetRetryReason(error) {
+    return error === "https-required" ? "ssl_error" : "connection_failed";
+}
+/** @internal */
+export async function postSlackEventToAddresses(params) {
+    const addresses = params.addresses && params.addresses.length > 0 ? [...params.addresses] : [undefined];
+    const request = params.request ?? postWebhookRequestWithResponse;
+    let lastError;
+    for (const [index, address] of addresses.entries()) {
+        const remainingMs = params.timeoutAt - Date.now();
+        if (remainingMs <= 0) {
+            throw new DOMException("Slack Events API delivery timed out", "TimeoutError");
+        }
+        const attemptsRemaining = addresses.length - index;
+        try {
+            return await request({
+                address,
+                body: params.body,
+                headerEntries: params.headerEntries,
+                signal: params.signal,
+                timeoutMs: Math.max(1, Math.floor(remainingMs / attemptsRemaining)),
+                url: params.url,
+            });
+        }
+        catch (error) {
+            lastError = error;
+            if (params.signal.aborted) {
+                throw error;
+            }
+        }
+    }
+    throw lastError;
+}
+async function postSlackEventRequest(params) {
+    const target = await validateWebhookTarget({
+        allowLoopbackHttp: params.state.allowLoopbackHttpEvents,
+        restrictPrivateAddresses: params.state.restrictEventTargets,
+        signal: params.signal,
+        url: params.url,
+    });
+    if ("error" in target) {
+        throw new SlackEventTargetError(slackTargetRetryReason(target.error), target.error);
+    }
+    return await postSlackEventToAddresses({
+        addresses: target.addresses,
+        body: params.body,
+        headerEntries: params.headerEntries,
+        signal: params.signal,
+        timeoutAt: params.timeoutAt,
+        url: params.url,
+    });
+}
 async function waitForSlackRetry(delayMs, signal) {
     if (signal.aborted) {
         return false;
@@ -397,47 +576,50 @@ async function deliverSlackEvent(state, event, lifecycleSignal) {
         }
         try {
             const timestamp = Math.floor(Date.now() / 1000).toString();
-            const headers = {
-                "content-type": "application/json",
+            const headerEntries = [
+                ["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),
-            };
+                    ? [
+                        ["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;
+            const timeoutAt = Date.now() + 3_000;
+            let requestUrl = new URL(state.eventsRequestUrl);
             let response;
             for (let redirectCount = 0;; redirectCount += 1) {
-                response = await fetch(requestUrl, {
+                response = await postSlackEventRequest({
                     body,
-                    headers,
-                    method: "POST",
-                    redirect: "manual",
+                    headerEntries,
                     signal,
+                    state,
+                    timeoutAt,
+                    url: requestUrl,
                 });
-                const location = response.headers.get("location");
+                const noRetry = slackResponseHeader(response, "x-slack-no-retry") === "1";
+                if (noRetry) {
+                    return;
+                }
+                const location = slackResponseHeader(response, "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();
+                requestUrl = new URL(location, requestUrl);
             }
             if (response) {
-                const noRetry = response.headers.get("x-slack-no-retry") === "1";
-                await response.body?.cancel();
-                if (response.ok || noRetry) {
+                if (response.status >= 200 && response.status < 300) {
                     return;
                 }
-                retryReason = "http_error";
+                throw new SlackEventHttpError(response.status);
             }
         }
         catch (error) {
@@ -489,10 +671,13 @@ async function handleSlackApi(params) {
             if (rateLimit) {
                 rateLimit.remaining -= 1;
             }
-            const channel = requireSlackSendTargetId(params.body.channel);
-            if (channel instanceof Response) {
-                return channel;
+            const requestedChannel = requireSlackSendTargetId(params.body.channel);
+            if (requestedChannel instanceof Response) {
+                return requestedChannel;
             }
+            const channel = SLACK_USER_ID_RULE.pattern.test(requestedChannel)
+                ? dmChannelForUser(params.state, requestedChannel)
+                : requestedChannel;
             const text = readSlackText(params.body.text) ?? "";
             const attachments = readStructuredArray(params.body.attachments, "invalid_attachments");
             if (attachments instanceof Response) {
@@ -566,21 +751,34 @@ async function handleSlackApi(params) {
             if (channel instanceof Response) {
                 return channel;
             }
-            const mpim = [...params.state.userMpimChannels.values()].find((candidate) => candidate.id === channel);
+            const conversation = slackConversation(params.state, channel);
+            return conversation ? slackOk({ channel: conversation }) : slackError("channel_not_found");
+        }
+        case "conversations.list": {
+            const types = requireSlackConversationTypes(params.body.types);
+            if (types instanceof Response) {
+                return types;
+            }
+            const limit = requireSlackLimit(params.body.limit);
+            if (limit instanceof Response) {
+                return limit;
+            }
+            const boundary = decodeSlackCursor(params.body.cursor, "list");
+            if (boundary instanceof Response) {
+                return boundary;
+            }
+            const remaining = slackConversations(params.state).filter((conversation) => {
+                const channelId = readTrimmedString(conversation.id);
+                return channelId && (boundary === undefined || channelId > boundary);
+            });
+            const virtualPage = remaining.slice(0, limit);
+            const channels = virtualPage.filter((conversation) => types.has(slackConversationType(conversation)));
+            const hasMore = virtualPage.length < remaining.length;
+            const nextBoundary = readTrimmedString(virtualPage.at(-1)?.id);
             return slackOk({
-                channel: {
-                    id: channel,
-                    is_channel: channel.startsWith("C"),
-                    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",
+                channels,
+                response_metadata: {
+                    next_cursor: hasMore && nextBoundary ? encodeSlackCursor("list", nextBoundary) : "",
                 },
             });
         }
@@ -589,6 +787,9 @@ async function handleSlackApi(params) {
             if (channel instanceof Response) {
                 return channel;
             }
+            if (!slackConversation(params.state, channel)) {
+                return slackError("channel_not_found");
+            }
             const oldest = requireSlackThreadTs(params.body.oldest);
             if (oldest instanceof Response) {
                 return oldest;
@@ -636,6 +837,9 @@ async function handleSlackApi(params) {
             if (channel instanceof Response) {
                 return channel;
             }
+            if (!slackConversation(params.state, channel)) {
+                return slackError("channel_not_found");
+            }
             const ts = requireSlackThreadTs(params.body.ts);
             if (ts instanceof Response) {
                 return ts;
@@ -693,6 +897,7 @@ async function handleAdminInbound(params) {
     if (user instanceof Response) {
         return user;
     }
+    rememberDmChannel(params.state, user, channel);
     const threadTs = requireSlackThreadTs(params.body.threadTs ?? params.body.thread_ts);
     if (threadTs instanceof Response) {
         return threadTs;
@@ -713,7 +918,7 @@ async function handleAdminInbound(params) {
         ts,
         user,
     }));
-    const event = asSlackEventCallback(message);
+    const event = asSlackEventCallback(params.state, message);
     scheduleSlackEventDelivery(params.state, event);
     return slackOk({ event, message });
 }
@@ -819,17 +1024,18 @@ async function handleRequest(params) {
         state: params.state,
     });
     const mutation = ["chat.postMessage", "conversations.open"].includes(methodMatch[1]);
-    const payload = mutation
+    const recordsAcceptance = mutation || methodMatch[1] === "auth.test";
+    const payload = recordsAcceptance
         ? (await response
             .clone()
             .json()
             .catch(() => undefined))
         : undefined;
     const committed = isJsonObject(payload) && payload.ok === true;
-    if (methodMatch[1] === "chat.postMessage") {
+    if (methodMatch[1] === "auth.test" || methodMatch[1] === "chat.postMessage") {
         event.accepted = committed;
     }
-    await appendEvent(params.state, event, committed);
+    await appendEvent(params.state, event, mutation && committed);
     return response;
 }
 export async function startSlackServer(params = {}) {
@@ -838,6 +1044,7 @@ export async function startSlackServer(params = {}) {
     const state = {
         activeEventDeliveries: new Set(),
         adminToken: params.adminToken ?? randomBytes(24).toString("base64url"),
+        allowLoopbackHttpEvents: isLoopbackHost(host),
         botId: params.botId ?? "BCRABLINE",
         botToken: params.botToken ?? "xoxb-crabline-slack-token",
         botUserId: params.botUserId ?? "UCRABBOT",
@@ -850,6 +1057,7 @@ export async function startSlackServer(params = {}) {
         nextTsIndex: 100,
         onEvent: params.onEvent,
         recorderPath: params.recorderPath ?? path.resolve(".crabline", "servers", "slack.jsonl"),
+        restrictEventTargets: true,
         signingSecret: params.signingSecret ?? "crabline-slack-signing-secret",
         userDmChannels: new Map(),
         userMpimChannels: new Map(),