@zhin.js/adapter-slack 4.1.0 → 4.1.1

package/src/index.ts

@@ -1,72 +1,68 @@
-/**
- * Slack 适配器入口：类型扩展、导出、注册
- */
-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 {
-  registerSlackPlatformPermitChecker,
-  slackGroupPermitResolver,
-} from './platform-permit.js';
-import { setSlackAgentDeps } from './slack-agent-deps.js';
-
-declare module 'zhin.js' {
-  interface Adapters {
-    slack: SlackAdapter;
-  }
-}
-
-export * from './types.js';
-export { SlackEndpoint } from './endpoint.js';
-export { SlackAdapter } from './adapter.js';
+export {
+  formatInboundContent,
+  formatInteractionContent,
+  formatOutboundWire,
+  formatSlashContent,
+  headerValue,
+  inboundMessageId,
+  keyboardToBlockKitBlocks,
+  normalizeWebhookPath,
+  readTextBody,
+  resolveSlackChannelType,
+  resolveSlackConfig,
+  verifySlackSignature,
+  type ResolvedSlackConfig,
+  type SlackAdapterConfig,
+  type SlackBlockAction,
+  type SlackEvent,
+  type SlackEventEnvelope,
+  type SlackInteractionPayload,
+  type SlackMessageEvent,
+  type SlackSlashCommand,
+  type SlackUrlVerification,
+  type SlackWireSegment,
+} from './protocol.js';
 
-const plugin = usePlugin();
-const { provide, useContext } = plugin;
+export {
+  SlackEndpoint,
+  type SlackEndpointOptions,
+  type SlackSocketLike,
+  type SlackWebClientLike,
+} from './endpoint.js';
 
-provide({
-  name: 'slack',
-  description: 'Slack Endpoint Adapter',
-  mounted: async (p: Plugin) => {
-    const adapter = new SlackAdapter(p);
-    await adapter.start();
-    return adapter;
-  },
-  dispose: async (adapter: SlackAdapter) => {
-    await adapter.stop();
-  },
-});
+export {
+  registerSlackWebhookRoutes,
+  handleSlackWebhookRequest,
+  type SlackWebhookHandler,
+} from './webhook.js';
 
-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 () => {};
-});
+export {
+  getSlackAgentDeps,
+  registerSlackAgentEndpoint,
+  setSlackAgentDeps,
+  type SlackAgentDeps,
+  type SlackAgentEndpoint,
+} from './slack-agent-deps.js';
 
-useContext('tool', 'slack', (toolService: ToolFeature, slack: SlackAdapter) => {
-  const disposers: (() => void)[] = [];
-  disposers.push(registerSlackPlatformPermitChecker());
-
-  function getEndpoint(endpointId: string) {
-    const endpoint = slack.endpoints.get(endpointId);
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} 不存在`);
-    return endpoint;
-  }
-
-  setSlackAgentDeps({ getEndpoint, getAdapter: () => slack });
+export {
+  checkSlackPlatformPermit,
+  normalizeSlackSenderForPermit,
+  platformPermit,
+  registerSlackPlatformPermitChecker,
+  slackGroupPermitResolver,
+} from './platform-permit.js';
 
-  const sceneTools = createSceneManagementTools(
-    slack as unknown as ISceneManagement,
-    'slack',
-    { permitResolver: slackGroupPermitResolver, registerChecker: false },
-  );
-  disposers.push(...sceneTools.map(t => toolService.addTool(t, plugin.name)));
+export {
+  formatSlackMessageRef,
+  parseSlackMessageRef,
+  slackMessageTs,
+} from './slack-message-ref.js';
 
-  return () => disposers.forEach(d => d());
-});
+export { normalizeSlackReactionName } from './slack-reaction.js';
+export { markdownToMrkdwn, mrkdwnToPlainFallback, splitMrkdwnText } from './markdown-to-mrkdwn.js';
+export { mrkdwnToMarkdown } from './mrkdwn-to-markdown.js';
+export {
+  createSlackInboundFilterState,
+  shouldDropSlackInboundMessage,
+} from './slack-inbound-filter.js';
+export { editSlackContent, sendSlackContent } from './slack-outbound.js';

package/src/markdown-to-mrkdwn.ts

@@ -51,8 +51,67 @@ export function splitMrkdwnText(text: string, maxLen = SLACK_MRKDWN_TEXT_MAX): s
 
 /** 通知栏 / 无障碍 fallback 用的纯文本 */
 export function mrkdwnToPlainFallback(text: string): string {
-  return text
-    .replace(/<([^|>]+)\|([^>]+)>/g, '$2 ($1)')
-    .replace(/<([^>]+)>/g, '$1')
-    .replace(/[*_~`]/g, '');
+  return stripMrkdwnMarkers(stripAngleBrackets(rewriteAngleLinks(text)));
+}
+
+/**
+ * `<url|text>` → `text (url)`。
+ * 线性扫描，语义等价于 `/<([^|>]+)\|([^>]+)>/g`（分组一不含 `|`，
+ * 因此切分点恒为首个 `|`），但避免量词重叠在超长 `<...` 输入上的
+ * 二次方回溯（js/polynomial-redos）。
+ */
+function rewriteAngleLinks(text: string): string {
+  let out = '';
+  let i = 0;
+  while (i < text.length) {
+    const open = text.indexOf('<', i);
+    if (open < 0) break;
+    const close = text.indexOf('>', open + 1);
+    if (close < 0) break;
+    const inner = text.slice(open + 1, close);
+    const pipe = inner.indexOf('|');
+    if (pipe > 0 && pipe < inner.length - 1) {
+      out += text.slice(i, open);
+      out += `${inner.slice(pipe + 1)} (${inner.slice(0, pipe)})`;
+      i = close + 1;
+      continue;
+    }
+    // 非链接形态：本趟不匹配，原样保留 `<` 并继续（与原正则行为一致）。
+    out += text.slice(i, open + 1);
+    i = open + 1;
+  }
+  return out + text.slice(i);
+}
+
+/**
+ * 剥掉剩余 `<...>` 的尖括号。线性扫描，等价于 `/<([^>]+)>/g`
+ * （空内容 `<>` 不匹配、原样保留）。
+ */
+function stripAngleBrackets(text: string): string {
+  let out = '';
+  let i = 0;
+  while (i < text.length) {
+    const open = text.indexOf('<', i);
+    if (open < 0) break;
+    const close = text.indexOf('>', open + 1);
+    if (close < 0) break;
+    if (close === open + 1) {
+      out += text.slice(i, open + 1);
+      i = open + 1;
+      continue;
+    }
+    out += text.slice(i, open);
+    out += text.slice(open + 1, close);
+    i = close + 1;
+  }
+  return out + text.slice(i);
+}
+
+/** 去掉 `*` `_` `~` `` ` `` 样式符号（等价于 `/[*_~`]/g`，逐字符线性）。 */
+function stripMrkdwnMarkers(text: string): string {
+  let out = '';
+  for (const ch of text) {
+    if (ch !== '*' && ch !== '_' && ch !== '~' && ch !== '`') out += ch;
+  }
+  return out;
 }

package/src/platform-permit.ts

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

package/src/protocol.ts

@@ -0,0 +1,380 @@
+/**
+ * Slack protocol helpers — no legacy Adapter/Endpoint / segment-mapper.
+ * Canonicalization is owned by gateway/core before endpoint.send.
+ */
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import type { IncomingMessage } from 'node:http';
+import { mrkdwnToMarkdown } from './mrkdwn-to-markdown.js';
+
+const SLACK_SIG_VERSION = 'v0';
+const MAX_TIMESTAMP_DRIFT_SECONDS = 300;
+
+/** Plugin Runtime owner config (`plugins.<instanceKey>` / schema.json). */
+export interface SlackAdapterConfig {
+  readonly name?: string;
+  readonly token?: string;
+  readonly signingSecret?: string;
+  readonly appToken?: string;
+  /** Default true (Socket Mode). Set false for HTTP Events API via httpHostToken. */
+  readonly socketMode?: boolean;
+  readonly webhookPath?: string;
+  readonly clientPingTimeout?: number;
+  /** Transitional: legacy root `endpoints[]` with `context: slack`. */
+  readonly endpoints?: ReadonlyArray<Partial<ResolvedSlackConfig> & {
+    readonly context?: string;
+    readonly socketMode?: boolean;
+    readonly signingSecret?: string;
+    readonly appToken?: string;
+    readonly webhookPath?: string;
+    readonly clientPingTimeout?: number;
+  }>;
+}
+
+export interface ResolvedSlackConfig {
+  readonly context: 'slack';
+  readonly name: string;
+  readonly token: string;
+  readonly mode: 'socket' | 'http';
+  readonly signingSecret: string;
+  readonly appToken?: string;
+  readonly webhookPath: string;
+  readonly clientPingTimeout: number;
+}
+
+export interface SlackEventEnvelope {
+  readonly token?: string;
+  readonly team_id?: string;
+  readonly api_app_id?: string;
+  readonly event: SlackEvent;
+  readonly type: 'event_callback';
+  readonly event_id?: string;
+  readonly event_time?: number;
+}
+
+export interface SlackUrlVerification {
+  readonly type: 'url_verification';
+  readonly token: string;
+  readonly challenge: string;
+}
+
+export interface SlackInteractionPayload {
+  readonly type: 'block_actions' | 'message_action' | 'shortcut' | 'view_submission' | 'view_closed';
+  readonly trigger_id?: string;
+  readonly user: { id: string; username?: string; name?: string; team_id?: string };
+  readonly channel?: { id: string; name?: string };
+  readonly message?: { ts: string; text?: string; [key: string]: unknown };
+  readonly actions?: SlackBlockAction[];
+  readonly response_url?: string;
+  readonly [key: string]: unknown;
+}
+
+export interface SlackBlockAction {
+  readonly type: string;
+  readonly action_id: string;
+  readonly block_id: string;
+  readonly value?: string;
+  readonly text?: { type: string; text: string };
+  readonly action_ts?: string;
+  readonly [key: string]: unknown;
+}
+
+export interface SlackSlashCommand {
+  readonly token: string;
+  readonly team_id: string;
+  readonly channel_id: string;
+  readonly channel_name: string;
+  readonly user_id: string;
+  readonly user_name: string;
+  readonly command: string;
+  readonly text: string;
+  readonly response_url: string;
+  readonly trigger_id: string;
+  readonly api_app_id?: string;
+}
+
+export interface SlackEvent {
+  readonly type: string;
+  readonly ts?: string;
+  readonly event_ts?: string;
+  readonly user?: string;
+  readonly channel?: string;
+  readonly channel_type?: string;
+  readonly text?: string;
+  readonly thread_ts?: string;
+  readonly subtype?: string;
+  readonly bot_id?: string;
+  readonly [key: string]: unknown;
+}
+
+export type SlackMessageEvent = SlackEvent & {
+  readonly type: 'message' | 'app_mention';
+  readonly ts: string;
+  readonly channel: string;
+};
+
+export interface SlackWireSegment {
+  readonly type: string;
+  readonly data?: Record<string, unknown>;
+}
+
+export function resolveSlackConfig(config: SlackAdapterConfig = {}): ResolvedSlackConfig {
+  const entry = config.endpoints?.find((item) => item.context === 'slack');
+  const token = config.token
+    ?? entry?.token
+    ?? process.env.SLACK_BOT_TOKEN
+    ?? process.env.SLACK_TOKEN;
+  if (!token) {
+    throw new TypeError(
+      'Slack adapter requires token (plugins.<key>.token or endpoints with context: slack)',
+    );
+  }
+
+  const name = (typeof config.name === 'string' && config.name)
+    || (typeof entry?.name === 'string' && entry.name)
+    || process.env.SLACK_BOT_NAME
+    || 'slack-bot';
+
+  const socketMode = config.socketMode ?? entry?.socketMode;
+  // Prefer Socket Mode (default true) — no public URL required.
+  const mode: 'socket' | 'http' = socketMode === false ? 'http' : 'socket';
+
+  const signingSecret = config.signingSecret
+    ?? entry?.signingSecret
+    ?? process.env.SLACK_SIGNING_SECRET
+    ?? '';
+  const appToken = config.appToken
+    ?? entry?.appToken
+    ?? process.env.SLACK_APP_TOKEN
+    ?? undefined;
+
+  if (mode === 'socket' && !appToken) {
+    throw new TypeError(
+      'Slack Socket Mode requires appToken (xapp-...); set socketMode: false for HTTP Events API',
+    );
+  }
+  if (mode === 'http' && !signingSecret) {
+    throw new TypeError(
+      'Slack HTTP Events API requires signingSecret',
+    );
+  }
+
+  return {
+    context: 'slack',
+    name,
+    token,
+    mode,
+    signingSecret,
+    appToken,
+    webhookPath: normalizeWebhookPath(
+      config.webhookPath ?? entry?.webhookPath ?? '/slack/events',
+    ),
+    clientPingTimeout: config.clientPingTimeout
+      ?? entry?.clientPingTimeout
+      ?? 15_000,
+  };
+}
+
+export function normalizeWebhookPath(path: string): string {
+  const trimmed = path.trim() || '/slack/events';
+  return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+}
+
+export function resolveSlackChannelType(event: Pick<SlackEvent, 'channel_type'>): 'private' | 'group' {
+  return event.channel_type === 'im' ? 'private' : 'group';
+}
+
+/** Build inbound text for MessageGateway.receive. */
+export function formatInboundContent(event: SlackMessageEvent | SlackEvent): string {
+  const text = typeof event.text === 'string' ? event.text : '';
+  if (text) return mrkdwnToMarkdown(text);
+  if ('files' in event && Array.isArray(event.files) && event.files.length > 0) {
+    return '[file]';
+  }
+  return '';
+}
+
+export function formatInteractionContent(payload: SlackInteractionPayload): string {
+  const action = payload.actions?.[0];
+  if (!action) return '[action]';
+  const label = action.text?.text ?? action.value ?? action.action_id;
+  return `[action: ${action.action_id}${label ? ` ${label}` : ''}]`;
+}
+
+export function formatSlashContent(cmd: SlackSlashCommand): string {
+  return `${cmd.command} ${cmd.text}`.trim();
+}
+
+export function inboundMessageId(event: SlackMessageEvent): string {
+  return `${event.channel}:${event.ts}`;
+}
+
+/**
+ * Wire-encode an already-rendered outbound payload into Slack text + Block Kit blocks.
+ * Segment canonicalization is intentionally not done here.
+ */
+export function formatOutboundWire(payload: unknown): {
+  text: string;
+  blocks: Record<string, unknown>[];
+  attachments: Record<string, unknown>[];
+  files: Array<{ buffer?: Buffer; url?: string; path?: string; name?: string }>;
+} {
+  if (typeof payload === 'string') {
+    return { text: payload, blocks: [], attachments: [], files: [] };
+  }
+
+  const items: Array<string | SlackWireSegment> = Array.isArray(payload)
+    ? payload as Array<string | SlackWireSegment>
+    : payload && typeof payload === 'object' && 'type' in (payload as object)
+      ? [payload as SlackWireSegment]
+      : [];
+
+  if (items.length === 0) {
+    const text = payload == null
+      ? ''
+      : typeof payload === 'object'
+        ? JSON.stringify(payload)
+        : String(payload);
+    return { text, blocks: [], attachments: [], files: [] };
+  }
+
+  let text = '';
+  const blocks: Record<string, unknown>[] = [];
+  const attachments: Record<string, unknown>[] = [];
+  const files: Array<{ buffer?: Buffer; url?: string; path?: string; name?: string }> = [];
+
+  for (const item of items) {
+    if (typeof item === 'string') {
+      text += item;
+      continue;
+    }
+    const data = item.data ?? {};
+    switch (item.type) {
+      case 'text':
+        text += String(data.text ?? data.content ?? '');
+        break;
+      case 'at':
+      case 'mention':
+        text += `<@${String(data.id ?? data.target ?? '')}>`;
+        break;
+      case 'channel_mention':
+        text += `<#${String(data.id ?? '')}>`;
+        break;
+      case 'link':
+        if (data.text && data.text !== data.url) {
+          text += `<${String(data.url)}|${String(data.text)}>`;
+        } else {
+          text += `<${String(data.url ?? '')}>`;
+        }
+        break;
+      case 'image':
+        if (typeof data.url === 'string' && data.url) {
+          attachments.push({
+            image_url: data.url,
+            title: String(data.name ?? data.title ?? ''),
+          });
+        } else if (data.media && typeof data.media === 'object') {
+          files.push(resolveMediaToFile(data.media as { kind: string; value: string }, String(data.alt ?? 'image')));
+        }
+        break;
+      case 'audio':
+      case 'video':
+      case 'file':
+        if (data.media && typeof data.media === 'object') {
+          files.push(resolveMediaToFile(data.media as { kind: string; value: string }, String(data.name ?? item.type)));
+        } else if (data.file || data.url) {
+          files.push({
+            path: typeof data.file === 'string' ? data.file : undefined,
+            url: typeof data.url === 'string' ? data.url : undefined,
+            name: String(data.name ?? item.type),
+          });
+        }
+        break;
+      case 'keyboard':
+        blocks.push(...keyboardToBlockKitBlocks(data));
+        break;
+      default:
+        text += String(data.text ?? `[${item.type}]`);
+    }
+  }
+
+  return { text, blocks, attachments, files };
+}
+
+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;
+}
+
+function resolveMediaToFile(
+  media: { kind: string; value: string },
+  name: string,
+): { buffer?: Buffer; url?: string; name: string } {
+  if (media.kind === 'base64') {
+    return { buffer: Buffer.from(media.value, 'base64'), name };
+  }
+  return { url: media.value, name };
+}
+
+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_SIG_VERSION}:${timestamp}:${rawBody}`;
+  const hmac = createHmac('sha256', signingSecret).update(baseString).digest('hex');
+  const expected = `${SLACK_SIG_VERSION}=${hmac}`;
+
+  if (expected.length !== signature.length) return false;
+  return timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
+}
+
+export async function readTextBody(
+  request: IncomingMessage,
+  options: { readonly limit?: number } = {},
+): Promise<string> {
+  const limit = options.limit ?? 1_048_576;
+  const chunks: Buffer[] = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > limit) {
+      request.destroy();
+      throw new Error(`Request body exceeds ${limit} bytes`);
+    }
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+export function headerValue(
+  headers: IncomingMessage['headers'],
+  name: string,
+): string {
+  const raw = headers[name.toLowerCase()];
+  if (Array.isArray(raw)) return raw[0] ?? '';
+  return raw ?? '';
+}

package/src/slack-agent-deps.ts

@@ -1,22 +1,57 @@
 /**
- * Shared runtime deps for slack agent/ authoring tools.
- * Set once from plugin index during init — never call getPlugin() from tool execute.
+ * Agent tool deps for slack.
+ * Endpoints register themselves on start; tools look up by config name / endpoint id.
  */
-import type { SlackAdapter } from './adapter.js';
-import type { SlackEndpoint } from './endpoint.js';
+
+export interface SlackAgentEndpoint {
+  inviteToChannel(channel: string, users: string[]): Promise<boolean>;
+  kickFromChannel(channel: string, user: string): Promise<boolean>;
+  setChannelTopic(channel: string, topic: string): Promise<boolean>;
+  setChannelPurpose(channel: string, purpose: string): Promise<boolean>;
+  archiveChannel(channel: string): Promise<boolean>;
+  unarchiveChannel(channel: string): Promise<boolean>;
+  renameChannel(channel: string, name: string): Promise<boolean>;
+  getChannelMembers(channel: string): Promise<string[]>;
+  getChannelInfo(channel: string): Promise<unknown>;
+  getUserInfo(user: string): Promise<unknown>;
+  addReaction(channel: string, timestamp: string, name: string): Promise<boolean>;
+  removeReaction(channel: string, timestamp: string, name: string): Promise<boolean>;
+  pinMessage(channel: string, timestamp: string): Promise<boolean>;
+  unpinMessage(channel: string, timestamp: string): Promise<boolean>;
+  editMessage(channel: string, messageTs: string, content: unknown): Promise<void>;
+}
 
 export interface SlackAgentDeps {
-  getEndpoint: (endpointId: string) => SlackEndpoint;
-  getAdapter: () => SlackAdapter;
+  getEndpoint: (endpointId: string) => SlackAgentEndpoint;
 }
 
-let _deps: SlackAgentDeps | null = null;
+const endpoints = new Map<string, SlackAgentEndpoint>();
+let override: SlackAgentDeps | null = null;
+
+export function registerSlackAgentEndpoint(
+  endpointId: string,
+  endpoint: SlackAgentEndpoint,
+): () => void {
+  endpoints.set(endpointId, endpoint);
+  return () => {
+    if (endpoints.get(endpointId) === endpoint) {
+      endpoints.delete(endpointId);
+    }
+  };
+}
 
-export function setSlackAgentDeps(deps: SlackAgentDeps): void {
-  _deps = deps;
+/** Optional override used by tests / transitional callers. Pass `null` to clear. */
+export function setSlackAgentDeps(deps: SlackAgentDeps | null): void {
+  override = deps;
 }
 
 export function getSlackAgentDeps(): SlackAgentDeps {
-  if (!_deps) throw new Error('slack agent deps not initialized');
-  return _deps;
+  if (override) return override;
+  return {
+    getEndpoint(endpointId: string): SlackAgentEndpoint {
+      const registered = endpoints.get(endpointId);
+      if (!registered) throw new Error(`Endpoint ${endpointId} 不存在`);
+      return registered;
+    },
+  };
 }

package/src/slack-inbound-filter.ts

@@ -1,4 +1,4 @@
-import type { SlackMessageEvent } from './types.js';
+import type { SlackMessageEvent } from './protocol.js';
 
 const DEDUPE_TTL_MS = 60_000;