@zhin.js/adapter-slack 4.0.1 → 4.1.0

package/src/slack-agent-deps.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared runtime deps for slack agent/ authoring tools.
+ * Set once from plugin index during init — never call getPlugin() from tool execute.
+ */
+import type { SlackAdapter } from './adapter.js';
+import type { SlackEndpoint } from './endpoint.js';
+
+export interface SlackAgentDeps {
+  getEndpoint: (endpointId: string) => SlackEndpoint;
+  getAdapter: () => SlackAdapter;
+}
+
+let _deps: SlackAgentDeps | null = null;
+
+export function setSlackAgentDeps(deps: SlackAgentDeps): void {
+  _deps = deps;
+}
+
+export function getSlackAgentDeps(): SlackAgentDeps {
+  if (!_deps) throw new Error('slack agent deps not initialized');
+  return _deps;
+}

package/src/slack-inbound-filter.ts

@@ -0,0 +1,60 @@
+import type { SlackMessageEvent } from './types.js';
+
+const DEDUPE_TTL_MS = 60_000;
+
+export interface SlackInboundFilterState {
+  seenInbound: Map<string, number>;
+}
+
+export function createSlackInboundFilterState(): SlackInboundFilterState {
+  return { seenInbound: new Map() };
+}
+
+function pruneSeen(state: SlackInboundFilterState, now: number): void {
+  if (state.seenInbound.size < 512) return;
+  for (const [key, at] of state.seenInbound) {
+    if (now - at > DEDUPE_TTL_MS) {
+      state.seenInbound.delete(key);
+    }
+  }
+}
+
+/**
+ * 过滤不应进入 IM 管道的 Slack 入站消息。
+ * - 跳过 Bot 自身消息
+ * - 频道内 @Bot：只保留 app_mention，丢弃重复的 message 事件
+ * - channel:ts 去重（message + app_mention 等同一条）
+ */
+export function shouldDropSlackInboundMessage(
+  event: SlackMessageEvent,
+  state: SlackInboundFilterState,
+  botUserId?: string,
+): boolean {
+  if (event.subtype === 'bot_message' || event.subtype === 'message_changed') {
+    return true;
+  }
+
+  if (event.bot_id) return true;
+  if (botUserId && event.user === botUserId) return true;
+
+  const channelType = event.channel_type ?? 'channel';
+  const text = event.text ?? '';
+
+  if (event.type === 'message' && channelType !== 'im' && botUserId) {
+    if (text.includes(`<@${botUserId}>`)) {
+      return true;
+    }
+  }
+
+  if (!event.channel || !event.ts) return true;
+
+  const key = `${event.channel}:${event.ts}`;
+  const now = Date.now();
+  const seenAt = state.seenInbound.get(key);
+  if (seenAt != null && now - seenAt < DEDUPE_TTL_MS) {
+    return true;
+  }
+  state.seenInbound.set(key, now);
+  pruneSeen(state, now);
+  return false;
+}

package/src/slack-inbound.ts

@@ -0,0 +1,140 @@
+/**
+ * Slack 入站消息解析 — 将 Slack mrkdwn 文本 + attachments + files 转为 wire segments
+ */
+import type { MessageSegment } from 'zhin.js';
+import type { SlackMessageEvent, SlackEvent } from './types.js';
+import { mrkdwnToMarkdown } from './mrkdwn-to-markdown.js';
+
+export function parseSlackMessageToSegments(msg: SlackMessageEvent): MessageSegment[] {
+  const segments: MessageSegment[] = [];
+
+  if (msg.text) {
+    segments.push(...parseSlackMrkdwn(msg.text));
+  }
+
+  if ('files' in msg && Array.isArray(msg.files)) {
+    for (const file of msg.files as Record<string, unknown>[]) {
+      segments.push(parseSlackFile(file));
+    }
+  }
+
+  if ('attachments' in msg && Array.isArray(msg.attachments)) {
+    for (const att of msg.attachments as Record<string, unknown>[]) {
+      if (att.image_url) {
+        segments.push({
+          type: 'image',
+          data: {
+            url: att.image_url,
+            title: att.title,
+            text: att.text,
+          },
+        });
+      }
+    }
+  }
+
+  return segments.length > 0 ? segments : [{ type: 'text', data: { text: '' } }];
+}
+
+function parseSlackFile(file: Record<string, unknown>): MessageSegment {
+  const mime = String(file.mimetype ?? '');
+  let type: string;
+  if (mime.startsWith('image/')) type = 'image';
+  else if (mime.startsWith('video/')) type = 'video';
+  else if (mime.startsWith('audio/')) type = 'audio';
+  else type = 'file';
+
+  return {
+    type,
+    data: {
+      id: file.id,
+      name: file.name,
+      url: file.url_private ?? file.permalink,
+      size: file.size,
+      mimetype: file.mimetype,
+    },
+  };
+}
+
+export function parseSlackMrkdwn(text: string): MessageSegment[] {
+  const segments: MessageSegment[] = [];
+  let lastIndex = 0;
+
+  for (const token of scanSlackTokens(text)) {
+    const start = token.start;
+    if (start > lastIndex) {
+      const before = text.slice(lastIndex, start);
+      if (before.trim()) {
+        segments.push({ type: 'text', data: { text: mrkdwnToMarkdown(before) } });
+      }
+    }
+
+    switch (token.kind) {
+      case 'user':
+        segments.push({ type: 'at', data: { id: token.id, name: token.label || token.id, text: token.raw } });
+        break;
+      case 'channel':
+        segments.push({ type: 'channel_mention', data: { id: token.id, name: token.label || token.id, text: token.raw } });
+        break;
+      case 'link':
+        segments.push({ type: 'link', data: { url: token.url, text: token.label || token.url } });
+        break;
+    }
+    lastIndex = start + token.raw.length;
+  }
+
+  if (lastIndex < text.length) {
+    const rest = text.slice(lastIndex);
+    if (rest.trim()) {
+      segments.push({ type: 'text', data: { text: mrkdwnToMarkdown(rest) } });
+    }
+  }
+
+  return segments.length > 0 ? segments : [{ type: 'text', data: { text: mrkdwnToMarkdown(text) } }];
+}
+
+type SlackToken =
+  | { kind: 'user' | 'channel'; start: number; raw: string; id: string; label?: string }
+  | { kind: 'link'; start: number; raw: string; url: string; label?: string };
+
+function scanSlackTokens(text: string): SlackToken[] {
+  const tokens: SlackToken[] = [];
+  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;
+    const raw = text.slice(start, end + 1);
+    const body = raw.slice(1, -1);
+    const sep = body.indexOf('|');
+    const head = sep >= 0 ? body.slice(0, sep) : body;
+    const label = sep >= 0 ? body.slice(sep + 1) : undefined;
+
+    if ((head.startsWith('@U') || head.startsWith('@W')) && isSlackId(head.slice(1))) {
+      tokens.push({ kind: 'user', start, raw, id: head.slice(1), label });
+    } else if (head.startsWith('#C') && isSlackId(head.slice(1))) {
+      tokens.push({ kind: 'channel', start, raw, id: head.slice(1), label });
+    } else if (head.startsWith('http://') || head.startsWith('https://')) {
+      tokens.push({ kind: 'link', start, raw, url: head, label });
+    }
+    cursor = end + 1;
+  }
+  return tokens;
+}
+
+function isSlackId(value: string): boolean {
+  if (!value) return false;
+  for (const ch of value) {
+    const code = ch.charCodeAt(0);
+    const isDigit = code >= 48 && code <= 57;
+    const isUpper = code >= 65 && code <= 90;
+    if (!isDigit && !isUpper) return false;
+  }
+  return true;
+}
+
+export function resolveSlackChannelType(event: SlackEvent): 'private' | 'group' {
+  if (event.channel_type === 'im') return 'private';
+  return 'group';
+}

package/src/slack-message-ref.ts

@@ -0,0 +1,18 @@
+/** Slack 消息定位：channel + ts（Activity Feedback / recall / reaction 共用） */
+
+export function formatSlackMessageRef(channel: string, ts: string): string {
+  return `${channel}:${ts}`;
+}
+
+export function parseSlackMessageRef(ref: string): { channel: string; ts: string } | null {
+  const sep = ref.indexOf(':');
+  if (sep <= 0) return null;
+  const channel = ref.slice(0, sep);
+  const ts = ref.slice(sep + 1);
+  if (!channel || !ts) return null;
+  return { channel, ts };
+}
+
+export function slackMessageTs(ref: string): string {
+  return parseSlackMessageRef(ref)?.ts ?? ref;
+}

package/src/slack-outbound.ts

@@ -0,0 +1,269 @@
+/**
+ * Slack 出站消息构造 — mrkdwn + Block Kit + files.uploadV2
+ */
+import type { WebClient } from '@slack/web-api';
+import type { MessageSegment, SendContent } from 'zhin.js';
+import type { Logger } from '@zhin.js/logger';
+import { markdownToMrkdwn, mrkdwnToPlainFallback, splitMrkdwnText } from './markdown-to-mrkdwn.js';
+
+export interface SlackOutboundResult {
+  ts: string;
+}
+
+export interface SlackSendOptions {
+  channel: string;
+  threadTs?: string;
+}
+
+const SLACK_MAX_BLOCKS_PER_MESSAGE = 48;
+
+export async function sendSlackContent(
+  client: WebClient,
+  content: SendContent,
+  opts: SlackSendOptions,
+  logger: Logger,
+): Promise<SlackOutboundResult> {
+  const segments = normalizeContent(content);
+  let textContent = '';
+  const blocks: Record<string, unknown>[] = [];
+  const attachments: Record<string, unknown>[] = [];
+  const pendingFiles: Array<{ buffer?: Buffer; url?: string; path?: string; name?: string }> = [];
+
+  for (const seg of segments) {
+    if (typeof seg === 'string') {
+      textContent += seg;
+      continue;
+    }
+    const { type, data } = seg as MessageSegment;
+    switch (type) {
+      case 'text':
+        textContent += data.text ?? '';
+        break;
+      case 'at':
+      case 'mention':
+        textContent += `<@${data.id ?? data.target}>`;
+        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 ?? '' });
+        } else if (data.media) {
+          pendingFiles.push(resolveMediaToFile(data.media, data.alt ?? 'image'));
+        }
+        break;
+      case 'audio':
+      case 'video':
+      case 'file':
+        if (data.media) {
+          pendingFiles.push(resolveMediaToFile(data.media, data.name ?? type));
+        } else if (data.file || data.url) {
+          pendingFiles.push({ path: data.file, url: data.url, name: data.name ?? type });
+        }
+        break;
+      case 'keyboard':
+        blocks.push(...keyboardToBlockKitBlocks(data));
+        break;
+      default:
+        textContent += data.text ?? `[${type}]`;
+    }
+  }
+
+  const textDelivery = applyTextMrkdwnBlocks(textContent, blocks);
+
+  for (const pf of pendingFiles) {
+    try {
+      await uploadFile(client, opts.channel, pf, opts.threadTs, logger);
+    } catch (e) {
+      logger.error('Failed to upload file:', e);
+    }
+  }
+
+  return postSlackMessage(client, {
+    channel: opts.channel,
+    threadTs: opts.threadTs,
+    blocks,
+    attachments,
+    fallbackText: textDelivery.fallbackText,
+  });
+}
+
+export async function editSlackContent(
+  client: WebClient,
+  channel: string,
+  ts: string,
+  content: SendContent,
+): Promise<void> {
+  const segments = normalizeContent(content);
+  let textContent = '';
+  const blocks: Record<string, unknown>[] = [];
+
+  for (const seg of segments) {
+    if (typeof seg === 'string') { textContent += seg; continue; }
+    const { type, data } = seg as MessageSegment;
+    switch (type) {
+      case 'text': textContent += data.text ?? ''; break;
+      case 'at': case 'mention': textContent += `<@${data.id ?? data.target}>`; break;
+      case 'channel_mention': textContent += `<#${data.id}>`; break;
+      case 'link':
+        textContent += data.text && data.text !== data.url ? `<${data.url}|${data.text}>` : `<${data.url}>`;
+        break;
+      case 'keyboard':
+        blocks.push(...keyboardToBlockKitBlocks(data));
+        break;
+      default: textContent += data.text ?? `[${type}]`;
+    }
+  }
+
+  const textDelivery = applyTextMrkdwnBlocks(textContent, blocks);
+  const payloadBlocks = blocks.slice(0, SLACK_MAX_BLOCKS_PER_MESSAGE);
+
+  const updateOpts: Record<string, unknown> = {
+    channel,
+    ts,
+    text: textDelivery.fallbackText || ' ',
+  };
+  if (payloadBlocks.length > 0) updateOpts.blocks = payloadBlocks;
+  await client.chat.update(updateOpts as any);
+}
+
+function normalizeContent(content: SendContent): Array<string | MessageSegment> {
+  if (typeof content === 'string') return [content];
+  if (!Array.isArray(content)) return [content as MessageSegment];
+  return content as Array<string | MessageSegment>;
+}
+
+function applyTextMrkdwnBlocks(
+  textContent: string,
+  blocks: Record<string, unknown>[],
+): { fallbackText: string } {
+  const trimmed = textContent.trim();
+  if (!trimmed) return { fallbackText: '' };
+
+  const mrkdwn = markdownToMrkdwn(trimmed);
+  const sections = splitMrkdwnText(mrkdwn).map((chunk) => ({
+    type: 'section',
+    text: { type: 'mrkdwn', text: chunk },
+  }));
+
+  if (blocks.length > 0) {
+    blocks.unshift(...sections);
+    return { fallbackText: '' };
+  }
+  blocks.push(...sections);
+  return { fallbackText: mrkdwnToPlainFallback(mrkdwn) };
+}
+
+async function postSlackMessage(
+  client: WebClient,
+  opts: {
+    channel: string;
+    threadTs?: string;
+    blocks: Record<string, unknown>[];
+    attachments: Record<string, unknown>[];
+    fallbackText: string;
+  },
+): Promise<SlackOutboundResult> {
+  const { channel, blocks, attachments, fallbackText } = opts;
+  let threadTs = opts.threadTs;
+  let firstTs = '';
+
+  if (blocks.length === 0) {
+    const result = await client.chat.postMessage({
+      channel,
+      text: fallbackText || 'Message',
+      ...(threadTs ? { thread_ts: threadTs } : {}),
+      ...(attachments.length > 0 ? { attachments } : {}),
+    } as any);
+    return { ts: (result as any).ts ?? '' };
+  }
+
+  for (let offset = 0; offset < blocks.length; offset += SLACK_MAX_BLOCKS_PER_MESSAGE) {
+    const chunk = blocks.slice(offset, offset + SLACK_MAX_BLOCKS_PER_MESSAGE);
+    const result = await client.chat.postMessage({
+      channel,
+      text: offset === 0 ? (fallbackText || ' ') : ' ',
+      blocks: chunk,
+      ...(threadTs ? { thread_ts: threadTs } : {}),
+      ...(offset === 0 && attachments.length > 0 ? { attachments } : {}),
+    } as any);
+    const ts = (result as any).ts ?? '';
+    if (!firstTs) firstTs = ts;
+    if (!threadTs) threadTs = ts;
+  }
+
+  return { ts: firstTs };
+}
+
+function resolveMediaToFile(
+  media: { kind: string; value: string; mime_type?: string },
+  name: string,
+): { buffer?: Buffer; url?: string; name: string } {
+  if (media.kind === 'base64') {
+    return { buffer: Buffer.from(media.value, 'base64'), name };
+  }
+  if (media.kind === 'url') {
+    return { url: media.value, name };
+  }
+  return { url: media.value, name };
+}
+
+/** 每行 keyboard → 独立 actions block（Slack 每 block 最多 5 个按钮） */
+export function keyboardToBlockKitBlocks(data: Record<string, unknown>): Record<string, unknown>[] {
+  const rows = data.rows as Array<Array<Record<string, unknown>>> | undefined;
+  if (!rows?.length) return [];
+
+  const blocks: Record<string, unknown>[] = [];
+  for (const row of rows) {
+    const elements = row.slice(0, 5).map((btn, index) => ({
+      type: 'button',
+      text: { type: 'plain_text', text: String(btn.label ?? btn.text ?? 'button').slice(0, 75) },
+      action_id: String(btn.id ?? btn.action_id ?? `btn_${blocks.length}_${index}`),
+      ...(btn.value != null ? { value: String(btn.value) } : {}),
+      ...(btn.style === 'primary' ? { style: 'primary' } : {}),
+      ...(btn.style === 'danger' ? { style: 'danger' } : {}),
+    }));
+    if (elements.length > 0) {
+      blocks.push({ type: 'actions', elements });
+    }
+  }
+  return blocks;
+}
+
+async function uploadFile(
+  client: WebClient,
+  channel: string,
+  file: { buffer?: Buffer; url?: string; path?: string; name?: string },
+  threadTs?: string,
+  logger?: Logger,
+): Promise<void> {
+  try {
+    let buffer = file.buffer;
+    if (!buffer && file.path) {
+      const { readFile } = await import('node:fs/promises');
+      buffer = await readFile(file.path);
+    }
+    if (!buffer && file.url) {
+      const res = await fetch(file.url);
+      if (!res.ok) throw new Error(`fetch ${file.url}: ${res.status}`);
+      buffer = Buffer.from(await res.arrayBuffer());
+    }
+    if (!buffer) return;
+
+    await client.filesUploadV2(
+      threadTs
+        ? { channel_id: channel, file: buffer, filename: file.name ?? 'file', thread_ts: threadTs }
+        : { channel_id: channel, file: buffer, filename: file.name ?? 'file' },
+    );
+  } catch (e) {
+    logger?.error('File upload failed:', e);
+  }
+}

package/src/slack-reaction.ts

@@ -0,0 +1,23 @@
+/** 将 activity-feedback / 工具入参规范为 Slack reactions.add 的 name（不含冒号） */
+const UNICODE_TO_SLACK: Record<string, string> = {
+  '⏳': 'hourglass_flowing_sand',
+  '✅': 'white_check_mark',
+  '❌': 'x',
+  '⏰': 'alarm_clock',
+  '🤔': 'thinking_face',
+  '👀': 'eyes',
+};
+
+export function normalizeSlackReactionName(emoji: string): string {
+  const trimmed = emoji.trim();
+  if (!trimmed) return 'hourglass_flowing_sand';
+  if (UNICODE_TO_SLACK[trimmed]) return UNICODE_TO_SLACK[trimmed]!;
+  if (trimmed.startsWith(':') && trimmed.endsWith(':') && trimmed.length > 2) {
+    return trimmed.slice(1, -1);
+  }
+  let start = 0;
+  let end = trimmed.length;
+  while (start < end && trimmed[start] === ':') start++;
+  while (end > start && trimmed[end - 1] === ':') end--;
+  return trimmed.slice(start, end);
+}

package/src/slack-response-url.ts

@@ -0,0 +1,26 @@
+/**
+ * Slack response_url 即时 ephemeral 反馈（斜杠命令 / 按钮交互）
+ */
+import type { Logger } from '@zhin.js/logger';
+
+export function postSlackEphemeral(
+  responseUrl: string,
+  text: string,
+  logger?: Logger,
+): void {
+  if (!responseUrl?.trim()) return;
+
+  const body = JSON.stringify({
+    response_type: 'ephemeral',
+    text,
+    replace_original: false,
+  });
+
+  fetch(responseUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body,
+  }).catch((err) => {
+    logger?.debug(`Slack response_url failed: ${err instanceof Error ? err.message : String(err)}`);
+  });
+}

package/src/slack-side-events.ts

@@ -0,0 +1,74 @@
+/**
+ * Slack 事件 → zhin Notice 映射
+ */
+import { mapNoticeParts, buildNotice, senderFromId } from 'zhin.js';
+import type { SlackEvent } from './types.js';
+
+export function isSlackNoticeEvent(eventType: string): boolean {
+  return SLACK_NOTICE_EVENT_TYPES.has(eventType);
+}
+
+const SLACK_NOTICE_EVENT_TYPES = new Set([
+  'member_joined_channel',
+  'member_left_channel',
+  'reaction_added',
+  'reaction_removed',
+  'message_deleted',
+  'channel_archive',
+  'channel_unarchive',
+  'channel_rename',
+  'channel_created',
+  'channel_deleted',
+  'pin_added',
+  'pin_removed',
+  'app_home_opened',
+  'team_join',
+]);
+
+export function formatSlackNotice(
+  event: SlackEvent,
+  endpointName: string,
+) {
+  const eventType = event.type;
+  const { scene_type, sub_type } = mapNoticeParts('slack', eventType);
+
+  const channelId = resolveNoticeChannelId(event);
+  const ts = event.event_ts
+    ? parseFloat(event.event_ts) * 1000
+    : Date.now();
+
+  const actorId = event.user ?? (event as any).inviter;
+  const targetId =
+    (event as any).item_user ??
+    (event as any).user ??
+    undefined;
+
+  return buildNotice(event, {
+    $id: resolveSlackSideEventDedupeKey(event),
+    $adapter: 'slack',
+    $endpoint: endpointName,
+    $type: 'notice',
+    $scene_id: channelId,
+    $scene_type: scene_type,
+    $sub_type: sub_type,
+    $actor: senderFromId(actorId),
+    $target: actorId !== targetId ? senderFromId(targetId) : undefined,
+    $timestamp: ts,
+  });
+}
+
+export function resolveSlackSideEventDedupeKey(event: SlackEvent): string {
+  const ts = event.event_ts ?? event.ts ?? '';
+  const type = event.type;
+  const channel = event.channel ?? '';
+  const user = event.user ?? '';
+  return `slack:${ts}_${type}_${channel}_${user}`;
+}
+
+function resolveNoticeChannelId(event: SlackEvent): string {
+  if (event.channel) return String(event.channel);
+  const item = (event as any).item;
+  if (item?.channel) return String(item.channel);
+  const channel = (event as any).channel_id ?? (event as any).channel?.id;
+  return channel ? String(channel) : '';
+}