@zhin.js/adapter-slack 4.0.1 → 4.1.1

package/lib/endpoint.js

@@ -1,677 +1,335 @@
 /**
- * Slack Endpoint 实现
+ * SlackEndpoint — lifecycle, outbound, admit, Socket Mode, agent tool surface.
  */
-import { App as SlackApp, LogLevel } from "@slack/bolt";
-import { WebClient } from "@slack/web-api";
-import { formatCompact, Message, segment, expandInteractiveSegmentsInContent, } from 'zhin.js';
-import { normalizeSlackSenderForPermit } from "./platform-permit.js";
-import { fromCanonicalSegments, toCanonicalSegments } from './segment-mapper.js';
+import { SocketModeClient } from '@slack/socket-mode';
+import { WebClient } from '@slack/web-api';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { formatInboundContent, formatInteractionContent, formatSlashContent, inboundMessageId, resolveSlackChannelType, } from './protocol.js';
+import { registerSlackAgentEndpoint } from './slack-agent-deps.js';
+import { createSlackInboundFilterState, shouldDropSlackInboundMessage, } from './slack-inbound-filter.js';
+import { formatSlackMessageRef, parseSlackMessageRef } from './slack-message-ref.js';
+import { normalizeSlackReactionName } from './slack-reaction.js';
+import { postSlackEphemeral } from './slack-response-url.js';
+import { editSlackContent, sendSlackContent } from './slack-outbound.js';
+import { registerSlackWebhookRoutes } from './webhook.js';
+const logger = getLogger('slack');
 export class SlackEndpoint {
-    adapter;
-    $config;
-    $connected;
-    /** 延迟到 `$connect`，避免子类 mock `$connect` 时仍在构造函数里创建 Bolt/WebClient（会在后台触发 Slack API） */
-    app;
-    client;
-    get logger() {
-        return this.adapter.plugin.logger;
-    }
-    get $id() {
-        return this.$config.name;
-    }
-    constructor(adapter, $config) {
-        this.adapter = adapter;
-        this.$config = $config;
-        this.$connected = false;
-    }
-    #ensureSlackRuntime() {
-        if (this.app && this.client)
-            return;
-        const $config = this.$config;
-        if ($config.socketMode && $config.appToken) {
-            this.app = new SlackApp({
-                token: $config.token,
-                signingSecret: $config.signingSecret,
-                appToken: $config.appToken,
-                socketMode: true,
-                logLevel: $config.logLevel || LogLevel.INFO,
-            });
-        }
-        else {
-            this.app = new SlackApp({
-                token: $config.token,
-                signingSecret: $config.signingSecret,
-                socketMode: false,
-                logLevel: $config.logLevel || LogLevel.INFO,
-            });
-        }
-        this.client = new WebClient($config.token);
+    #options;
+    #inboundFilter = createSlackInboundFilterState();
+    #messageChannelMap = new Map();
+    #client;
+    #socket;
+    #routeReleases = [];
+    #botUserId;
+    #open = false;
+    #started = false;
+    #unregisterAgent;
+    constructor(options) {
+        this.#options = options;
+    }
+    get client() {
+        return this.#client;
+    }
+    get platformUserId() {
+        return this.#botUserId;
     }
-    async $connect() {
-        this.#ensureSlackRuntime();
+    get config() {
+        return this.#options.config;
+    }
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
         try {
-            // Set up message event handler
-            this.app.message(async ({ message, say }) => {
-                await this.handleSlackMessage(message);
-            });
-            // Set up app mention handler
-            this.app.event("app_mention", async ({ event, say }) => {
-                await this.handleSlackMessage(event);
-            });
-            // Start the app
-            const port = this.$config.port || 3000;
-            if (this.$config.socketMode) {
-                await this.app.start();
+            const { config } = this.#options;
+            this.#client = this.#options.createClient?.(config.token)
+                ?? new WebClient(config.token);
+            this.#unregisterAgent = registerSlackAgentEndpoint(config.name, this);
+            if (config.mode === 'socket') {
+                await this.#startSocket();
             }
             else {
-                await this.app.start(port);
-            }
-            this.$connected = true;
-            // Get bot info
-            const authTest = await this.client.auth.test();
-            this.logger.info(formatCompact({ endpoint: this.$config.name, user: authTest.user }));
-            if (!this.$config.socketMode) {
-                this.logger.info(formatCompact({ op: "listen", port }));
+                const http = this.#options.http;
+                if (!http) {
+                    throw new Error('Slack HTTP Events API requires httpHostToken (Runtime Host)');
+                }
+                this.#routeReleases.push(...registerSlackWebhookRoutes(http, this));
+                logger.debug(formatCompact({
+                    endpoint: config.name,
+                    op: 'webhook',
+                    path: config.webhookPath,
+                }));
             }
+            const authTest = await this.#client.auth.test();
+            if (authTest.user_id)
+                this.#botUserId = String(authTest.user_id);
+            logger.info(formatCompact({
+                op: 'connect',
+                endpoint: config.name,
+                mode: config.mode,
+                platform_user_id: this.#botUserId,
+            }));
         }
         catch (error) {
-            this.logger.error("Failed to connect Slack bot:", error);
-            this.$connected = false;
+            await this.stop();
+            logger.error('Failed to connect Slack endpoint:', error);
             throw error;
         }
     }
-    async $disconnect() {
-        if (!this.app) {
-            this.$connected = false;
-            return;
-        }
-        try {
-            await this.app.stop();
-            this.$connected = false;
-            this.logger.info(formatCompact({ op: "disconnect", endpoint: this.$config.name }));
-        }
-        catch (error) {
-            this.logger.error("Error disconnecting Slack bot:", error);
-            throw error;
-        }
+    open() {
+        this.#open = true;
     }
-    senderPermitCache = new Map();
-    async enrichChannelSender(message, msg) {
-        if (message.$channel.type !== "group" || !("user" in msg) || !msg.user)
-            return;
-        const channelId = msg.channel;
-        const userId = msg.user;
-        const key = `${channelId}:${userId}`;
-        const now = Date.now();
-        const cached = this.senderPermitCache.get(key);
-        if (cached && now - cached.at < 60_000) {
-            message.$sender.role = cached.role;
-            message.$sender.permissions = cached.permissions;
-            return;
-        }
-        try {
-            const user = await this.getUserInfo(userId);
-            let isChannelManager = false;
+    close() {
+        this.#open = false;
+    }
+    async stop() {
+        this.#open = false;
+        if (this.#socket) {
             try {
-                const channel = await this.getChannelInfo(channelId);
-                if (channel?.creator === userId)
-                    isChannelManager = true;
+                await this.#socket.disconnect();
             }
             catch {
-                // ignore
+                /* ignore */
             }
-            const normalized = normalizeSlackSenderForPermit({
-                isWorkspaceOwner: user.is_owner === true,
-                isWorkspaceAdmin: user.is_admin === true,
-                isChannelManager,
-            });
-            const entry = {
-                at: now,
-                role: normalized.role,
-                permissions: normalized.permissions ?? [],
-            };
-            this.senderPermitCache.set(key, entry);
-            message.$sender.role = entry.role;
-            message.$sender.permissions = entry.permissions;
-        }
-        catch {
-            // 保守拒绝
-        }
+            this.#socket = undefined;
+        }
+        for (const release of this.#routeReleases.splice(0))
+            release();
+        this.#unregisterAgent?.();
+        this.#unregisterAgent = undefined;
+        this.#client = undefined;
+        this.#started = false;
+        logger.debug(formatCompact({ op: 'disconnect', endpoint: this.#options.config.name }));
     }
-    async handleSlackMessage(msg) {
-        // Ignore bot messages and message changes
-        if ("subtype" in msg && (msg.subtype === "bot_message" || msg.subtype === "message_changed")) {
+    async send({ target, payload }) {
+        if (!this.#client)
+            throw new Error('Slack client not connected');
+        const { channel, threadTs } = parseSendTarget(target);
+        const result = await sendSlackContent(this.#client, payload, { channel, threadTs }, logger);
+        if (result.ts)
+            this.trackMessageChannel(result.ts, channel);
+        return formatSlackMessageRef(channel, result.ts || String(Date.now()));
+    }
+    /** Test / internal: admit a message event when open. */
+    admit(event) {
+        if (!this.#open)
             return;
-        }
-        const message = this.$formatMessage(msg);
-        await this.enrichChannelSender(message, msg);
-        this.adapter.emit("message.receive", message);
-        this.logger.debug(`${this.$config.name} recv  ${message.$channel.type}(${message.$channel.id}): ${segment.raw(message.$content)}`);
-    }
-    $formatMessage(msg) {
-        // Determine channel type based on channel ID
-        const channelType = "channel_type" in msg && msg.channel_type === "im" ? "private" : "group";
-        const channelId = msg.channel;
-        // Parse message content
-        const wire = this.parseMessageContent(msg);
-        const content = toCanonicalSegments(wire);
-        // Extract user info safely
-        const userId = ("user" in msg ? msg.user : "") || "";
-        const userName = ("username" in msg ? msg.username : null) || userId || "Unknown";
-        const messageText = ("text" in msg ? msg.text : "") || "";
-        const result = Message.from(msg, {
-            $id: msg.ts,
-            $adapter: "slack",
-            $endpoint: this.$config.name,
-            $sender: {
-                id: userId,
-                name: userName,
-            },
-            $channel: {
-                id: channelId,
-                type: channelType,
-            },
-            $content: content,
-            $raw: messageText,
-            $timestamp: parseFloat(msg.ts) * 1000,
-            $recall: async () => {
-                try {
-                    await this.client.chat.delete({
-                        channel: channelId,
-                        ts: result.$id,
-                    });
-                }
-                catch (error) {
-                    this.logger.error("Error recalling Slack message:", error);
-                    throw error;
-                }
-            },
-            $reply: async (content, quote) => {
-                if (!Array.isArray(content))
-                    content = [content];
-                const sendOptions = {
-                    channel: channelId,
-                };
-                // Handle thread reply
-                if (quote) {
-                    const threadTs = typeof quote === "boolean" ? result.$id : quote;
-                    sendOptions.thread_ts = threadTs;
-                }
-                return await this.adapter.sendMessage({
-                    context: "slack",
-                    endpoint: this.$config.name,
-                    id: channelId,
-                    type: "channel",
-                    content: content,
-                });
-            },
+        if (event.type !== 'message' && event.type !== 'app_mention')
+            return;
+        const msg = event;
+        if (shouldDropSlackInboundMessage(msg, this.#inboundFilter, this.#botUserId))
+            return;
+        if (!msg.channel || !msg.ts)
+            return;
+        this.trackMessageChannel(msg.ts, msg.channel);
+        void this.#options.gateway.receive({
+            adapter: this.#options.id,
+            target: msg.channel,
+            content: formatInboundContent(msg),
+            sender: msg.user ?? msg.channel,
+            id: inboundMessageId(msg),
+            metadata: Object.freeze({
+                endpoint: this.#options.config.name,
+                channelType: resolveSlackChannelType(msg),
+                userId: msg.user,
+                threadTs: msg.thread_ts && msg.thread_ts !== msg.ts ? msg.thread_ts : undefined,
+                ts: msg.ts,
+                // app_mention 事件本身即 @ 机器人；新 Runtime 纯文本 content 需经 metadata 传递
+                ...(msg.type === 'app_mention' ? { mentioned: true } : {}),
+            }),
+        }).catch((err) => {
+            logger.warn(formatCompact({
+                op: 'slack_gateway_receive_failed',
+                target: msg.channel,
+                error: err instanceof Error ? err.message : String(err),
+            }));
         });
-        return result;
-    }
-    parseMessageContent(msg) {
-        const segments = [];
-        // Handle text
-        if ("text" in msg && msg.text) {
-            // Parse Slack formatting
-            segments.push(...this.parseSlackText(msg.text));
-        }
-        // Handle files
-        if ("files" in msg && msg.files) {
-            for (const file of msg.files) {
-                if (file.mimetype?.startsWith("image/")) {
-                    segments.push({
-                        type: "image",
-                        data: {
-                            id: file.id,
-                            name: file.name,
-                            url: file.url_private || file.permalink,
-                            size: file.size,
-                            mimetype: file.mimetype,
-                        },
-                    });
-                }
-                else if (file.mimetype?.startsWith("video/")) {
-                    segments.push({
-                        type: "video",
-                        data: {
-                            id: file.id,
-                            name: file.name,
-                            url: file.url_private || file.permalink,
-                            size: file.size,
-                            mimetype: file.mimetype,
-                        },
-                    });
-                }
-                else if (file.mimetype?.startsWith("audio/")) {
-                    segments.push({
-                        type: "audio",
-                        data: {
-                            id: file.id,
-                            name: file.name,
-                            url: file.url_private || file.permalink,
-                            size: file.size,
-                            mimetype: file.mimetype,
-                        },
-                    });
-                }
-                else {
-                    segments.push({
-                        type: "file",
-                        data: {
-                            id: file.id,
-                            name: file.name,
-                            url: file.url_private || file.permalink,
-                            size: file.size,
-                            mimetype: file.mimetype,
-                        },
-                    });
-                }
-            }
-        }
-        // Handle attachments
-        if ("attachments" in msg && msg.attachments) {
-            for (const attachment of msg.attachments) {
-                if (attachment.image_url) {
-                    segments.push({
-                        type: "image",
-                        data: {
-                            url: attachment.image_url,
-                            title: attachment.title,
-                            text: attachment.text,
-                        },
-                    });
-                }
-            }
-        }
-        return segments.length > 0
-            ? segments
-            : [{ type: "text", data: { text: "" } }];
-    }
-    parseSlackText(text) {
-        const segments = [];
-        let lastIndex = 0;
-        // Match user mentions <@U12345678>
-        const userMentionRegex = /<@([UW][A-Z0-9]+)(?:\|([^>]+))?>/g;
-        // Match channel mentions <#C12345678|general>
-        const channelMentionRegex = /<#([C][A-Z0-9]+)(?:\|([^>]+))?>/g;
-        // Match links <http://example.com|Example>
-        const linkRegex = /<(https?:\/\/[^|>]+)(?:\|([^>]+))?>/g;
-        const allMatches = [];
-        // Collect all matches
-        let match;
-        while ((match = userMentionRegex.exec(text)) !== null) {
-            allMatches.push({ match, type: "user" });
-        }
-        while ((match = channelMentionRegex.exec(text)) !== null) {
-            allMatches.push({ match, type: "channel" });
-        }
-        while ((match = linkRegex.exec(text)) !== null) {
-            allMatches.push({ match, type: "link" });
-        }
-        // Sort by position
-        allMatches.sort((a, b) => a.match.index - b.match.index);
-        // Process matches
-        for (const { match, type } of allMatches) {
-            const matchStart = match.index;
-            const matchEnd = matchStart + match[0].length;
-            // Add text before match
-            if (matchStart > lastIndex) {
-                const beforeText = text.slice(lastIndex, matchStart);
-                if (beforeText.trim()) {
-                    segments.push({ type: "text", data: { text: beforeText } });
-                }
-            }
-            // Add special segment
-            switch (type) {
-                case "user":
-                    segments.push({
-                        type: "at",
-                        data: {
-                            id: match[1],
-                            name: match[2] || match[1],
-                            text: match[0],
-                        },
-                    });
-                    break;
-                case "channel":
-                    segments.push({
-                        type: "channel_mention",
-                        data: {
-                            id: match[1],
-                            name: match[2] || match[1],
-                            text: match[0],
-                        },
-                    });
-                    break;
-                case "link":
-                    segments.push({
-                        type: "link",
-                        data: {
-                            url: match[1],
-                            text: match[2] || match[1],
-                        },
-                    });
-                    break;
-            }
-            lastIndex = matchEnd;
-        }
-        // Add remaining text
-        if (lastIndex < text.length) {
-            const remainingText = text.slice(lastIndex);
-            if (remainingText.trim()) {
-                segments.push({ type: "text", data: { text: remainingText } });
-            }
-        }
-        return segments.length > 0
-            ? segments
-            : [{ type: "text", data: { text } }];
     }
-    async $sendMessage(options) {
-        try {
-            const canonical = expandInteractiveSegmentsInContent(options.content);
-            const wire = fromCanonicalSegments(canonical);
-            const result = await this.sendContentToChannel(options.id, wire);
-            this.logger.debug(`${this.$config.name} send ${options.type}(${options.id}): ${segment.raw(options.content)}`);
-            return result.ts || "";
-        }
-        catch (error) {
-            this.logger.error("Failed to send Slack message:", error);
-            throw error;
-        }
+    admitInteraction(payload) {
+        if (!this.#open)
+            return;
+        if (payload.type !== 'block_actions' || !payload.actions?.length)
+            return;
+        const channelId = payload.channel?.id ?? '';
+        const userId = payload.user.id;
+        const messageTs = payload.message?.ts ?? '';
+        if (payload.response_url) {
+            postSlackEphemeral(payload.response_url, '已收到', logger);
+        }
+        void this.#options.gateway.receive({
+            adapter: this.#options.id,
+            target: channelId || userId,
+            content: formatInteractionContent(payload),
+            sender: userId,
+            id: payload.actions[0]?.action_ts ?? messageTs ?? `action-${Date.now()}`,
+            metadata: Object.freeze({
+                endpoint: this.#options.config.name,
+                eventType: 'block_actions',
+                actionId: payload.actions[0]?.action_id,
+                threadTs: messageTs || undefined,
+            }),
+        }).catch((err) => {
+            logger.warn(formatCompact({
+                op: 'slack_gateway_receive_failed',
+                target: channelId,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
     }
-    async sendContentToChannel(channel, content, extraOptions = {}) {
-        if (!Array.isArray(content))
-            content = [content];
-        let textContent = "";
-        const attachments = [];
-        for (const segment of content) {
-            if (typeof segment === "string") {
-                textContent += segment;
-                continue;
-            }
-            const { type, data } = segment;
-            switch (type) {
-                case "text":
-                    textContent += data.text || "";
-                    break;
-                case "at":
-                    textContent += `<@${data.id}>`;
-                    break;
-                case "channel_mention":
-                    textContent += `<#${data.id}>`;
-                    break;
-                case "link":
-                    if (data.text && data.text !== data.url) {
-                        textContent += `<${data.url}|${data.text}>`;
-                    }
-                    else {
-                        textContent += `<${data.url}>`;
-                    }
-                    break;
-                case "image":
-                    if (data.url) {
-                        attachments.push({
-                            image_url: data.url,
-                            title: data.name || data.title,
-                        });
-                    }
-                    break;
-                case "file":
-                    // Files need to be uploaded separately
-                    if (data.file) {
-                        try {
-                            await this.client.files.upload({
-                                channels: channel,
-                                file: data.file,
-                                filename: data.name,
-                            });
-                        }
-                        catch (error) {
-                            this.logger.error("Failed to upload file:", error);
-                        }
-                    }
-                    break;
-                default:
-                    textContent += data.text || `[${type}]`;
-            }
-        }
-        // Send message
-        const messageOptions = {
-            channel,
-            text: textContent.trim() || "Message",
-            ...extraOptions,
-        };
-        if (attachments.length > 0) {
-            messageOptions.attachments = attachments;
+    admitSlashCommand(cmd) {
+        if (!this.#open)
+            return;
+        postSlackEphemeral(cmd.response_url, '处理中…', logger);
+        void this.#options.gateway.receive({
+            adapter: this.#options.id,
+            target: cmd.channel_id,
+            content: formatSlashContent(cmd),
+            sender: cmd.user_id,
+            id: cmd.trigger_id,
+            metadata: Object.freeze({
+                endpoint: this.#options.config.name,
+                eventType: 'slash_command',
+                command: cmd.command,
+            }),
+        }).catch((err) => {
+            logger.warn(formatCompact({
+                op: 'slack_gateway_receive_failed',
+                target: cmd.channel_id,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    handleEnvelope(body) {
+        const envelope = body;
+        if (envelope?.type === 'event_callback' && envelope.event) {
+            this.admit(envelope.event);
         }
-        const result = await this.client.chat.postMessage(messageOptions);
-        return result.message || {};
-    }
-    async $recallMessage(id) {
-        // Slack requires both channel and ts (timestamp) to delete a message
-        // The Endpoint interface only provides message ID (ts), making recall impossible  
-        // Users should use message.$recall() instead, which has the full context
-        throw new Error("SlackEndpoint.$recallMessage: Message recall not supported without channel information. " +
-            "Use message.$recall() method instead, which contains the required context.");
-    }
-    // ==================== 工作区管理 API ====================
-    /**
-     * 邀请用户到频道
-     * @param channel 频道 ID
-     * @param users 用户 ID 列表
-     */
+    }
+    trackMessageChannel(ts, channel) {
+        if (ts && channel)
+            this.#messageChannelMap.set(ts, channel);
+    }
+    resolveMessageRef(messageId, channelHint) {
+        const parsed = parseSlackMessageRef(messageId);
+        if (parsed) {
+            this.trackMessageChannel(parsed.ts, parsed.channel);
+            return parsed;
+        }
+        if (channelHint)
+            return { channel: channelHint, ts: messageId };
+        const channel = this.#messageChannelMap.get(messageId);
+        return channel ? { channel, ts: messageId } : null;
+    }
+    async editMessage(channel, messageTs, content) {
+        if (!this.#client)
+            throw new Error('Slack client not connected');
+        await editSlackContent(this.#client, channel, messageTs, content);
+    }
+    // ── Agent tool surface ──────────────────────────────────────────────
     async inviteToChannel(channel, users) {
-        try {
-            await this.client.conversations.invite({ channel, users: users.join(',') });
-            this.logger.debug(formatCompact({ op: "invite", endpoint: this.$id, channel, users: users.join(",") }));
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 邀请用户失败:`, error);
-            throw error;
-        }
+        await this.#client.conversations.invite({ channel, users: users.join(',') });
+        return true;
     }
-    /**
-     * 从频道踢出用户
-     * @param channel 频道 ID
-     * @param user 用户 ID
-     */
     async kickFromChannel(channel, user) {
-        try {
-            await this.client.conversations.kick({ channel, user });
-            this.logger.debug(formatCompact({ op: "kick", endpoint: this.$id, channel, user }));
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 踢出用户失败:`, error);
-            throw error;
-        }
+        await this.#client.conversations.kick({ channel, user });
+        return true;
     }
-    /**
-     * 设置频道话题
-     * @param channel 频道 ID
-     * @param topic 话题
-     */
     async setChannelTopic(channel, topic) {
-        try {
-            await this.client.conversations.setTopic({ channel, topic });
-            this.logger.debug(formatCompact({ op: "set_topic", endpoint: this.$id, channel }));
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 设置话题失败:`, error);
-            throw error;
-        }
+        await this.#client.conversations.setTopic({ channel, topic });
+        return true;
     }
-    /**
-     * 设置频道目的
-     * @param channel 频道 ID
-     * @param purpose 目的
-     */
     async setChannelPurpose(channel, purpose) {
-        try {
-            await this.client.conversations.setPurpose({ channel, purpose });
-            this.logger.debug(formatCompact({ op: "set_purpose", endpoint: this.$id, channel }));
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 设置目的失败:`, error);
-            throw error;
-        }
+        await this.#client.conversations.setPurpose({ channel, purpose });
+        return true;
     }
-    /**
-     * 归档频道
-     * @param channel 频道 ID
-     */
     async archiveChannel(channel) {
-        try {
-            await this.client.conversations.archive({ channel });
-            this.logger.debug(formatCompact({ op: "archive", endpoint: this.$id, channel }));
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 归档频道失败:`, error);
-            throw error;
-        }
+        await this.#client.conversations.archive({ channel });
+        return true;
     }
-    /**
-     * 取消归档频道
-     * @param channel 频道 ID
-     */
     async unarchiveChannel(channel) {
-        try {
-            await this.client.conversations.unarchive({ channel });
-            this.logger.debug(formatCompact({ op: "unarchive", endpoint: this.$id, channel }));
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 取消归档失败:`, error);
-            throw error;
-        }
+        await this.#client.conversations.unarchive({ channel });
+        return true;
     }
-    /**
-     * 重命名频道
-     * @param channel 频道 ID
-     * @param name 新名称
-     */
     async renameChannel(channel, name) {
-        try {
-            await this.client.conversations.rename({ channel, name });
-            this.logger.debug(formatCompact({ op: "rename", endpoint: this.$id, channel, name }));
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 重命名频道失败:`, error);
-            throw error;
-        }
+        await this.#client.conversations.rename({ channel, name });
+        return true;
     }
-    /**
-     * 获取频道成员列表
-     * @param channel 频道 ID
-     */
     async getChannelMembers(channel) {
-        try {
-            const result = await this.client.conversations.members({ channel });
-            return result.members || [];
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 获取成员列表失败:`, error);
-            throw error;
-        }
+        const result = await this.#client.conversations.members({ channel });
+        return result.members || [];
     }
-    /**
-     * 获取频道信息
-     * @param channel 频道 ID
-     */
     async getChannelInfo(channel) {
-        try {
-            const result = await this.client.conversations.info({ channel });
-            return result.channel;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 获取频道信息失败:`, error);
-            throw error;
-        }
+        const result = await this.#client.conversations.info({ channel });
+        return result.channel;
     }
-    /**
-     * 获取用户信息
-     * @param user 用户 ID
-     */
     async getUserInfo(user) {
-        try {
-            const result = await this.client.users.info({ user });
-            return result.user;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 获取用户信息失败:`, error);
-            throw error;
-        }
+        const result = await this.#client.users.info({ user });
+        return result.user;
     }
-    /**
-     * 添加消息反应
-     * @param channel 频道 ID
-     * @param timestamp 消息时间戳
-     * @param name 表情名称
-     */
     async addReaction(channel, timestamp, name) {
+        const reaction = normalizeSlackReactionName(name);
         try {
-            await this.client.reactions.add({ channel, timestamp, name });
-            this.logger.debug(formatCompact({ op: "reaction_add", endpoint: this.$id, name }));
+            await this.#client.reactions.add({ channel, timestamp, name: reaction });
             return true;
         }
         catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 添加反应失败:`, error);
+            const code = error?.data?.error;
+            if (code === 'already_reacted')
+                return true;
             throw error;
         }
     }
-    /**
-     * 移除消息反应
-     * @param channel 频道 ID
-     * @param timestamp 消息时间戳
-     * @param name 表情名称
-     */
     async removeReaction(channel, timestamp, name) {
+        const reaction = normalizeSlackReactionName(name);
         try {
-            await this.client.reactions.remove({ channel, timestamp, name });
-            this.logger.debug(formatCompact({ op: "reaction_remove", endpoint: this.$id, name }));
+            await this.#client.reactions.remove({ channel, timestamp, name: reaction });
             return true;
         }
         catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 移除反应失败:`, error);
+            const code = error?.data?.error;
+            if (code === 'no_reaction')
+                return true;
             throw error;
         }
     }
-    /**
-     * 置顶消息
-     * @param channel 频道 ID
-     * @param timestamp 消息时间戳
-     */
     async pinMessage(channel, timestamp) {
-        try {
-            await this.client.pins.add({ channel, timestamp });
-            this.logger.debug(formatCompact({ op: "pin", endpoint: this.$id, channel }));
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 置顶消息失败:`, error);
-            throw error;
-        }
+        await this.#client.pins.add({ channel, timestamp });
+        return true;
     }
-    /**
-     * 取消置顶消息
-     * @param channel 频道 ID
-     * @param timestamp 消息时间戳
-     */
     async unpinMessage(channel, timestamp) {
-        try {
-            await this.client.pins.remove({ channel, timestamp });
-            this.logger.debug(formatCompact({ op: "unpin", endpoint: this.$id, channel }));
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Slack Endpoint ${this.$id} 取消置顶失败:`, error);
-            throw error;
-        }
+        await this.#client.pins.remove({ channel, timestamp });
+        return true;
+    }
+    async #startSocket() {
+        const { config } = this.#options;
+        if (!config.appToken)
+            throw new Error('Socket Mode requires appToken');
+        this.#socket = this.#options.createSocket?.({
+            appToken: config.appToken,
+            clientPingTimeout: config.clientPingTimeout,
+        }) ?? new SocketModeClient({
+            appToken: config.appToken,
+            clientPingTimeout: config.clientPingTimeout,
+        });
+        this.#socket.on('slack_event', async ({ ack, body }) => {
+            await ack();
+            this.handleEnvelope(body);
+        });
+        this.#socket.on('interactive', async ({ ack, body }) => {
+            await ack();
+            this.admitInteraction(body);
+        });
+        this.#socket.on('slash_commands', async ({ ack, body }) => {
+            await ack();
+            this.admitSlashCommand(body);
+        });
+        await this.#socket.start();
+    }
+}
+function parseSendTarget(target) {
+    const parsed = parseSlackMessageRef(target);
+    if (parsed && /^\d+\.\d+$/.test(parsed.ts)) {
+        return { channel: parsed.channel, threadTs: parsed.ts };
     }
+    return { channel: target };
 }
-//# sourceMappingURL=endpoint.js.map