@zhin.js/adapter-slack 4.1.0 → 4.1.1

package/lib/endpoint.d.ts

@@ -0,0 +1,147 @@
+import type { EndpointInstance } from '@zhin.js/adapter';
+import type { MessageGateway } from '@zhin.js/core/runtime';
+import type { HttpHost } from '@zhin.js/host-http';
+import type { CapabilityId } from '@zhin.js/plugin-runtime';
+import { type ResolvedSlackConfig, type SlackEvent, type SlackInteractionPayload, type SlackMessageEvent, type SlackSlashCommand } from './protocol.js';
+import { type SlackChatClient } from './slack-outbound.js';
+import { type SlackWebhookHandler } from './webhook.js';
+export interface SlackSocketLike {
+    on(event: string, handler: (args: {
+        ack: () => Promise<void>;
+        body: unknown;
+    }) => void | Promise<void>): void;
+    start(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export interface SlackWebClientLike extends SlackChatClient {
+    auth: {
+        test(): Promise<{
+            user_id?: string;
+            user?: string;
+        }>;
+    };
+    conversations: {
+        invite(opts: {
+            channel: string;
+            users: string;
+        }): Promise<unknown>;
+        kick(opts: {
+            channel: string;
+            user: string;
+        }): Promise<unknown>;
+        setTopic(opts: {
+            channel: string;
+            topic: string;
+        }): Promise<unknown>;
+        setPurpose(opts: {
+            channel: string;
+            purpose: string;
+        }): Promise<unknown>;
+        archive(opts: {
+            channel: string;
+        }): Promise<unknown>;
+        unarchive(opts: {
+            channel: string;
+        }): Promise<unknown>;
+        rename(opts: {
+            channel: string;
+            name: string;
+        }): Promise<unknown>;
+        members(opts: {
+            channel: string;
+        }): Promise<{
+            members?: string[];
+        }>;
+        info(opts: {
+            channel: string;
+        }): Promise<{
+            channel?: unknown;
+        }>;
+    };
+    users: {
+        info(opts: {
+            user: string;
+        }): Promise<{
+            user?: unknown;
+        }>;
+    };
+    reactions: {
+        add(opts: {
+            channel: string;
+            timestamp: string;
+            name: string;
+        }): Promise<unknown>;
+        remove(opts: {
+            channel: string;
+            timestamp: string;
+            name: string;
+        }): Promise<unknown>;
+    };
+    pins: {
+        add(opts: {
+            channel: string;
+            timestamp: string;
+        }): Promise<unknown>;
+        remove(opts: {
+            channel: string;
+            timestamp: string;
+        }): Promise<unknown>;
+    };
+    chat: SlackChatClient['chat'] & {
+        delete(opts: {
+            channel: string;
+            ts: string;
+        }): Promise<unknown>;
+    };
+}
+export interface SlackEndpointOptions {
+    readonly id: CapabilityId;
+    readonly gateway: MessageGateway;
+    readonly config: ResolvedSlackConfig;
+    readonly http?: HttpHost;
+    readonly createClient?: (token: string) => SlackWebClientLike;
+    readonly createSocket?: (opts: {
+        readonly appToken: string;
+        readonly clientPingTimeout: number;
+    }) => SlackSocketLike;
+}
+export declare class SlackEndpoint implements EndpointInstance, SlackWebhookHandler {
+    #private;
+    constructor(options: SlackEndpointOptions);
+    get client(): SlackWebClientLike | undefined;
+    get platformUserId(): string | undefined;
+    get config(): ResolvedSlackConfig;
+    start(): Promise<void>;
+    open(): void;
+    close(): void;
+    stop(): Promise<void>;
+    send({ target, payload }: {
+        readonly target: string;
+        readonly payload: unknown;
+    }): Promise<string>;
+    /** Test / internal: admit a message event when open. */
+    admit(event: SlackMessageEvent | SlackEvent): void;
+    admitInteraction(payload: SlackInteractionPayload): void;
+    admitSlashCommand(cmd: SlackSlashCommand): void;
+    handleEnvelope(body: unknown): void;
+    trackMessageChannel(ts: string, channel: string): void;
+    resolveMessageRef(messageId: string, channelHint?: string): {
+        channel: string;
+        ts: string;
+    } | null;
+    editMessage(channel: string, messageTs: string, content: unknown): Promise<void>;
+    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>;
+}

package/lib/endpoint.js

@@ -0,0 +1,335 @@
+/**
+ * SlackEndpoint — lifecycle, outbound, admit, Socket Mode, agent tool surface.
+ */
+import { SocketModeClient } from '@slack/socket-mode';
+import { WebClient } from '@slack/web-api';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { formatInboundContent, formatInteractionContent, formatSlashContent, inboundMessageId, resolveSlackChannelType, } from './protocol.js';
+import { registerSlackAgentEndpoint } from './slack-agent-deps.js';
+import { createSlackInboundFilterState, shouldDropSlackInboundMessage, } from './slack-inbound-filter.js';
+import { formatSlackMessageRef, parseSlackMessageRef } from './slack-message-ref.js';
+import { normalizeSlackReactionName } from './slack-reaction.js';
+import { postSlackEphemeral } from './slack-response-url.js';
+import { editSlackContent, sendSlackContent } from './slack-outbound.js';
+import { registerSlackWebhookRoutes } from './webhook.js';
+const logger = getLogger('slack');
+export class SlackEndpoint {
+    #options;
+    #inboundFilter = createSlackInboundFilterState();
+    #messageChannelMap = new Map();
+    #client;
+    #socket;
+    #routeReleases = [];
+    #botUserId;
+    #open = false;
+    #started = false;
+    #unregisterAgent;
+    constructor(options) {
+        this.#options = options;
+    }
+    get client() {
+        return this.#client;
+    }
+    get platformUserId() {
+        return this.#botUserId;
+    }
+    get config() {
+        return this.#options.config;
+    }
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
+        try {
+            const { config } = this.#options;
+            this.#client = this.#options.createClient?.(config.token)
+                ?? new WebClient(config.token);
+            this.#unregisterAgent = registerSlackAgentEndpoint(config.name, this);
+            if (config.mode === 'socket') {
+                await this.#startSocket();
+            }
+            else {
+                const http = this.#options.http;
+                if (!http) {
+                    throw new Error('Slack HTTP Events API requires httpHostToken (Runtime Host)');
+                }
+                this.#routeReleases.push(...registerSlackWebhookRoutes(http, this));
+                logger.debug(formatCompact({
+                    endpoint: config.name,
+                    op: 'webhook',
+                    path: config.webhookPath,
+                }));
+            }
+            const authTest = await this.#client.auth.test();
+            if (authTest.user_id)
+                this.#botUserId = String(authTest.user_id);
+            logger.info(formatCompact({
+                op: 'connect',
+                endpoint: config.name,
+                mode: config.mode,
+                platform_user_id: this.#botUserId,
+            }));
+        }
+        catch (error) {
+            await this.stop();
+            logger.error('Failed to connect Slack endpoint:', error);
+            throw error;
+        }
+    }
+    open() {
+        this.#open = true;
+    }
+    close() {
+        this.#open = false;
+    }
+    async stop() {
+        this.#open = false;
+        if (this.#socket) {
+            try {
+                await this.#socket.disconnect();
+            }
+            catch {
+                /* ignore */
+            }
+            this.#socket = undefined;
+        }
+        for (const release of this.#routeReleases.splice(0))
+            release();
+        this.#unregisterAgent?.();
+        this.#unregisterAgent = undefined;
+        this.#client = undefined;
+        this.#started = false;
+        logger.debug(formatCompact({ op: 'disconnect', endpoint: this.#options.config.name }));
+    }
+    async send({ target, payload }) {
+        if (!this.#client)
+            throw new Error('Slack client not connected');
+        const { channel, threadTs } = parseSendTarget(target);
+        const result = await sendSlackContent(this.#client, payload, { channel, threadTs }, logger);
+        if (result.ts)
+            this.trackMessageChannel(result.ts, channel);
+        return formatSlackMessageRef(channel, result.ts || String(Date.now()));
+    }
+    /** Test / internal: admit a message event when open. */
+    admit(event) {
+        if (!this.#open)
+            return;
+        if (event.type !== 'message' && event.type !== 'app_mention')
+            return;
+        const msg = event;
+        if (shouldDropSlackInboundMessage(msg, this.#inboundFilter, this.#botUserId))
+            return;
+        if (!msg.channel || !msg.ts)
+            return;
+        this.trackMessageChannel(msg.ts, msg.channel);
+        void this.#options.gateway.receive({
+            adapter: this.#options.id,
+            target: msg.channel,
+            content: formatInboundContent(msg),
+            sender: msg.user ?? msg.channel,
+            id: inboundMessageId(msg),
+            metadata: Object.freeze({
+                endpoint: this.#options.config.name,
+                channelType: resolveSlackChannelType(msg),
+                userId: msg.user,
+                threadTs: msg.thread_ts && msg.thread_ts !== msg.ts ? msg.thread_ts : undefined,
+                ts: msg.ts,
+                // app_mention 事件本身即 @ 机器人；新 Runtime 纯文本 content 需经 metadata 传递
+                ...(msg.type === 'app_mention' ? { mentioned: true } : {}),
+            }),
+        }).catch((err) => {
+            logger.warn(formatCompact({
+                op: 'slack_gateway_receive_failed',
+                target: msg.channel,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    admitInteraction(payload) {
+        if (!this.#open)
+            return;
+        if (payload.type !== 'block_actions' || !payload.actions?.length)
+            return;
+        const channelId = payload.channel?.id ?? '';
+        const userId = payload.user.id;
+        const messageTs = payload.message?.ts ?? '';
+        if (payload.response_url) {
+            postSlackEphemeral(payload.response_url, '已收到', logger);
+        }
+        void this.#options.gateway.receive({
+            adapter: this.#options.id,
+            target: channelId || userId,
+            content: formatInteractionContent(payload),
+            sender: userId,
+            id: payload.actions[0]?.action_ts ?? messageTs ?? `action-${Date.now()}`,
+            metadata: Object.freeze({
+                endpoint: this.#options.config.name,
+                eventType: 'block_actions',
+                actionId: payload.actions[0]?.action_id,
+                threadTs: messageTs || undefined,
+            }),
+        }).catch((err) => {
+            logger.warn(formatCompact({
+                op: 'slack_gateway_receive_failed',
+                target: channelId,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    admitSlashCommand(cmd) {
+        if (!this.#open)
+            return;
+        postSlackEphemeral(cmd.response_url, '处理中…', logger);
+        void this.#options.gateway.receive({
+            adapter: this.#options.id,
+            target: cmd.channel_id,
+            content: formatSlashContent(cmd),
+            sender: cmd.user_id,
+            id: cmd.trigger_id,
+            metadata: Object.freeze({
+                endpoint: this.#options.config.name,
+                eventType: 'slash_command',
+                command: cmd.command,
+            }),
+        }).catch((err) => {
+            logger.warn(formatCompact({
+                op: 'slack_gateway_receive_failed',
+                target: cmd.channel_id,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    handleEnvelope(body) {
+        const envelope = body;
+        if (envelope?.type === 'event_callback' && envelope.event) {
+            this.admit(envelope.event);
+        }
+    }
+    trackMessageChannel(ts, channel) {
+        if (ts && channel)
+            this.#messageChannelMap.set(ts, channel);
+    }
+    resolveMessageRef(messageId, channelHint) {
+        const parsed = parseSlackMessageRef(messageId);
+        if (parsed) {
+            this.trackMessageChannel(parsed.ts, parsed.channel);
+            return parsed;
+        }
+        if (channelHint)
+            return { channel: channelHint, ts: messageId };
+        const channel = this.#messageChannelMap.get(messageId);
+        return channel ? { channel, ts: messageId } : null;
+    }
+    async editMessage(channel, messageTs, content) {
+        if (!this.#client)
+            throw new Error('Slack client not connected');
+        await editSlackContent(this.#client, channel, messageTs, content);
+    }
+    // ── Agent tool surface ──────────────────────────────────────────────
+    async inviteToChannel(channel, users) {
+        await this.#client.conversations.invite({ channel, users: users.join(',') });
+        return true;
+    }
+    async kickFromChannel(channel, user) {
+        await this.#client.conversations.kick({ channel, user });
+        return true;
+    }
+    async setChannelTopic(channel, topic) {
+        await this.#client.conversations.setTopic({ channel, topic });
+        return true;
+    }
+    async setChannelPurpose(channel, purpose) {
+        await this.#client.conversations.setPurpose({ channel, purpose });
+        return true;
+    }
+    async archiveChannel(channel) {
+        await this.#client.conversations.archive({ channel });
+        return true;
+    }
+    async unarchiveChannel(channel) {
+        await this.#client.conversations.unarchive({ channel });
+        return true;
+    }
+    async renameChannel(channel, name) {
+        await this.#client.conversations.rename({ channel, name });
+        return true;
+    }
+    async getChannelMembers(channel) {
+        const result = await this.#client.conversations.members({ channel });
+        return result.members || [];
+    }
+    async getChannelInfo(channel) {
+        const result = await this.#client.conversations.info({ channel });
+        return result.channel;
+    }
+    async getUserInfo(user) {
+        const result = await this.#client.users.info({ user });
+        return result.user;
+    }
+    async addReaction(channel, timestamp, name) {
+        const reaction = normalizeSlackReactionName(name);
+        try {
+            await this.#client.reactions.add({ channel, timestamp, name: reaction });
+            return true;
+        }
+        catch (error) {
+            const code = error?.data?.error;
+            if (code === 'already_reacted')
+                return true;
+            throw error;
+        }
+    }
+    async removeReaction(channel, timestamp, name) {
+        const reaction = normalizeSlackReactionName(name);
+        try {
+            await this.#client.reactions.remove({ channel, timestamp, name: reaction });
+            return true;
+        }
+        catch (error) {
+            const code = error?.data?.error;
+            if (code === 'no_reaction')
+                return true;
+            throw error;
+        }
+    }
+    async pinMessage(channel, timestamp) {
+        await this.#client.pins.add({ channel, timestamp });
+        return true;
+    }
+    async unpinMessage(channel, timestamp) {
+        await this.#client.pins.remove({ channel, timestamp });
+        return true;
+    }
+    async #startSocket() {
+        const { config } = this.#options;
+        if (!config.appToken)
+            throw new Error('Socket Mode requires appToken');
+        this.#socket = this.#options.createSocket?.({
+            appToken: config.appToken,
+            clientPingTimeout: config.clientPingTimeout,
+        }) ?? new SocketModeClient({
+            appToken: config.appToken,
+            clientPingTimeout: config.clientPingTimeout,
+        });
+        this.#socket.on('slack_event', async ({ ack, body }) => {
+            await ack();
+            this.handleEnvelope(body);
+        });
+        this.#socket.on('interactive', async ({ ack, body }) => {
+            await ack();
+            this.admitInteraction(body);
+        });
+        this.#socket.on('slash_commands', async ({ ack, body }) => {
+            await ack();
+            this.admitSlashCommand(body);
+        });
+        await this.#socket.start();
+    }
+}
+function parseSendTarget(target) {
+    const parsed = parseSlackMessageRef(target);
+    if (parsed && /^\d+\.\d+$/.test(parsed.ts)) {
+        return { channel: parsed.channel, threadTs: parsed.ts };
+    }
+    return { channel: target };
+}

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+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';
+export { SlackEndpoint, type SlackEndpointOptions, type SlackSocketLike, type SlackWebClientLike, } from './endpoint.js';
+export { registerSlackWebhookRoutes, handleSlackWebhookRequest, type SlackWebhookHandler, } from './webhook.js';
+export { getSlackAgentDeps, registerSlackAgentEndpoint, setSlackAgentDeps, type SlackAgentDeps, type SlackAgentEndpoint, } from './slack-agent-deps.js';
+export { checkSlackPlatformPermit, normalizeSlackSenderForPermit, platformPermit, registerSlackPlatformPermitChecker, slackGroupPermitResolver, } from './platform-permit.js';
+export { formatSlackMessageRef, parseSlackMessageRef, slackMessageTs, } from './slack-message-ref.js';
+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/lib/index.js

@@ -0,0 +1,11 @@
+export { formatInboundContent, formatInteractionContent, formatOutboundWire, formatSlashContent, headerValue, inboundMessageId, keyboardToBlockKitBlocks, normalizeWebhookPath, readTextBody, resolveSlackChannelType, resolveSlackConfig, verifySlackSignature, } from './protocol.js';
+export { SlackEndpoint, } from './endpoint.js';
+export { registerSlackWebhookRoutes, handleSlackWebhookRequest, } from './webhook.js';
+export { getSlackAgentDeps, registerSlackAgentEndpoint, setSlackAgentDeps, } from './slack-agent-deps.js';
+export { checkSlackPlatformPermit, normalizeSlackSenderForPermit, platformPermit, registerSlackPlatformPermitChecker, slackGroupPermitResolver, } from './platform-permit.js';
+export { formatSlackMessageRef, parseSlackMessageRef, slackMessageTs, } from './slack-message-ref.js';
+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/lib/markdown-to-mrkdwn.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 常见 Markdown → Slack mrkdwn（Slack 粗体为 *text*，链接为 <url|text>）
+ */
+export declare const SLACK_MRKDWN_TEXT_MAX = 2900;
+export declare function markdownToMrkdwn(text: string): string;
+/** 按 Slack section mrkdwn 上限切分（尽量在换行/空格处断开） */
+export declare function splitMrkdwnText(text: string, maxLen?: number): string[];
+/** 通知栏 / 无障碍 fallback 用的纯文本 */
+export declare function mrkdwnToPlainFallback(text: string): string;

package/lib/markdown-to-mrkdwn.js

@@ -0,0 +1,121 @@
+/**
+ * 常见 Markdown → Slack mrkdwn（Slack 粗体为 *text*，链接为 <url|text>）
+ */
+export const SLACK_MRKDWN_TEXT_MAX = 2900;
+export function markdownToMrkdwn(text) {
+    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) {
+    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, maxLen = SLACK_MRKDWN_TEXT_MAX) {
+    if (text.length <= maxLen)
+        return [text];
+    const chunks = [];
+    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) {
+    return stripMrkdwnMarkers(stripAngleBrackets(rewriteAngleLinks(text)));
+}
+/**
+ * `<url|text>` → `text (url)`。
+ * 线性扫描，语义等价于 `/<([^|>]+)\|([^>]+)>/g`（分组一不含 `|`，
+ * 因此切分点恒为首个 `|`），但避免量词重叠在超长 `<...` 输入上的
+ * 二次方回溯（js/polynomial-redos）。
+ */
+function rewriteAngleLinks(text) {
+    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) {
+    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) {
+    let out = '';
+    for (const ch of text) {
+        if (ch !== '*' && ch !== '_' && ch !== '~' && ch !== '`')
+            out += ch;
+    }
+    return out;
+}

package/lib/mrkdwn-to-markdown.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Slack mrkdwn → 通用 Markdown（入站文本段）
+ */
+export declare function mrkdwnToMarkdown(text: string): string;

package/lib/{src/mrkdwn-to-markdown.js → mrkdwn-to-markdown.js}

@@ -28,4 +28,3 @@ function replaceSlackLinks(text) {
     }
     return out + text.slice(cursor);
 }
-//# sourceMappingURL=mrkdwn-to-markdown.js.map

package/lib/platform-permit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Slack platform permit — workspace + channel 权限
+ */
+import { type Message } from '@zhin.js/core';
+export declare function platformPermit(perm: string): string;
+export declare function slackGroupPermitResolver(logicalPerm: string): string;
+export declare function normalizeSlackSenderForPermit(input: {
+    isWorkspaceOwner?: boolean;
+    isWorkspaceAdmin?: boolean;
+    isChannelManager?: boolean;
+}): {
+    role?: string;
+    permissions?: string[];
+};
+export declare function checkSlackPlatformPermit(perm: string, message: Message<any>): boolean;
+export declare function registerSlackPlatformPermitChecker(): () => void;

package/lib/{src/platform-permit.js → platform-permit.js}

@@ -1,7 +1,7 @@
 /**
  * Slack platform permit — workspace + channel 权限
  */
-import { registerPlatformPermitChecker } from 'zhin.js';
+import { registerPlatformPermitChecker } from '@zhin.js/core';
 const ADAPTER = 'slack';
 export function platformPermit(perm) {
     return `platform(${ADAPTER},${perm})`;
@@ -49,4 +49,3 @@ export function checkSlackPlatformPermit(perm, message) {
 export function registerSlackPlatformPermitChecker() {
     return registerPlatformPermitChecker(ADAPTER, checkSlackPlatformPermit);
 }
-//# sourceMappingURL=platform-permit.js.map