@chat-adapter/slack 4.0.0

package/dist/index.d.ts

@@ -0,0 +1,215 @@
+import { CardElement, BaseFormatConverter, PostableMessage, Root, Adapter, ChatInstance, WebhookOptions, RawMessage, EmojiValue, FetchOptions, Message, ThreadInfo, FormattedContent } from 'chat';
+
+/**
+ * Slack Block Kit converter for cross-platform cards.
+ *
+ * Converts CardElement to Slack Block Kit blocks.
+ * @see https://api.slack.com/block-kit
+ */
+
+interface SlackBlock {
+    type: string;
+    block_id?: string;
+    [key: string]: unknown;
+}
+/**
+ * Convert a CardElement to Slack Block Kit blocks.
+ */
+declare function cardToBlockKit(card: CardElement): SlackBlock[];
+/**
+ * Generate fallback text from a card element.
+ * Used when blocks aren't supported or for notifications.
+ */
+declare function cardToFallbackText(card: CardElement): string;
+
+/**
+ * Slack-specific format conversion using AST-based parsing.
+ *
+ * Slack uses "mrkdwn" format which is similar but not identical to markdown:
+ * - Bold: *text* (not **text**)
+ * - Italic: _text_ (same)
+ * - Strikethrough: ~text~ (not ~~text~~)
+ * - Links: <url|text> (not [text](url))
+ * - User mentions: <@U123>
+ * - Channel mentions: <#C123|name>
+ */
+
+declare class SlackFormatConverter extends BaseFormatConverter {
+    /**
+     * Convert @mentions to Slack format in plain text.
+     * @name → <@name>
+     */
+    private convertMentionsToSlack;
+    /**
+     * Override renderPostable to convert @mentions in plain strings.
+     */
+    renderPostable(message: PostableMessage): string;
+    /**
+     * Render an AST to Slack mrkdwn format.
+     */
+    fromAst(ast: Root): string;
+    /**
+     * Parse Slack mrkdwn into an AST.
+     */
+    toAst(mrkdwn: string): Root;
+    private nodeToMrkdwn;
+}
+
+interface SlackAdapterConfig {
+    /** Bot token (xoxb-...) */
+    botToken: string;
+    /** Signing secret for webhook verification */
+    signingSecret: string;
+    /** Override bot username (optional) */
+    userName?: string;
+    /** Bot user ID (will be fetched if not provided) */
+    botUserId?: string;
+}
+/** Slack-specific thread ID data */
+interface SlackThreadId {
+    channel: string;
+    threadTs: string;
+}
+/** Slack event payload (raw message format) */
+interface SlackEvent {
+    type: string;
+    user?: string;
+    bot_id?: string;
+    channel?: string;
+    text?: string;
+    ts?: string;
+    thread_ts?: string;
+    subtype?: string;
+    username?: string;
+    edited?: {
+        ts: string;
+    };
+    /** Channel type: "channel", "group", "mpim", or "im" (DM) */
+    channel_type?: string;
+    files?: Array<{
+        id?: string;
+        mimetype?: string;
+        url_private?: string;
+        name?: string;
+        size?: number;
+        original_w?: number;
+        original_h?: number;
+    }>;
+}
+/** Slack reaction event payload */
+interface SlackReactionEvent {
+    type: "reaction_added" | "reaction_removed";
+    user: string;
+    reaction: string;
+    item_user?: string;
+    item: {
+        type: string;
+        channel: string;
+        ts: string;
+    };
+    event_ts: string;
+}
+declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
+    readonly name = "slack";
+    readonly userName: string;
+    private client;
+    private signingSecret;
+    private botToken;
+    private chat;
+    private logger;
+    private _botUserId;
+    private _botId;
+    private formatConverter;
+    private static USER_CACHE_TTL_MS;
+    /** Bot user ID (e.g., U_BOT_123) used for mention detection */
+    get botUserId(): string | undefined;
+    constructor(config: SlackAdapterConfig);
+    initialize(chat: ChatInstance): Promise<void>;
+    /**
+     * Look up user info from Slack API with caching via state adapter.
+     * Returns display name and real name, or falls back to user ID.
+     */
+    private lookupUser;
+    handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
+    /**
+     * Handle Slack interactive payloads (button clicks, etc.).
+     * These are sent as form-urlencoded with a `payload` JSON field.
+     */
+    private handleInteractivePayload;
+    /**
+     * Handle block_actions payload (button clicks in Block Kit).
+     */
+    private handleBlockActions;
+    private verifySignature;
+    /**
+     * Handle message events from Slack.
+     * Bot message filtering (isMe) is handled centrally by the Chat class.
+     */
+    private handleMessageEvent;
+    /**
+     * Handle reaction events from Slack (reaction_added, reaction_removed).
+     */
+    private handleReactionEvent;
+    private parseSlackMessage;
+    /**
+     * Create an Attachment object from a Slack file.
+     * Includes a fetchData method that uses the bot token for auth.
+     */
+    private createAttachment;
+    postMessage(threadId: string, message: PostableMessage): Promise<RawMessage<unknown>>;
+    /**
+     * Extract card element from a PostableMessage if present.
+     */
+    private extractCard;
+    /**
+     * Extract files from a PostableMessage if present.
+     */
+    private extractFiles;
+    /**
+     * Upload files to Slack and share them to a channel.
+     * Returns the file IDs of uploaded files.
+     */
+    private uploadFiles;
+    editMessage(threadId: string, messageId: string, message: PostableMessage): Promise<RawMessage<unknown>>;
+    deleteMessage(threadId: string, messageId: string): Promise<void>;
+    addReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
+    removeReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
+    startTyping(_threadId: string): Promise<void>;
+    /**
+     * Open a direct message conversation with a user.
+     * Returns a thread ID that can be used to post messages.
+     */
+    openDM(userId: string): Promise<string>;
+    fetchMessages(threadId: string, options?: FetchOptions): Promise<Message<unknown>[]>;
+    fetchThread(threadId: string): Promise<ThreadInfo>;
+    encodeThreadId(platformData: SlackThreadId): string;
+    /**
+     * Check if a thread is a direct message conversation.
+     * Slack DM channel IDs start with 'D'.
+     */
+    isDM(threadId: string): boolean;
+    decodeThreadId(threadId: string): SlackThreadId;
+    parseMessage(raw: SlackEvent): Message<unknown>;
+    /**
+     * Synchronous message parsing without user lookup.
+     * Used for parseMessage interface - falls back to user ID for username.
+     */
+    private parseSlackMessageSync;
+    renderFormatted(content: FormattedContent): string;
+    /**
+     * Check if a Slack event is from this bot.
+     *
+     * Slack messages can come from:
+     * - User messages: have `user` field (U_xxx format)
+     * - Bot messages: have `bot_id` field (B_xxx format)
+     *
+     * We check both because:
+     * - _botUserId is the user ID (U_xxx) - matches event.user
+     * - _botId is the bot ID (B_xxx) - matches event.bot_id
+     */
+    private isMessageFromSelf;
+    private handleSlackError;
+}
+declare function createSlackAdapter(config: SlackAdapterConfig): SlackAdapter;
+
+export { SlackAdapter, type SlackAdapterConfig, type SlackEvent, SlackFormatConverter, SlackFormatConverter as SlackMarkdownConverter, type SlackReactionEvent, type SlackThreadId, cardToBlockKit, cardToFallbackText, createSlackAdapter };