@zhin.js/adapter-slack 1.1.18 → 1.1.20

package/lib/protocol.d.ts

@@ -109,6 +109,12 @@ export interface SlackWireSegment {
     readonly type: string;
     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 declare function resolveSlackConfig(config: SlackEndpointConfig): ResolvedSlackConfig;
 export declare function normalizeWebhookPath(path: string): string;
 export declare function resolveSlackChannelType(event: Pick<SlackEvent, 'channel_type'>): 'private' | 'group';
@@ -133,7 +139,7 @@ export declare function formatSlashContent(cmd: SlackSlashCommand): string;
 export declare function formatOutboundWire(payload: unknown): {
     replyTo?: string;
     text: string;
-    blocks: Record<string, unknown>[];
+    blocks: SlackBlock[];
     attachments: Record<string, unknown>[];
     files: Array<{
         buffer?: Buffer;
@@ -142,7 +148,7 @@ export declare function formatOutboundWire(payload: unknown): {
         name?: string;
     }>;
 };
-export declare function keyboardToBlockKitBlocks(data: Record<string, unknown>): Record<string, unknown>[];
+export declare function keyboardToBlockKitBlocks(data: Record<string, unknown>): SlackBlock[];
 export declare function verifySlackSignature(signingSecret: string, rawBody: string, timestamp: string, signature: string): boolean;
 export declare function readTextBody(request: IncomingMessage, options?: {
     readonly limit?: number;

package/lib/slack-outbound.d.ts

@@ -1,7 +1,5 @@
-/**
- * Slack outbound — chat.postMessage + Block Kit + files.uploadV2
- */
 import type { Logger } from '@zhin.js/logger';
+import type { WebClient } from '@slack/web-api';
 import { keyboardToBlockKitBlocks } from './protocol.js';
 export interface SlackOutboundResult {
     ts: string;
@@ -11,14 +9,20 @@ export interface SlackSendOptions {
     threadTs?: string;
 }
 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'];
 }
-export declare function sendSlackContent(client: SlackChatClient, content: unknown, opts: SlackSendOptions, logger: Logger): Promise<SlackOutboundResult>;
-export declare function editSlackContent(client: SlackChatClient, channel: string, ts: string, content: unknown): Promise<void>;
+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 declare function sendSlackContent(client: SlackChatClient, { content, logger, signal, ...opts }: SlackContentRequest): Promise<SlackOutboundResult>;
+export declare function editSlackContent(client: SlackChatClient, { channel, ts, content, signal }: SlackEditRequest): Promise<void>;
 export { keyboardToBlockKitBlocks };

package/lib/slack-outbound.js

@@ -1,14 +1,19 @@
+/**
+ * Slack outbound — chat.postMessage + Block Kit + files.uploadV2
+ */
+import { createEndpointOperation } from 'zhin.js/adapter';
 import { markdownToMrkdwn, mrkdwnToPlainFallback, splitMrkdwnText } from './markdown-to-mrkdwn.js';
 import { formatOutboundWire, keyboardToBlockKitBlocks } from './protocol.js';
 const SLACK_MAX_BLOCKS_PER_MESSAGE = 48;
-export async function sendSlackContent(client, content, opts, logger) {
+export async function sendSlackContent(client, { content, logger, signal, ...opts }) {
+    const operation = createEndpointOperation({ signal });
     const wire = formatOutboundWire(content);
     const threadTs = opts.threadTs ?? wire.replyTo;
     const blocks = [...wire.blocks];
     const textDelivery = applyTextMrkdwnBlocks(wire.text, blocks);
     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);
@@ -18,12 +23,13 @@ export async function sendSlackContent(client, content, opts, logger) {
     return postSlackMessage(client, {
         channel: opts.channel,
         threadTs,
+        operation,
         blocks,
         attachments: wire.attachments,
         fallbackText: textDelivery.fallbackText,
     });
 }
-export async function editSlackContent(client, channel, ts, content) {
+export async function editSlackContent(client, { channel, ts, content, signal }) {
     const wire = formatOutboundWire(content);
     const blocks = [...wire.blocks];
     const textDelivery = applyTextMrkdwnBlocks(wire.text, blocks);
@@ -35,7 +41,7 @@ export async function editSlackContent(client, channel, ts, content) {
     };
     if (payloadBlocks.length > 0)
         updateOpts.blocks = payloadBlocks;
-    await client.chat.update(updateOpts);
+    await createEndpointOperation({ signal }).run(() => client.chat.update(updateOpts));
 }
 function applyTextMrkdwnBlocks(textContent, blocks) {
     const trimmed = textContent.trim();
@@ -54,27 +60,27 @@ function applyTextMrkdwnBlocks(textContent, blocks) {
     return { fallbackText: mrkdwnToPlainFallback(mrkdwn) };
 }
 async function postSlackMessage(client, opts) {
-    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;
@@ -89,24 +95,27 @@ function requireMessageTimestamp(result) {
     }
     return result.ts;
 }
-async function uploadFile(client, channel, file, threadTs) {
-    if (!client.filesUploadV2)
+async function uploadFile(client, { channel, file, threadTs, operation }) {
+    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
+    const options = threadTs
         ? { channel_id: channel, file: buffer, filename: file.name ?? 'file', thread_ts: threadTs }
-        : { channel_id: channel, file: buffer, filename: file.name ?? 'file' });
+        : { channel_id: channel, file: buffer, filename: file.name ?? 'file' };
+    await operation.run(() => upload.call(client, options));
 }
 export { keyboardToBlockKitBlocks };

package/lib/web-client.d.ts

@@ -2,4 +2,5 @@ import { WebClient, type WebClientOptions } from '@slack/web-api';
 import { EndpointDeliveryError } from '@zhin.js/im-contract';
 /** A non-idempotent outbound API call gets exactly one transport attempt. */
 export declare function createSlackWebClient(token: string, options?: WebClientOptions): WebClient;
+export declare function slackWebClientOptions(options?: WebClientOptions): WebClientOptions;
 export declare function slackDeliveryError(error: unknown): EndpointDeliveryError;

package/lib/web-client.js

@@ -2,7 +2,10 @@ import { WebClient, ErrorCode } from '@slack/web-api';
 import { EndpointDeliveryError } from '@zhin.js/im-contract';
 /** A non-idempotent outbound API call gets exactly one transport attempt. */
 export function createSlackWebClient(token, options = {}) {
-    return new WebClient(token, { ...options, retryConfig: { retries: 0 }, rejectRateLimitedCalls: true });
+    return new WebClient(token, slackWebClientOptions(options));
+}
+export function slackWebClientOptions(options = {}) {
+    return { ...options, retryConfig: { retries: 0 }, rejectRateLimitedCalls: true };
 }
 export function slackDeliveryError(error) {
     if (error instanceof EndpointDeliveryError)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/adapter-slack",
-  "version": "1.1.18",
+  "version": "1.1.20",
   "description": "Zhin.js Slack adapter for Plugin Runtime (Socket Mode / HTTP Events)",
   "type": "module",
   "main": "./lib/index.js",
@@ -33,27 +33,27 @@
   "dependencies": {
     "@slack/socket-mode": "^2.0.7",
     "@slack/web-api": "^7.19.0",
-    "@zhin.js/adapter": "1.1.25",
-    "@zhin.js/agent-feature": "1.1.10",
-    "@zhin.js/client": "1.1.21",
+    "@zhin.js/adapter": "1.1.26",
+    "@zhin.js/agent-feature": "1.1.11",
+    "@zhin.js/client": "1.1.22",
     "@zhin.js/console-contract": "1.1.3",
-    "@zhin.js/core": "1.1.53",
-    "@zhin.js/feature-kit": "1.1.9",
-    "@zhin.js/host-http": "1.1.11",
+    "@zhin.js/core": "1.1.54",
+    "@zhin.js/feature-kit": "1.1.10",
+    "@zhin.js/host-http": "1.1.12",
     "@zhin.js/im-contract": "1.1.9",
     "@zhin.js/logger": "1.1.2",
-    "@zhin.js/page": "1.1.10",
-    "@zhin.js/skill": "1.1.10",
-    "@zhin.js/tool": "1.1.12"
+    "@zhin.js/page": "1.1.12",
+    "@zhin.js/skill": "1.1.11",
+    "@zhin.js/tool": "1.1.13"
   },
   "peerDependencies": {
     "zod": "^4.0.0",
-    "@zhin.js/adapter": "^1.1.25",
-    "@zhin.js/command": "^1.1.11",
-    "@zhin.js/core": "^1.1.53",
-    "@zhin.js/host-http": "^1.1.11",
-    "@zhin.js/permission": "^1.1.9",
-    "zhin.js": "^1.1.18"
+    "@zhin.js/adapter": "^1.1.26",
+    "@zhin.js/command": "^1.1.12",
+    "@zhin.js/core": "^1.1.54",
+    "@zhin.js/host-http": "^1.1.12",
+    "@zhin.js/permission": "^1.1.10",
+    "zhin.js": "^1.1.19"
   },
   "peerDependenciesMeta": {
     "@zhin.js/command": {
@@ -71,7 +71,7 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.10",
     "zod": "^4.4.3",
-    "zhin.js": "1.1.18"
+    "zhin.js": "1.1.19"
   },
   "files": [
     "adapters",
@@ -103,7 +103,7 @@
     "features": [
       {
         "package": "@zhin.js/adapter",
-        "api": "^1.0.0"
+        "api": "^2.0.0"
       },
       {
         "package": "@zhin.js/command",

package/plugin.js

@@ -1,9 +1,7 @@
 // Generated by build-plugin-runtime-entries.mjs. Do not edit.
-import { createEndpointRuntimeState } from 'zhin.js/adapter';
 import { definePlugin, pluginConsoleRpcToken } from 'zhin.js';
 import { permissionHostToken } from '@zhin.js/permission';
 import { checkSlackPlatformPermit } from "./lib/platform-permit.js";
-import { slackRuntimeStateToken } from "./lib/slack-runtime-state.js";
 import { createSlackConsoleRpc } from "./lib/console.js";
 export default definePlugin({
     name: 'slack',
@@ -11,8 +9,7 @@ export default definePlugin({
         displayName: 'Slack Adapter',
     },
     setup(context) {
-        context.resources.provide(slackRuntimeStateToken, createEndpointRuntimeState());
-        context.resources.provide(pluginConsoleRpcToken, createSlackConsoleRpc(context.resources, () => context.config.get()));
+        context.resources.provide(pluginConsoleRpcToken, createSlackConsoleRpc(() => context.config.get()));
         if (context.resources.has(permissionHostToken)) {
             const host = context.resources.use(permissionHostToken);
             return host.registerPlatform('slack', checkSlackPlatformPermit);

package/src/adapter.ts

@@ -0,0 +1,38 @@
+import { Adapter, type AdapterContext, type EndpointCreationContext } from 'zhin.js/adapter';
+import { httpHostToken } from '@zhin.js/host-http';
+import { WebClient, type WebClientOptions } from '@slack/web-api';
+import { SlackEndpoint } from './endpoint.js';
+import { slackWebClientOptions } from './web-client.js';
+import { createSlackWebApiAgent } from './web-api-proxy.js';
+import { resolveSlackConfig, type SlackEndpointConfig } from './protocol.js';
+import type { SlackClientEventMap } from './client.js';
+
+export class SlackAdapter extends Adapter<SlackEndpoint, SlackEndpointConfig, SlackClientEventMap> {
+  constructor(private readonly context: AdapterContext<SlackEndpointConfig>, private readonly webOptions: WebClientOptions = {}) { super(); }
+  override get configurationIdentityFields(): readonly string[] { return ['id']; }
+  override get configurationIdentityProbeFields(): readonly string[] { return ['token', 'appToken', 'signingSecret']; }
+  override get configurationUpdateFields(): readonly string[] { return ['token', 'appToken', 'signingSecret', 'socketMode',
+    'webhookPath', 'clientPingTimeout', 'webApiProxy', 'webApiProxy.port', 'streamProxy', 'streamProxy.port', 'streamProxy.serverName']; }
+  protected override validateConfiguration(config: SlackEndpointConfig): void { resolveSlackConfig(config); }
+  protected override async identifyConfiguration(input: SlackEndpointConfig, signal: AbortSignal, changedFields: readonly string[]): Promise<string | undefined> {
+    // Neither the app-level token nor the callback signing secret has a readonly identity API.
+    if (changedFields.some(field => field !== 'token')) return undefined;
+    const config = resolveSlackConfig(input);
+    const agent = config.webApiProxy ? createSlackWebApiAgent(config.webApiProxy) : undefined;
+    const client = new WebClient(config.token, slackWebClientOptions({ ...this.webOptions, ...(agent ? { agent } : {}),
+      requestInterceptor: request => { request.signal = signal; return request; } }));
+    try {
+      const me = await client.auth.test();
+      if (typeof me.team_id !== 'string' || !me.team_id.trim()
+        || typeof me.user_id !== 'string' || !me.user_id.trim()) throw new Error('Slack identity response is incomplete');
+      return JSON.stringify(['slack', me.team_id, me.user_id]);
+    } finally { agent?.destroy(); }
+  }
+  protected createEndpoint(input: SlackEndpointConfig, execution: EndpointCreationContext): SlackEndpoint {
+    const config = resolveSlackConfig(input);
+    const webApiAgent = config.webApiProxy ? createSlackWebApiAgent(config.webApiProxy) : undefined;
+    try { return new SlackEndpoint({ id: execution.canonicalId, config, webApiAgent, webOptions: this.webOptions,
+      ...(config.mode === 'http' ? { http: this.context.use(httpHostToken) } : {}) }); }
+    catch (error) { webApiAgent?.destroy(); throw error; }
+  }
+}

package/src/client.ts

@@ -1,5 +1,4 @@
-import { defineEndpointClient } from 'zhin.js/adapter';
-import type { SlackWebClientLike } from './endpoint.js';
+import type { SlackAdapter } from './adapter.js';
 import type { SlackEvent } from './protocol.js';
 
 /** Slack users.info response fields projected by the bundled tools. */
@@ -19,12 +18,5 @@ export interface SlackUserInfo {
 export type SlackClientEventMap = Record<string, SlackEvent>;
 
 declare module '@zhin.js/feature-kit' {
-  interface AdapterClientRegistry {
-    readonly slack: {
-      readonly client: SlackWebClientLike;
-      readonly events: SlackClientEventMap;
-    };
-  }
+  interface AdapterRegistry { readonly slack: SlackAdapter; }
 }
-
-export const slackClient = defineEndpointClient<SlackWebClientLike, SlackClientEventMap>('slack');

package/src/console-spec.ts

@@ -10,6 +10,12 @@ export const slackConsoleSpec = {
     { key: 'token', required: true, env: true, description: 'Bot User OAuth Token（xoxb-...）' },
     { key: 'signingSecret', env: true, description: '签名密钥（HTTP Events，socketMode: false 必填）', descriptionI18n: { en: 'Signing secret (required for HTTP Events)' } },
     { key: 'appToken', env: true, description: 'App-Level Token（xapp-...，Socket Mode）', descriptionI18n: { en: 'App-level token (xapp-..., Socket Mode)' } },
+    { key: 'socketMode', type: 'boolean', description: 'Socket Mode; false selects HTTP Events' },
+    { key: 'webhookPath', description: 'HTTP Events route' },
+    { key: 'clientPingTimeout', type: 'number', description: 'SDK client ping timeout in milliseconds' },
+    { key: 'webApiProxy.port', type: 'number', description: 'Configured Web API loopback proxy port' },
+    { key: 'streamProxy.port', type: 'number', description: 'Configured Socket Mode loopback proxy port' },
+    { key: 'streamProxy.serverName', description: 'Expected Socket Mode TLS hostname' },
   ] as readonly AdapterConsoleField[],
   docsUrl: 'https://zhin.js.org/adapters/slack',
   readPermission: 'slack:read',

package/src/console.ts

@@ -3,19 +3,15 @@
  *
  * 页面绑定 `pages/index`，读取 / 写入分别要求 `<adapter>:read` / `<adapter>:write`。
  */
-import { createAdapterConsoleRpc, type AdapterConsoleResources } from 'zhin.js/adapter';
+import { createAdapterConsoleRpc } from 'zhin.js/adapter';
 import type { PluginConsoleRpc } from 'zhin.js';
-import { slackRuntimeStateToken } from './slack-runtime-state.js';
 import { slackConsoleSpec } from './console-spec.js';
 
 export function createSlackConsoleRpc(
-  resources: AdapterConsoleResources,
   getConfig: () => unknown,
 ): PluginConsoleRpc {
-  const state = resources.use(slackRuntimeStateToken);
   return createAdapterConsoleRpc({
     ...slackConsoleSpec,
-    running: () => state.endpoints.values(),
     getConfig,
-  }, resources);
+  });
 }