@zhin.js/adapter-slack 1.1.18 → 1.1.20

package/src/index.ts

@@ -37,7 +37,6 @@ export {
 } from './webhook.js';
 
 export {
-  slackClient,
   type SlackClientEventMap,
   type SlackUserInfo,
 } from './client.js';
@@ -57,3 +56,4 @@ export {
   shouldDropSlackInboundMessage,
 } from './slack-inbound-filter.js';
 export { editSlackContent, sendSlackContent } from './slack-outbound.js';
+export { SlackAdapter } from './adapter.js';

package/src/protocol.ts

@@ -121,6 +121,9 @@ export interface SlackWireSegment {
   readonly data?: Record<string, unknown>;
 }
 
+/** Every block emitted by the encoder has Slack's required native block discriminator. */
+export interface SlackBlock { readonly type: string; readonly block_id?: string; readonly [key: string]: unknown }
+
 export function resolveSlackConfig(config: SlackEndpointConfig): ResolvedSlackConfig {
   if (config.webApiProxy && (!Number.isInteger(config.webApiProxy.port) || config.webApiProxy.port < 1 || config.webApiProxy.port > 65535)) throw new TypeError('Invalid Slack webApiProxy port');
   if (config.streamProxy && (!Number.isInteger(config.streamProxy.port) || config.streamProxy.port < 1 || config.streamProxy.port > 65535
@@ -225,7 +228,7 @@ export function formatSlashContent(cmd: SlackSlashCommand): string {
 export function formatOutboundWire(payload: unknown): {
   replyTo?: string;
   text: string;
-  blocks: Record<string, unknown>[];
+  blocks: SlackBlock[];
   attachments: Record<string, unknown>[];
   files: Array<{ buffer?: Buffer; url?: string; path?: string; name?: string }>;
 } {
@@ -249,7 +252,7 @@ export function formatOutboundWire(payload: unknown): {
   }
 
   let text = '';
-  const blocks: Record<string, unknown>[] = [];
+  const blocks: SlackBlock[] = [];
   const attachments: Record<string, unknown>[] = [];
   const files: Array<{ buffer?: Buffer; url?: string; path?: string; name?: string }> = [];
   let replyTo: string | undefined;
@@ -328,11 +331,11 @@ export function formatOutboundWire(payload: unknown): {
   return { text, blocks, attachments, files, ...(replyTo ? { replyTo } : {}) };
 }
 
-export function keyboardToBlockKitBlocks(data: Record<string, unknown>): Record<string, unknown>[] {
+export function keyboardToBlockKitBlocks(data: Record<string, unknown>): SlackBlock[] {
   const rows = data.rows as Array<Array<Record<string, unknown>>> | undefined;
   if (!rows?.length) return [];
 
-  const blocks: Record<string, unknown>[] = [];
+  const blocks: SlackBlock[] = [];
   for (const row of rows) {
     const elements = row.slice(0, 5).map((btn, index) => ({
       type: 'button',

package/src/slack-outbound.ts

@@ -1,9 +1,11 @@
 /**
  * Slack outbound — chat.postMessage + Block Kit + files.uploadV2
  */
+import { createEndpointOperation, type EndpointOperation } from 'zhin.js/adapter';
 import type { Logger } from '@zhin.js/logger';
+import type { WebClient } from '@slack/web-api';
 import { markdownToMrkdwn, mrkdwnToPlainFallback, splitMrkdwnText } from './markdown-to-mrkdwn.js';
-import { formatOutboundWire, keyboardToBlockKitBlocks } from './protocol.js';
+import { formatOutboundWire, keyboardToBlockKitBlocks, type SlackBlock } from './protocol.js';
 
 export interface SlackOutboundResult {
   ts: string;
@@ -15,21 +17,28 @@ export interface SlackSendOptions {
 }
 
 export interface SlackChatClient {
-  chat: {
-    postMessage(opts: Record<string, unknown>): Promise<{ ts?: string }>;
-    update(opts: Record<string, unknown>): Promise<unknown>;
-  };
-  filesUploadV2?(opts: Record<string, unknown>): Promise<unknown>;
+  chat: Pick<WebClient['chat'], 'postMessage' | 'update'>;
+  filesUploadV2?: WebClient['filesUploadV2'];
 }
 
 const SLACK_MAX_BLOCKS_PER_MESSAGE = 48;
 
+export interface SlackContentRequest extends SlackSendOptions {
+  readonly content: unknown;
+  readonly logger: Logger;
+  readonly signal?: AbortSignal;
+}
+export interface SlackEditRequest {
+  readonly channel: string;
+  readonly ts: string;
+  readonly content: unknown;
+  readonly signal?: AbortSignal;
+}
 export async function sendSlackContent(
   client: SlackChatClient,
-  content: unknown,
-  opts: SlackSendOptions,
-  logger: Logger,
+  { content, logger, signal, ...opts }: SlackContentRequest,
 ): Promise<SlackOutboundResult> {
+  const operation = createEndpointOperation({ signal });
   const wire = formatOutboundWire(content);
   const threadTs = opts.threadTs ?? wire.replyTo;
   const blocks = [...wire.blocks];
@@ -37,7 +46,7 @@ export async function sendSlackContent(
 
   for (const pf of wire.files) {
     try {
-      await uploadFile(client, opts.channel, pf, threadTs);
+      await uploadFile(client, { channel: opts.channel, file: pf, threadTs, operation });
     } catch (e) {
       logger.error('Failed to upload file:', e);
       throw e;
@@ -47,6 +56,7 @@ export async function sendSlackContent(
   return postSlackMessage(client, {
     channel: opts.channel,
     threadTs,
+    operation,
     blocks,
     attachments: wire.attachments,
     fallbackText: textDelivery.fallbackText,
@@ -55,27 +65,25 @@ export async function sendSlackContent(
 
 export async function editSlackContent(
   client: SlackChatClient,
-  channel: string,
-  ts: string,
-  content: unknown,
+  { channel, ts, content, signal }: SlackEditRequest,
 ): Promise<void> {
   const wire = formatOutboundWire(content);
   const blocks = [...wire.blocks];
   const textDelivery = applyTextMrkdwnBlocks(wire.text, blocks);
   const payloadBlocks = blocks.slice(0, SLACK_MAX_BLOCKS_PER_MESSAGE);
 
-  const updateOpts: Record<string, unknown> = {
+  const updateOpts: { channel: string; ts: string; text: string; blocks?: SlackBlock[] } = {
     channel,
     ts,
     text: textDelivery.fallbackText || ' ',
   };
   if (payloadBlocks.length > 0) updateOpts.blocks = payloadBlocks;
-  await client.chat.update(updateOpts);
+  await createEndpointOperation({ signal }).run(() => client.chat.update(updateOpts));
 }
 
 function applyTextMrkdwnBlocks(
   textContent: string,
-  blocks: Record<string, unknown>[],
+  blocks: SlackBlock[],
 ): { fallbackText: string } {
   const trimmed = textContent.trim();
   if (!trimmed) return { fallbackText: '' };
@@ -99,34 +107,35 @@ async function postSlackMessage(
   opts: {
     channel: string;
     threadTs?: string;
-    blocks: Record<string, unknown>[];
+    operation: EndpointOperation;
+    blocks: SlackBlock[];
     attachments: Record<string, unknown>[];
     fallbackText: string;
   },
 ): Promise<SlackOutboundResult> {
-  const { channel, blocks, attachments, fallbackText } = opts;
+  const { channel, blocks, attachments, fallbackText, operation } = opts;
   let threadTs = opts.threadTs;
   let firstTs = '';
 
   if (blocks.length === 0) {
-    const result = await client.chat.postMessage({
+    const result = await operation.run(() => client.chat.postMessage({
       channel,
       text: fallbackText || 'Message',
       ...(threadTs ? { thread_ts: threadTs } : {}),
       ...(attachments.length > 0 ? { attachments } : {}),
-    });
+    }));
     return { ts: requireMessageTimestamp(result) };
   }
 
   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({
+    const result = await operation.run(() => client.chat.postMessage({
       channel,
       text: offset === 0 ? (fallbackText || ' ') : ' ',
       blocks: chunk,
       ...(threadTs ? { thread_ts: threadTs } : {}),
       ...(offset === 0 && attachments.length > 0 ? { attachments } : {}),
-    });
+    }));
     const ts = requireMessageTimestamp(result);
     if (!firstTs) firstTs = ts;
     if (!threadTs) threadTs = ts;
@@ -144,28 +153,32 @@ function requireMessageTimestamp(result: { ts?: string } | null | undefined): st
 
 async function uploadFile(
   client: SlackChatClient,
-  channel: string,
-  file: { buffer?: Buffer; url?: string; path?: string; name?: string },
-  threadTs?: string,
+  { channel, file, threadTs, operation }: {
+    readonly channel: string;
+    readonly file: { buffer?: Buffer; url?: string; path?: string; name?: string };
+    readonly threadTs?: string;
+    readonly operation: EndpointOperation;
+  },
 ): Promise<void> {
-  if (!client.filesUploadV2) throw new Error('Slack client does not support file uploads');
+  const upload = client.filesUploadV2;
+  if (!upload) throw new Error('Slack client does not support file uploads');
+  const { path, url } = file;
   let buffer = file.buffer;
-  if (!buffer && file.path) {
-    const { readFile } = await import('node:fs/promises');
-    buffer = await readFile(file.path);
+  if (!buffer && path) {
+    const { readFile } = await operation.prepare(() => import('node:fs/promises'));
+    buffer = await operation.prepare(() => readFile(path));
   }
-  if (!buffer && file.url) {
-    const res = await fetch(file.url);
+  if (!buffer && url) {
+    const res = await operation.prepare(() => fetch(url, { signal: operation.signal }));
     if (!res.ok) throw new Error(`fetch ${file.url}: ${res.status}`);
-    buffer = Buffer.from(await res.arrayBuffer());
+    buffer = Buffer.from(await operation.prepare(() => res.arrayBuffer()));
   }
   if (!buffer) throw new Error('Slack file contains no uploadable content');
 
-  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' },
-  );
+  const options: Parameters<typeof upload>[0] = threadTs
+    ? { channel_id: channel, file: buffer, filename: file.name ?? 'file', thread_ts: threadTs }
+    : { channel_id: channel, file: buffer, filename: file.name ?? 'file' };
+  await operation.run(() => upload.call(client, options));
 }
 
 export { keyboardToBlockKitBlocks };

package/src/web-client.ts

@@ -3,7 +3,11 @@ import { EndpointDeliveryError } from '@zhin.js/im-contract';
 
 /** A non-idempotent outbound API call gets exactly one transport attempt. */
 export function createSlackWebClient(token: string, options: WebClientOptions = {}): WebClient {
-  return new WebClient(token, { ...options, retryConfig: { retries: 0 }, rejectRateLimitedCalls: true });
+  return new WebClient(token, slackWebClientOptions(options));
+}
+
+export function slackWebClientOptions(options: WebClientOptions = {}): WebClientOptions {
+  return { ...options, retryConfig: { retries: 0 }, rejectRateLimitedCalls: true };
 }
 
 export function slackDeliveryError(error: unknown): EndpointDeliveryError {

package/lib/slack-runtime-state.d.ts

@@ -1 +0,0 @@
-export declare const slackRuntimeStateToken: import("zhin.js").Token<import("@zhin.js/adapter").EndpointRuntimeState>;

package/lib/slack-runtime-state.js

@@ -1,6 +0,0 @@
-/**
- * Slack 插件实例的运行时状态：adapter create() 注册的 endpoint 列表。
- * 由 plugin.ts setup() provide，adapter create 与 `slack endpoint` 命令共享（同一 owner generation）。
- */
-import { defineEndpointRuntimeStateToken } from 'zhin.js/adapter';
-export const slackRuntimeStateToken = defineEndpointRuntimeStateToken('slack');

package/src/slack-runtime-state.ts

@@ -1,7 +0,0 @@
-/**
- * Slack 插件实例的运行时状态：adapter create() 注册的 endpoint 列表。
- * 由 plugin.ts setup() provide，adapter create 与 `slack endpoint` 命令共享（同一 owner generation）。
- */
-import { defineEndpointRuntimeStateToken } from 'zhin.js/adapter';
-
-export const slackRuntimeStateToken = defineEndpointRuntimeStateToken('slack');