@zhin.js/adapter-slack 4.0.1 → 4.1.0

package/src/event-dispatcher.ts

@@ -0,0 +1,255 @@
+/**
+ * Slack 统一事件分发 — 两种传输模式共用
+ */
+import { Message, segment, formatCompact, expandInteractiveSegmentsInContent } from 'zhin.js';
+import { toCanonicalSegments } from './segment-mapper.js';
+import { parseSlackMessageToSegments, resolveSlackChannelType } from './slack-inbound.js';
+import { isSlackNoticeEvent, formatSlackNotice } from './slack-side-events.js';
+import { normalizeSlackSenderForPermit } from './platform-permit.js';
+import type { SlackEvent, SlackMessageEvent, SlackInteractionPayload, SlackSlashCommand } from './types.js';
+import type { SlackEndpoint } from './endpoint.js';
+import { formatSlackMessageRef } from './slack-message-ref.js';
+import { createSlackInboundFilterState, shouldDropSlackInboundMessage } from './slack-inbound-filter.js';
+import { postSlackEphemeral } from './slack-response-url.js';
+
+export class SlackEventDispatcher {
+  private readonly inboundFilter = createSlackInboundFilterState();
+
+  constructor(private endpoint: SlackEndpoint) {}
+
+  private get adapter() { return this.endpoint.adapter; }
+  private get logger() { return this.endpoint.logger; }
+
+  async routeEvent(event: SlackEvent): Promise<void> {
+    const type = event.type;
+
+    if (type === 'message' || type === 'app_mention') {
+      await this.handleMessage(event as SlackMessageEvent);
+      return;
+    }
+
+    if (type === 'assistant_thread_started') {
+      this.handleAssistantThreadStarted(event);
+      return;
+    }
+
+    if (type === 'assistant_thread_context_changed') {
+      return;
+    }
+
+    if (isSlackNoticeEvent(type)) {
+      this.handleNotice(event);
+      return;
+    }
+  }
+
+  routeInteraction(payload: SlackInteractionPayload): void {
+    if (payload.type === 'block_actions' && payload.actions?.length) {
+      this.handleBlockAction(payload);
+    }
+  }
+
+  routeSlashCommand(cmd: SlackSlashCommand): void {
+    this.handleSlashCommand(cmd);
+  }
+
+  private async handleMessage(event: SlackMessageEvent): Promise<void> {
+    if (shouldDropSlackInboundMessage(event, this.inboundFilter, this.endpoint.$platformUserId)) {
+      return;
+    }
+
+    const messageRef = formatSlackMessageRef(event.channel, event.ts);
+    this.endpoint.trackMessageChannel(event.ts, event.channel);
+
+    const wire = parseSlackMessageToSegments(event);
+    const content = toCanonicalSegments(wire);
+    const channelType = resolveSlackChannelType(event);
+
+    const userId = event.user ?? '';
+    const userName = (event as any).username ?? (userId || 'Unknown');
+
+    const message = Message.from(event, {
+      $id: messageRef,
+      $adapter: 'slack',
+      $endpoint: this.endpoint.$config.name,
+      $sender: { id: userId, name: userName },
+      $channel: { id: event.channel, type: channelType },
+      $content: content,
+      $raw: event.text ?? '',
+      $timestamp: parseFloat(event.ts) * 1000,
+      $quote_id: event.thread_ts && event.thread_ts !== event.ts ? event.thread_ts : undefined,
+      $recall: async () => {
+        await this.endpoint.client!.chat.delete({ channel: event.channel, ts: event.ts });
+      },
+      $reply: async (replyContent, quote?) => {
+        if (!Array.isArray(replyContent)) replyContent = [replyContent];
+        const threadTs = quote
+          ? (typeof quote === 'boolean' ? event.ts : quote)
+          : (event.thread_ts ?? undefined);
+        return await this.adapter.sendMessage({
+          context: 'slack',
+          endpoint: this.endpoint.$config.name,
+          id: event.channel,
+          type: channelType,
+          content: replyContent,
+          ...(threadTs ? { threadId: threadTs } : {}),
+        });
+      },
+    });
+
+    await this.enrichSender(message, event);
+    this.adapter.emit('message.receive', message);
+    this.logger.debug(
+      `${this.endpoint.$config.name} recv ${message.$channel.type}(${message.$channel.id}): ${segment.raw(message.$content)}`,
+    );
+  }
+
+  private handleNotice(event: SlackEvent): void {
+    const notice = formatSlackNotice(event, this.endpoint.$config.name);
+    this.adapter.emit('notice.receive' as any, notice);
+    this.logger.debug(formatCompact({
+      notice: `${notice.$scene_type}.${notice.$sub_type}`,
+      endpoint: this.endpoint.$id,
+      scene: notice.$scene_id,
+    }));
+  }
+
+  private handleBlockAction(payload: SlackInteractionPayload): void {
+    const action = payload.actions![0];
+    const channelId = payload.channel?.id ?? '';
+    const userId = payload.user.id;
+    const userName = payload.user.username ?? payload.user.name ?? userId;
+    const messageTs = payload.message?.ts ?? '';
+
+    if (payload.response_url) {
+      postSlackEphemeral(payload.response_url, '已收到', this.logger);
+    }
+
+    const actionSegment = {
+      type: 'action',
+      data: {
+        id: action.action_id,
+        value: action.value ?? '',
+        payload: JSON.stringify(action),
+        text: action.text?.text ?? '',
+      },
+    };
+
+    const message = Message.from(payload as any, {
+      $id: action.action_ts ?? messageTs,
+      $adapter: 'slack',
+      $endpoint: this.endpoint.$config.name,
+      $sender: { id: userId, name: userName },
+      $channel: { id: channelId, type: 'group' },
+      $content: toCanonicalSegments([actionSegment]),
+      $raw: action.text?.text ?? '',
+      $timestamp: Date.now(),
+      $reply: async (content) => {
+        if (!Array.isArray(content)) content = [content];
+        return await this.adapter.sendMessage({
+          context: 'slack',
+          endpoint: this.endpoint.$config.name,
+          id: channelId,
+          type: 'group',
+          content,
+          ...(messageTs ? { threadId: messageTs } : {}),
+        });
+      },
+    });
+
+    this.adapter.emit('message.receive', message);
+  }
+
+  private handleSlashCommand(cmd: SlackSlashCommand): void {
+    const text = `${cmd.command} ${cmd.text}`.trim();
+
+    postSlackEphemeral(cmd.response_url, '处理中…', this.logger);
+
+    const message = Message.from(cmd as any, {
+      $id: cmd.trigger_id,
+      $adapter: 'slack',
+      $endpoint: this.endpoint.$config.name,
+      $sender: { id: cmd.user_id, name: cmd.user_name },
+      $channel: { id: cmd.channel_id, type: 'group' },
+      $content: [{ type: 'text', data: { text } }],
+      $raw: text,
+      $timestamp: Date.now(),
+      $reply: async (content) => {
+        if (!Array.isArray(content)) content = [content];
+        return await this.adapter.sendMessage({
+          context: 'slack',
+          endpoint: this.endpoint.$config.name,
+          id: cmd.channel_id,
+          type: 'group',
+          content,
+        });
+      },
+    });
+
+    this.adapter.emit('message.receive', message);
+  }
+
+  private handleAssistantThreadStarted(event: SlackEvent): void {
+    const thread = (event as any).assistant_thread;
+    if (!thread) return;
+
+    const userId = thread.user_id ?? '';
+    const channelId = thread.channel_id ?? '';
+    const threadTs = thread.thread_ts ?? '';
+
+    const message = Message.from(event, {
+      $id: threadTs,
+      $adapter: 'slack',
+      $endpoint: this.endpoint.$config.name,
+      $sender: { id: userId, name: userId },
+      $channel: { id: channelId, type: 'private' },
+      $content: [{ type: 'text', data: { text: '' } }],
+      $raw: '',
+      $timestamp: Date.now(),
+      $reply: async (content) => {
+        if (!Array.isArray(content)) content = [content];
+        return await this.adapter.sendMessage({
+          context: 'slack',
+          endpoint: this.endpoint.$config.name,
+          id: channelId,
+          type: 'private',
+          content,
+          threadId: threadTs,
+        });
+      },
+    });
+
+    this.adapter.emit('message.receive', message);
+  }
+
+  private async enrichSender(message: Message<any>, event: SlackEvent): Promise<void> {
+    if (message.$channel.type !== 'group' || !event.user) return;
+    const channelId = event.channel ?? '';
+    const userId = event.user;
+    const key = `${channelId}:${userId}`;
+    const now = Date.now();
+    const cached = this.endpoint.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.endpoint.getUserInfo(userId);
+      let isChannelManager = false;
+      try {
+        const channel = await this.endpoint.getChannelInfo(channelId);
+        if (channel?.creator === userId) isChannelManager = true;
+      } catch { /* 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.endpoint.senderPermitCache.set(key, entry);
+      message.$sender.role = entry.role;
+      message.$sender.permissions = entry.permissions;
+    } catch { /* conservative deny */ }
+  }
+}

package/src/index.ts

@@ -1,30 +1,33 @@
 /**
  * Slack 适配器入口：类型扩展、导出、注册
  */
-import { usePlugin, type Plugin, type ISceneManagement, createSceneManagementTools, type ToolFeature } from "zhin.js";
-import { SlackAdapter } from "./adapter.js";
+import { usePlugin, type Plugin, type ISceneManagement, createSceneManagementTools, type ToolFeature } from 'zhin.js';
+import type { Router } from '@zhin.js/host-router';
+import { SlackAdapter } from './adapter.js';
+import { SlackEventDispatcher } from './event-dispatcher.js';
+import { SlackHttpTransport } from './transport-http.js';
 import {
-  platformPermit,
   registerSlackPlatformPermitChecker,
   slackGroupPermitResolver,
-} from "./platform-permit.js";
+} from './platform-permit.js';
+import { setSlackAgentDeps } from './slack-agent-deps.js';
 
-declare module "zhin.js" {
+declare module 'zhin.js' {
   interface Adapters {
     slack: SlackAdapter;
   }
 }
 
-export * from "./types.js";
-export { SlackEndpoint } from "./endpoint.js";
-export { SlackAdapter } from "./adapter.js";
+export * from './types.js';
+export { SlackEndpoint } from './endpoint.js';
+export { SlackAdapter } from './adapter.js';
 
 const plugin = usePlugin();
 const { provide, useContext } = plugin;
 
 provide({
-  name: "slack",
-  description: "Slack Endpoint Adapter",
+  name: 'slack',
+  description: 'Slack Endpoint Adapter',
   mounted: async (p: Plugin) => {
     const adapter = new SlackAdapter(p);
     await adapter.start();
@@ -35,15 +38,20 @@ provide({
   },
 });
 
+useContext('router', 'slack', (router: Router, slack: SlackAdapter) => {
+  for (const [, endpoint] of slack.endpoints) {
+    if (!endpoint.$config.socketMode) {
+      const dispatcher = new SlackEventDispatcher(endpoint);
+      const transport = new SlackHttpTransport(endpoint.$config, dispatcher, endpoint.logger);
+      transport.registerRoutes(router);
+    }
+  }
+  return () => {};
+});
+
 useContext('tool', 'slack', (toolService: ToolFeature, slack: SlackAdapter) => {
   const disposers: (() => void)[] = [];
   disposers.push(registerSlackPlatformPermitChecker());
-  const sceneTools = createSceneManagementTools(
-    slack as unknown as ISceneManagement,
-    'slack',
-    { permitResolver: slackGroupPermitResolver, registerChecker: false },
-  );
-  disposers.push(...sceneTools.map(t => toolService.addTool(t, plugin.name)));
 
   function getEndpoint(endpointId: string) {
     const endpoint = slack.endpoints.get(endpointId);
@@ -51,230 +59,14 @@ useContext('tool', 'slack', (toolService: ToolFeature, slack: SlackAdapter) => {
     return endpoint;
   }
 
-  disposers.push(toolService.addTool({
-    name: 'slack_invite_to_channel',
-    description: '邀请用户加入 Slack 频道',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        channel: { type: 'string', description: '频道 ID' },
-        users: { type: 'string', description: '用户 ID 列表（逗号分隔）' },
-      },
-      required: ['endpoint_id', 'channel', 'users'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    permissions: [platformPermit('channel_manager')],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const success = await endpoint.inviteToChannel(args.channel, args.users.split(','));
-      return { success, message: success ? '已邀请用户加入频道' : '操作失败' };
-    },
-  }, plugin.name));
-
-  disposers.push(toolService.addTool({
-    name: 'slack_set_topic',
-    description: '设置 Slack 频道话题',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        channel: { type: 'string', description: '频道 ID' },
-        topic: { type: 'string', description: '新话题' },
-      },
-      required: ['endpoint_id', 'channel', 'topic'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    permissions: [platformPermit('channel_manager')],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const success = await endpoint.setChannelTopic(args.channel, args.topic);
-      return { success, message: success ? '已设置频道话题' : '操作失败' };
-    },
-  }, plugin.name));
-
-  disposers.push(toolService.addTool({
-    name: 'slack_archive_channel',
-    description: '归档 Slack 频道',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        channel: { type: 'string', description: '频道 ID' },
-      },
-      required: ['endpoint_id', 'channel'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    permissions: [platformPermit('workspace_admin')],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const success = await endpoint.archiveChannel(args.channel);
-      return { success, message: success ? '已归档频道' : '操作失败' };
-    },
-  }, plugin.name));
-
-  disposers.push(toolService.addTool({
-    name: 'slack_pin_message',
-    description: '置顶 Slack 消息',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        channel: { type: 'string', description: '频道 ID' },
-        timestamp: { type: 'string', description: '消息时间戳' },
-      },
-      required: ['endpoint_id', 'channel', 'timestamp'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    permissions: [platformPermit('channel_manager')],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const success = await endpoint.pinMessage(args.channel, args.timestamp);
-      return { success, message: success ? '已置顶消息' : '操作失败' };
-    },
-  }, plugin.name));
+  setSlackAgentDeps({ getEndpoint, getAdapter: () => slack });
 
-  disposers.push(toolService.addTool({
-    name: 'slack_add_reaction',
-    description: '给 Slack 消息添加表情反应',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        channel: { type: 'string', description: '频道 ID' },
-        timestamp: { type: 'string', description: '消息时间戳' },
-        emoji: { type: 'string', description: '表情名称（不含冒号）' },
-      },
-      required: ['endpoint_id', 'channel', 'timestamp', 'emoji'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const success = await endpoint.addReaction(args.channel, args.timestamp, args.emoji);
-      return { success, message: success ? `已添加反应 :${args.emoji}:` : '操作失败' };
-    },
-  }, plugin.name));
-
-  disposers.push(toolService.addTool({
-    name: 'slack_remove_reaction',
-    description: '移除 Slack 消息上的表情反应',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        channel_id: { type: 'string', description: '频道 ID' },
-        timestamp: { type: 'string', description: '消息时间戳' },
-        name: { type: 'string', description: '表情名称（如 thumbsup、heart）' },
-      },
-      required: ['endpoint_id', 'channel_id', 'timestamp', 'name'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const success = await endpoint.removeReaction(args.channel_id, args.timestamp, args.name);
-      return { success, message: success ? `已移除反应 :${args.name}:` : '操作失败' };
-    },
-  }, plugin.name));
-
-  disposers.push(toolService.addTool({
-    name: 'slack_unpin_message',
-    description: '取消 Slack 频道中消息的置顶',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        channel_id: { type: 'string', description: '频道 ID' },
-        timestamp: { type: 'string', description: '消息时间戳' },
-      },
-      required: ['endpoint_id', 'channel_id', 'timestamp'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    permissions: [platformPermit('channel_manager')],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const success = await endpoint.unpinMessage(args.channel_id, args.timestamp);
-      return { success, message: success ? '已取消置顶' : '操作失败' };
-    },
-  }, plugin.name));
-
-  disposers.push(toolService.addTool({
-    name: 'slack_user_info',
-    description: '查询 Slack 用户详细信息',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        user_id: { type: 'string', description: '用户 ID' },
-      },
-      required: ['endpoint_id', 'user_id'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const user = await endpoint.getUserInfo(args.user_id);
-      return {
-        id: user.id,
-        name: user.name,
-        real_name: user.real_name,
-        display_name: user.profile?.display_name,
-        email: user.profile?.email,
-        is_admin: user.is_admin,
-        is_bot: user.is_bot,
-        status_text: user.profile?.status_text,
-      };
-    },
-  }, plugin.name));
-
-  disposers.push(toolService.addTool({
-    name: 'slack_set_purpose',
-    description: '设置 Slack 频道的用途/目的',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        channel_id: { type: 'string', description: '频道 ID' },
-        purpose: { type: 'string', description: '频道用途描述' },
-      },
-      required: ['endpoint_id', 'channel_id', 'purpose'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    permissions: [platformPermit('channel_manager')],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const success = await endpoint.setChannelPurpose(args.channel_id, args.purpose);
-      return { success, message: success ? '频道用途已更新' : '操作失败' };
-    },
-  }, plugin.name));
-
-  disposers.push(toolService.addTool({
-    name: 'slack_unarchive',
-    description: '恢复已归档的 Slack 频道',
-    parameters: {
-      type: 'object',
-      properties: {
-        endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-        channel_id: { type: 'string', description: '频道 ID' },
-      },
-      required: ['endpoint_id', 'channel_id'],
-    },
-    platforms: ['slack'],
-    tags: ['slack'],
-    permissions: [platformPermit('workspace_admin')],
-    execute: async (args: Record<string, any>) => {
-      const endpoint = getEndpoint(args.endpoint_id);
-      const success = await endpoint.unarchiveChannel(args.channel_id);
-      return { success, message: success ? '频道已恢复' : '操作失败' };
-    },
-  }, plugin.name));
+  const sceneTools = createSceneManagementTools(
+    slack as unknown as ISceneManagement,
+    'slack',
+    { permitResolver: slackGroupPermitResolver, registerChecker: false },
+  );
+  disposers.push(...sceneTools.map(t => toolService.addTool(t, plugin.name)));
 
   return () => disposers.forEach(d => d());
 });

package/src/markdown-to-mrkdwn.ts

@@ -0,0 +1,58 @@
+/**
+ * 常见 Markdown → Slack mrkdwn（Slack 粗体为 *text*，链接为 <url|text>）
+ */
+export const SLACK_MRKDWN_TEXT_MAX = 2900;
+
+export function markdownToMrkdwn(text: string): string {
+  let result = replaceMarkdownLinks(text);
+  result = result.replace(/\*\*([^*]+)\*\*/g, '*$1*');
+  result = result.replace(/__([^_]+)__/g, '*$1*');
+  result = result.replace(/~~([^~]+)~~/g, '~$1~');
+  result = result.replace(/^#{1,6}\s+(.+)$/gm, '*$1*');
+  return result;
+}
+
+function replaceMarkdownLinks(text: string): string {
+  let out = '';
+  let cursor = 0;
+  while (cursor < text.length) {
+    const labelStart = text.indexOf('[', cursor);
+    if (labelStart < 0) break;
+    const labelEnd = text.indexOf(']', labelStart + 1);
+    if (labelEnd < 0 || text[labelEnd + 1] !== '(') {
+      out += text.slice(cursor, labelStart + 1);
+      cursor = labelStart + 1;
+      continue;
+    }
+    const urlEnd = text.indexOf(')', labelEnd + 2);
+    if (urlEnd < 0) break;
+    out += text.slice(cursor, labelStart);
+    out += `<${text.slice(labelEnd + 2, urlEnd)}|${text.slice(labelStart + 1, labelEnd)}>`;
+    cursor = urlEnd + 1;
+  }
+  return out + text.slice(cursor);
+}
+
+/** 按 Slack section mrkdwn 上限切分（尽量在换行/空格处断开） */
+export function splitMrkdwnText(text: string, maxLen = SLACK_MRKDWN_TEXT_MAX): string[] {
+  if (text.length <= maxLen) return [text];
+  const chunks: string[] = [];
+  let rest = text;
+  while (rest.length > maxLen) {
+    let cut = rest.lastIndexOf('\n', maxLen);
+    if (cut < maxLen * 0.4) cut = rest.lastIndexOf(' ', maxLen);
+    if (cut <= 0) cut = maxLen;
+    chunks.push(rest.slice(0, cut).trimEnd());
+    rest = rest.slice(cut).trimStart();
+  }
+  if (rest) chunks.push(rest);
+  return chunks.length > 0 ? chunks : [text];
+}
+
+/** 通知栏 / 无障碍 fallback 用的纯文本 */
+export function mrkdwnToPlainFallback(text: string): string {
+  return text
+    .replace(/<([^|>]+)\|([^>]+)>/g, '$2 ($1)')
+    .replace(/<([^>]+)>/g, '$1')
+    .replace(/[*_~`]/g, '');
+}

package/src/mrkdwn-to-markdown.ts

@@ -0,0 +1,29 @@
+/**
+ * Slack mrkdwn → 通用 Markdown（入站文本段）
+ */
+export function mrkdwnToMarkdown(text: string): string {
+  let result = replaceSlackLinks(text);
+  result = result.replace(/\*([^*]+)\*/g, '**$1**');
+  result = result.replace(/_([^_]+)_/g, '*$1*');
+  result = result.replace(/~([^~]+)~/g, '~~$1~~');
+  return result;
+}
+
+function replaceSlackLinks(text: string): string {
+  let out = '';
+  let cursor = 0;
+  while (cursor < text.length) {
+    const start = text.indexOf('<', cursor);
+    if (start < 0) break;
+    const end = text.indexOf('>', start + 1);
+    if (end < 0) break;
+    out += text.slice(cursor, start);
+    const body = text.slice(start + 1, end);
+    const sep = body.indexOf('|');
+    const url = sep >= 0 ? body.slice(0, sep) : body;
+    const label = sep >= 0 ? body.slice(sep + 1) : url;
+    out += url.startsWith('http://') || url.startsWith('https://') ? `[${label}](${url})` : text.slice(start, end + 1);
+    cursor = end + 1;
+  }
+  return out + text.slice(cursor);
+}

package/src/platform-permit.ts

@@ -1,8 +1,7 @@
 /**
  * Slack platform permit — workspace + channel 权限
  */
-import type { Message } from 'zhin.js';
-import { registerPlatformPermitChecker } from 'zhin.js';
+import { registerPlatformPermitChecker, type Message } from 'zhin.js';
 
 const ADAPTER = 'slack';
 

package/src/signing.ts

@@ -0,0 +1,28 @@
+/**
+ * Slack 请求签名验证 — HMAC-SHA256
+ * https://api.slack.com/authentication/verifying-requests-from-slack
+ */
+import { createHmac, timingSafeEqual } from 'node:crypto';
+
+const SLACK_VERSION = 'v0';
+const MAX_TIMESTAMP_DRIFT_SECONDS = 300;
+
+export function verifySlackSignature(
+  signingSecret: string,
+  rawBody: string,
+  timestamp: string,
+  signature: string,
+): boolean {
+  const now = Math.floor(Date.now() / 1000);
+  const ts = parseInt(timestamp, 10);
+  if (Number.isNaN(ts) || Math.abs(now - ts) > MAX_TIMESTAMP_DRIFT_SECONDS) {
+    return false;
+  }
+
+  const baseString = `${SLACK_VERSION}:${timestamp}:${rawBody}`;
+  const hmac = createHmac('sha256', signingSecret).update(baseString).digest('hex');
+  const expected = `${SLACK_VERSION}=${hmac}`;
+
+  if (expected.length !== signature.length) return false;
+  return timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
+}