@aigne/afs-slack 1.11.0-beta.12

package/LICENSE.md

@@ -0,0 +1,26 @@
+# Proprietary License
+
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
+
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
+
+## No License Granted
+
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
+
+## Public Artifact Distribution
+
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
+
+## Contact
+
+For licensing inquiries, contact: legal@arcblock.io

package/dist/_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs

@@ -0,0 +1,11 @@
+
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+exports.__decorate = __decorate;

package/dist/_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs

@@ -0,0 +1,10 @@
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+export { __decorate };

package/dist/client.cjs

@@ -0,0 +1,120 @@
+
+//#region src/client.ts
+/**
+* SlackClient — pure Slack API wrapper.
+*
+* Two modes:
+* - Webhook: outbound-only, POST to Incoming Webhook URL
+* - Bot: bidirectional, chat.postMessage with Bearer token
+*
+* Zero external dependencies (uses native fetch).
+* No AFS or application-specific concepts.
+*/
+const DEFAULT_API_BASE = "https://slack.com/api";
+const DEFAULT_TIMEOUT = 3e4;
+var SlackClient = class SlackClient {
+	mode;
+	_webhookUrl;
+	_botToken;
+	_apiBase;
+	_timeout;
+	constructor(opts) {
+		this.mode = opts.mode;
+		this._webhookUrl = opts.webhookUrl ?? null;
+		this._botToken = opts.botToken ?? null;
+		this._apiBase = opts.apiBase ?? DEFAULT_API_BASE;
+		this._timeout = opts.timeout ?? DEFAULT_TIMEOUT;
+	}
+	static webhook(url, options) {
+		if (!url) throw new Error("SlackClient.webhook requires a webhook URL");
+		let parsed;
+		try {
+			parsed = new URL(url);
+		} catch {
+			throw new Error("SlackClient.webhook: invalid webhook URL");
+		}
+		const isLocal = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+		if (parsed.protocol !== "https:" && !isLocal) throw new Error("SlackClient.webhook: webhook URL must use HTTPS (or localhost for testing)");
+		return new SlackClient({
+			mode: "webhook",
+			webhookUrl: url,
+			timeout: options?.timeout
+		});
+	}
+	static bot(options) {
+		if (!options.botToken) throw new Error("SlackClient.bot requires a botToken");
+		return new SlackClient({
+			mode: "bot",
+			botToken: options.botToken,
+			apiBase: options.apiBase,
+			timeout: options.timeout
+		});
+	}
+	async sendWebhook(text, options) {
+		if (!this._webhookUrl) throw new Error("sendWebhook requires webhook mode");
+		const payload = { text };
+		if (options?.blocks) payload.blocks = options.blocks;
+		await fetch(this._webhookUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: AbortSignal.timeout(this._timeout)
+		});
+	}
+	async postMessage(channel, text, options) {
+		const body = {
+			channel,
+			text
+		};
+		if (options?.blocks) body.blocks = options.blocks;
+		if (options?.threadTs) body.thread_ts = options.threadTs;
+		return this._call("chat.postMessage", body);
+	}
+	static parseEvent(payload) {
+		if (!payload) return null;
+		if (payload.type === "url_verification" && payload.challenge) return {
+			type: "url_verification",
+			challenge: payload.challenge
+		};
+		if (payload.type !== "event_callback") return null;
+		const event = payload.event;
+		if (!event || event.type !== "message") return null;
+		if (event.bot_id) return null;
+		if (event.subtype) return null;
+		const text = (event.text || "").trim();
+		const userId = event.user;
+		const channelId = event.channel;
+		const ts = event.ts;
+		if (!text || !userId) return null;
+		return {
+			type: "message",
+			text,
+			userId,
+			channelId,
+			ts
+		};
+	}
+	static escapeSlack(text) {
+		return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	}
+	async _call(method, body) {
+		if (!this._botToken) throw new Error(`${method} requires bot mode`);
+		const data = await (await fetch(`${this._apiBase}/${method}`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${this._botToken}`
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(this._timeout)
+		})).json();
+		if (!data.ok) {
+			const desc = (data.error || "Unknown error").replace(this._botToken, "***");
+			throw new Error(`Slack API error: ${desc}`);
+		}
+		return data;
+	}
+};
+
+//#endregion
+exports.SlackClient = SlackClient;

package/dist/client.d.cts

@@ -0,0 +1,56 @@
+//#region src/client.d.ts
+/**
+ * SlackClient — pure Slack API wrapper.
+ *
+ * Two modes:
+ * - Webhook: outbound-only, POST to Incoming Webhook URL
+ * - Bot: bidirectional, chat.postMessage with Bearer token
+ *
+ * Zero external dependencies (uses native fetch).
+ * No AFS or application-specific concepts.
+ */
+interface SlackBotOptions {
+  botToken: string;
+  apiBase?: string;
+  timeout?: number;
+}
+interface PostMessageOptions {
+  blocks?: unknown[];
+  threadTs?: string;
+}
+interface SendWebhookOptions {
+  blocks?: unknown[];
+}
+/** Parsed Slack Events API event. */
+type SlackParsedEvent = {
+  type: "url_verification";
+  challenge: string;
+} | {
+  type: "message";
+  text: string;
+  userId: string;
+  channelId: string;
+  ts: string;
+} | null;
+declare class SlackClient {
+  readonly mode: "webhook" | "bot";
+  private readonly _webhookUrl;
+  private readonly _botToken;
+  private readonly _apiBase;
+  private readonly _timeout;
+  private constructor();
+  static webhook(url: string, options?: {
+    timeout?: number;
+  }): SlackClient;
+  static bot(options: SlackBotOptions): SlackClient;
+  sendWebhook(text: string, options?: SendWebhookOptions): Promise<void>;
+  postMessage(channel: string, text: string, options?: PostMessageOptions): Promise<{
+    ts: string;
+  }>;
+  static parseEvent(payload: any): SlackParsedEvent;
+  static escapeSlack(text: string): string;
+  private _call;
+}
+//#endregion
+export { SlackClient };
+//# sourceMappingURL=client.d.cts.map

package/dist/client.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.cts","names":[],"sources":["../src/client.ts"],"mappings":";;AAcA;;;;;;;;;UAAiB,eAAA;EACf,QAAA;EACA,OAAA;EACA,OAAA;AAAA;AAAA,UAGe,kBAAA;EACf,MAAA;EACA,QAAA;AAAA;AAAA,UAGe,kBAAA;EACf,MAAA;AAAA;;KAIU,gBAAA;EACN,IAAA;EAA0B,SAAA;AAAA;EAC1B,IAAA;EAAiB,IAAA;EAAc,MAAA;EAAgB,SAAA;EAAmB,EAAA;AAAA;AAAA,cAG3D,WAAA;EAAA,SACF,IAAA;EAAA,iBACQ,WAAA;EAAA,iBACA,SAAA;EAAA,iBACA,QAAA;EAAA,iBACA,QAAA;EAAA,QAEV,WAAA,CAAA;EAAA,OAgBA,OAAA,CAAQ,GAAA,UAAa,OAAA;IAAY,OAAA;EAAA,IAAqB,WAAA;EAAA,OAsBtD,GAAA,CAAI,OAAA,EAAS,eAAA,GAAkB,WAAA;EAYhC,WAAA,CAAY,IAAA,UAAc,OAAA,GAAU,kBAAA,GAAqB,OAAA;EAgBzD,WAAA,CACJ,OAAA,UACA,IAAA,UACA,OAAA,GAAU,kBAAA,GACT,OAAA;IAAU,EAAA;EAAA;EAAA,OASN,UAAA,CAAW,OAAA,QAAe,gBAAA;EAAA,OAyB1B,WAAA,CAAY,IAAA;EAAA,QAML,KAAA;AAAA"}

package/dist/client.d.mts

@@ -0,0 +1,56 @@
+//#region src/client.d.ts
+/**
+ * SlackClient — pure Slack API wrapper.
+ *
+ * Two modes:
+ * - Webhook: outbound-only, POST to Incoming Webhook URL
+ * - Bot: bidirectional, chat.postMessage with Bearer token
+ *
+ * Zero external dependencies (uses native fetch).
+ * No AFS or application-specific concepts.
+ */
+interface SlackBotOptions {
+  botToken: string;
+  apiBase?: string;
+  timeout?: number;
+}
+interface PostMessageOptions {
+  blocks?: unknown[];
+  threadTs?: string;
+}
+interface SendWebhookOptions {
+  blocks?: unknown[];
+}
+/** Parsed Slack Events API event. */
+type SlackParsedEvent = {
+  type: "url_verification";
+  challenge: string;
+} | {
+  type: "message";
+  text: string;
+  userId: string;
+  channelId: string;
+  ts: string;
+} | null;
+declare class SlackClient {
+  readonly mode: "webhook" | "bot";
+  private readonly _webhookUrl;
+  private readonly _botToken;
+  private readonly _apiBase;
+  private readonly _timeout;
+  private constructor();
+  static webhook(url: string, options?: {
+    timeout?: number;
+  }): SlackClient;
+  static bot(options: SlackBotOptions): SlackClient;
+  sendWebhook(text: string, options?: SendWebhookOptions): Promise<void>;
+  postMessage(channel: string, text: string, options?: PostMessageOptions): Promise<{
+    ts: string;
+  }>;
+  static parseEvent(payload: any): SlackParsedEvent;
+  static escapeSlack(text: string): string;
+  private _call;
+}
+//#endregion
+export { SlackClient };
+//# sourceMappingURL=client.d.mts.map

package/dist/client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.mts","names":[],"sources":["../src/client.ts"],"mappings":";;AAcA;;;;;;;;;UAAiB,eAAA;EACf,QAAA;EACA,OAAA;EACA,OAAA;AAAA;AAAA,UAGe,kBAAA;EACf,MAAA;EACA,QAAA;AAAA;AAAA,UAGe,kBAAA;EACf,MAAA;AAAA;;KAIU,gBAAA;EACN,IAAA;EAA0B,SAAA;AAAA;EAC1B,IAAA;EAAiB,IAAA;EAAc,MAAA;EAAgB,SAAA;EAAmB,EAAA;AAAA;AAAA,cAG3D,WAAA;EAAA,SACF,IAAA;EAAA,iBACQ,WAAA;EAAA,iBACA,SAAA;EAAA,iBACA,QAAA;EAAA,iBACA,QAAA;EAAA,QAEV,WAAA,CAAA;EAAA,OAgBA,OAAA,CAAQ,GAAA,UAAa,OAAA;IAAY,OAAA;EAAA,IAAqB,WAAA;EAAA,OAsBtD,GAAA,CAAI,OAAA,EAAS,eAAA,GAAkB,WAAA;EAYhC,WAAA,CAAY,IAAA,UAAc,OAAA,GAAU,kBAAA,GAAqB,OAAA;EAgBzD,WAAA,CACJ,OAAA,UACA,IAAA,UACA,OAAA,GAAU,kBAAA,GACT,OAAA;IAAU,EAAA;EAAA;EAAA,OASN,UAAA,CAAW,OAAA,QAAe,gBAAA;EAAA,OAyB1B,WAAA,CAAY,IAAA;EAAA,QAML,KAAA;AAAA"}

package/dist/client.mjs

@@ -0,0 +1,120 @@
+//#region src/client.ts
+/**
+* SlackClient — pure Slack API wrapper.
+*
+* Two modes:
+* - Webhook: outbound-only, POST to Incoming Webhook URL
+* - Bot: bidirectional, chat.postMessage with Bearer token
+*
+* Zero external dependencies (uses native fetch).
+* No AFS or application-specific concepts.
+*/
+const DEFAULT_API_BASE = "https://slack.com/api";
+const DEFAULT_TIMEOUT = 3e4;
+var SlackClient = class SlackClient {
+	mode;
+	_webhookUrl;
+	_botToken;
+	_apiBase;
+	_timeout;
+	constructor(opts) {
+		this.mode = opts.mode;
+		this._webhookUrl = opts.webhookUrl ?? null;
+		this._botToken = opts.botToken ?? null;
+		this._apiBase = opts.apiBase ?? DEFAULT_API_BASE;
+		this._timeout = opts.timeout ?? DEFAULT_TIMEOUT;
+	}
+	static webhook(url, options) {
+		if (!url) throw new Error("SlackClient.webhook requires a webhook URL");
+		let parsed;
+		try {
+			parsed = new URL(url);
+		} catch {
+			throw new Error("SlackClient.webhook: invalid webhook URL");
+		}
+		const isLocal = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+		if (parsed.protocol !== "https:" && !isLocal) throw new Error("SlackClient.webhook: webhook URL must use HTTPS (or localhost for testing)");
+		return new SlackClient({
+			mode: "webhook",
+			webhookUrl: url,
+			timeout: options?.timeout
+		});
+	}
+	static bot(options) {
+		if (!options.botToken) throw new Error("SlackClient.bot requires a botToken");
+		return new SlackClient({
+			mode: "bot",
+			botToken: options.botToken,
+			apiBase: options.apiBase,
+			timeout: options.timeout
+		});
+	}
+	async sendWebhook(text, options) {
+		if (!this._webhookUrl) throw new Error("sendWebhook requires webhook mode");
+		const payload = { text };
+		if (options?.blocks) payload.blocks = options.blocks;
+		await fetch(this._webhookUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: AbortSignal.timeout(this._timeout)
+		});
+	}
+	async postMessage(channel, text, options) {
+		const body = {
+			channel,
+			text
+		};
+		if (options?.blocks) body.blocks = options.blocks;
+		if (options?.threadTs) body.thread_ts = options.threadTs;
+		return this._call("chat.postMessage", body);
+	}
+	static parseEvent(payload) {
+		if (!payload) return null;
+		if (payload.type === "url_verification" && payload.challenge) return {
+			type: "url_verification",
+			challenge: payload.challenge
+		};
+		if (payload.type !== "event_callback") return null;
+		const event = payload.event;
+		if (!event || event.type !== "message") return null;
+		if (event.bot_id) return null;
+		if (event.subtype) return null;
+		const text = (event.text || "").trim();
+		const userId = event.user;
+		const channelId = event.channel;
+		const ts = event.ts;
+		if (!text || !userId) return null;
+		return {
+			type: "message",
+			text,
+			userId,
+			channelId,
+			ts
+		};
+	}
+	static escapeSlack(text) {
+		return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	}
+	async _call(method, body) {
+		if (!this._botToken) throw new Error(`${method} requires bot mode`);
+		const data = await (await fetch(`${this._apiBase}/${method}`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${this._botToken}`
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(this._timeout)
+		})).json();
+		if (!data.ok) {
+			const desc = (data.error || "Unknown error").replace(this._botToken, "***");
+			throw new Error(`Slack API error: ${desc}`);
+		}
+		return data;
+	}
+};
+
+//#endregion
+export { SlackClient };
+//# sourceMappingURL=client.mjs.map

package/dist/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../src/client.ts"],"sourcesContent":["/**\n * SlackClient — pure Slack API wrapper.\n *\n * Two modes:\n * - Webhook: outbound-only, POST to Incoming Webhook URL\n * - Bot: bidirectional, chat.postMessage with Bearer token\n *\n * Zero external dependencies (uses native fetch).\n * No AFS or application-specific concepts.\n */\n\nconst DEFAULT_API_BASE = \"https://slack.com/api\";\nconst DEFAULT_TIMEOUT = 30_000;\n\nexport interface SlackBotOptions {\n  botToken: string;\n  apiBase?: string;\n  timeout?: number;\n}\n\nexport interface PostMessageOptions {\n  blocks?: unknown[];\n  threadTs?: string;\n}\n\nexport interface SendWebhookOptions {\n  blocks?: unknown[];\n}\n\n/** Parsed Slack Events API event. */\nexport type SlackParsedEvent =\n  | { type: \"url_verification\"; challenge: string }\n  | { type: \"message\"; text: string; userId: string; channelId: string; ts: string }\n  | null;\n\nexport class SlackClient {\n  readonly mode: \"webhook\" | \"bot\";\n  private readonly _webhookUrl: string | null;\n  private readonly _botToken: string | null;\n  private readonly _apiBase: string;\n  private readonly _timeout: number;\n\n  private constructor(opts: {\n    mode: \"webhook\" | \"bot\";\n    webhookUrl?: string;\n    botToken?: string;\n    apiBase?: string;\n    timeout?: number;\n  }) {\n    this.mode = opts.mode;\n    this._webhookUrl = opts.webhookUrl ?? null;\n    this._botToken = opts.botToken ?? null;\n    this._apiBase = opts.apiBase ?? DEFAULT_API_BASE;\n    this._timeout = opts.timeout ?? DEFAULT_TIMEOUT;\n  }\n\n  // ─── Factory Methods ──────────────────────────────────────\n\n  static webhook(url: string, options?: { timeout?: number }): SlackClient {\n    if (!url) throw new Error(\"SlackClient.webhook requires a webhook URL\");\n\n    let parsed: URL;\n    try {\n      parsed = new URL(url);\n    } catch {\n      throw new Error(\"SlackClient.webhook: invalid webhook URL\");\n    }\n\n    const isLocal = parsed.hostname === \"localhost\" || parsed.hostname === \"127.0.0.1\";\n    if (parsed.protocol !== \"https:\" && !isLocal) {\n      throw new Error(\"SlackClient.webhook: webhook URL must use HTTPS (or localhost for testing)\");\n    }\n\n    return new SlackClient({\n      mode: \"webhook\",\n      webhookUrl: url,\n      timeout: options?.timeout,\n    });\n  }\n\n  static bot(options: SlackBotOptions): SlackClient {\n    if (!options.botToken) throw new Error(\"SlackClient.bot requires a botToken\");\n    return new SlackClient({\n      mode: \"bot\",\n      botToken: options.botToken,\n      apiBase: options.apiBase,\n      timeout: options.timeout,\n    });\n  }\n\n  // ─── Webhook Mode ─────────────────────────────────────────\n\n  async sendWebhook(text: string, options?: SendWebhookOptions): Promise<void> {\n    if (!this._webhookUrl) throw new Error(\"sendWebhook requires webhook mode\");\n\n    const payload: Record<string, unknown> = { text };\n    if (options?.blocks) payload.blocks = options.blocks;\n\n    await fetch(this._webhookUrl, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\" },\n      body: JSON.stringify(payload),\n      signal: AbortSignal.timeout(this._timeout),\n    });\n  }\n\n  // ─── Bot Mode ─────────────────────────────────────────────\n\n  async postMessage(\n    channel: string,\n    text: string,\n    options?: PostMessageOptions,\n  ): Promise<{ ts: string }> {\n    const body: Record<string, unknown> = { channel, text };\n    if (options?.blocks) body.blocks = options.blocks;\n    if (options?.threadTs) body.thread_ts = options.threadTs;\n    return this._call(\"chat.postMessage\", body);\n  }\n\n  // ─── Events API Parsing ───────────────────────────────────\n\n  static parseEvent(payload: any): SlackParsedEvent {\n    if (!payload) return null;\n\n    if (payload.type === \"url_verification\" && payload.challenge) {\n      return { type: \"url_verification\", challenge: payload.challenge };\n    }\n\n    if (payload.type !== \"event_callback\") return null;\n\n    const event = payload.event;\n    if (!event || event.type !== \"message\") return null;\n    if (event.bot_id) return null;\n    if (event.subtype) return null;\n\n    const text = (event.text || \"\").trim();\n    const userId = event.user;\n    const channelId = event.channel;\n    const ts = event.ts;\n    if (!text || !userId) return null;\n\n    return { type: \"message\", text, userId, channelId, ts };\n  }\n\n  // ─── Helpers ──────────────────────────────────────────────\n\n  static escapeSlack(text: string): string {\n    return text.replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\");\n  }\n\n  // ─── Internal ─────────────────────────────────────────────\n\n  private async _call(method: string, body: Record<string, unknown>): Promise<any> {\n    if (!this._botToken) throw new Error(`${method} requires bot mode`);\n\n    const response = await fetch(`${this._apiBase}/${method}`, {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${this._botToken}`,\n      },\n      body: JSON.stringify(body),\n      signal: AbortSignal.timeout(this._timeout),\n    });\n\n    const data = (await response.json()) as { ok: boolean; error?: string; ts?: string };\n    if (!data.ok) {\n      const desc = (data.error || \"Unknown error\").replace(this._botToken, \"***\");\n      throw new Error(`Slack API error: ${desc}`);\n    }\n    return data;\n  }\n}\n"],"mappings":"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"}

package/dist/index.cjs

@@ -0,0 +1,288 @@
+const require_client = require('./client.cjs');
+const require_decorate = require('./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs');
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let _aigne_afs_messaging = require("@aigne/afs-messaging");
+
+//#region src/index.ts
+var AFSSlack = class extends _aigne_afs_messaging.BaseMessageProvider {
+	static manifest() {
+		return {
+			name: "slack",
+			description: "Slack messaging — webhook (outbound) or Bot API (bidirectional).\n- Incoming Webhook for simple notifications\n- Bot token + Events API for full interaction\n- Path: /:bot/conversations/:channelId/messages/:ts",
+			uriTemplate: "slack://{botToken}",
+			category: "messaging",
+			schema: {
+				type: "object",
+				properties: {
+					botToken: {
+						type: "string",
+						description: "Slack Bot OAuth token",
+						sensitive: true
+					},
+					webhook: {
+						type: "string",
+						description: "Incoming Webhook URL",
+						sensitive: true
+					},
+					channels: {
+						type: "array",
+						items: { type: "string" },
+						description: "Channel IDs"
+					}
+				}
+			},
+			tags: [
+				"slack",
+				"messaging",
+				"chat",
+				"workspace"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:token",
+				"remote",
+				"http",
+				"real-time",
+				"rate-limited"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet"],
+				notes: ["Connects to Slack API — requires bot token or webhook URL"]
+			},
+			capabilities: { network: {
+				egress: true,
+				allowedDomains: ["slack.com"]
+			} }
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "messaging:root",
+					operations: ["list", "exec"],
+					actions: [
+						"add-bot",
+						"remove-bot",
+						"process-event"
+					]
+				},
+				"/{bot}": {
+					kind: "messaging:bot",
+					operations: ["list", "read"]
+				},
+				"/{bot}/ctl": {
+					kind: "messaging:status",
+					operations: ["read"]
+				},
+				"/{bot}/conversations": {
+					kind: "messaging:conversations",
+					operations: ["list"]
+				},
+				"/{bot}/conversations/{convId}": {
+					kind: "messaging:conversation",
+					operations: ["list"]
+				},
+				"/{bot}/conversations/{convId}/messages": {
+					kind: "messaging:messages",
+					operations: ["list", "exec"],
+					actions: ["send"]
+				},
+				"/{bot}/conversations/{convId}/messages/{msgId}": {
+					kind: "messaging:message",
+					operations: ["read"]
+				}
+			},
+			auth: {
+				type: "token",
+				env: ["SLACK_BOT_TOKEN"]
+			},
+			bestFor: [
+				"team notifications",
+				"workflow alerts",
+				"chatops"
+			],
+			notFor: ["file storage", "database queries"]
+		};
+	}
+	providerName = "slack";
+	eventPrefix = "slack";
+	constructor(options) {
+		let bots;
+		if (options.bots) bots = options.bots.map((b) => ({
+			...b,
+			conversations: b.channels
+		}));
+		else {
+			if (!options.botToken && !options.webhook) throw new Error("AFSSlack requires either botToken or webhook");
+			bots = [{
+				name: "default",
+				botToken: options.botToken,
+				webhook: options.webhook,
+				conversations: options.channels ?? [],
+				apiBase: options.apiBase
+			}];
+		}
+		super({
+			bots,
+			bufferSize: options.bufferSize
+		});
+	}
+	getMessageCapabilities() {
+		return {
+			formats: {
+				send: ["text", "markdown"],
+				receive: ["text"]
+			},
+			maxMessageLength: 4e4,
+			features: {
+				edit: false,
+				delete: false,
+				reply: true,
+				thread: true,
+				reaction: true,
+				inlineKeyboard: false
+			},
+			limits: {
+				messagesPerSecond: 1,
+				messagesPerMinute: 60
+			}
+		};
+	}
+	createBotClient(config) {
+		const botToken = config.botToken;
+		const webhook = config.webhook;
+		const apiBase = config.apiBase;
+		if (botToken) return require_client.SlackClient.bot({
+			botToken,
+			apiBase
+		});
+		if (webhook) return require_client.SlackClient.webhook(webhook);
+		throw new Error(`Slack bot "${config.name}" requires botToken or webhook`);
+	}
+	async sendMessage(client, convId, text, opts) {
+		const sc = client;
+		const blocks = opts?.blocks;
+		const safeText = require_client.SlackClient.escapeSlack(text);
+		if (sc.mode === "bot") return { messageId: (await sc.postMessage(convId, safeText, { blocks })).ts };
+		await sc.sendWebhook(safeText, { blocks });
+		return { messageId: String(Date.now()) };
+	}
+	async sendTypingIndicator(_client, _convId) {}
+	normalizeMessage(raw) {
+		const msg = raw;
+		return {
+			id: String(msg.ts ?? "0"),
+			text: String(msg.text ?? ""),
+			from: this.normalizeSender({ id: msg.userId ?? msg.user }),
+			timestamp: Math.floor(Number.parseFloat(String(msg.ts ?? "0"))),
+			conversationId: String(msg.channelId ?? msg.channel ?? ""),
+			platform: { ts: msg.ts }
+		};
+	}
+	normalizeSender(raw) {
+		return {
+			id: String(raw.id ?? "0"),
+			name: String(raw.name ?? raw.id ?? ""),
+			isBot: raw.isBot
+		};
+	}
+	async listRootActions(_ctx) {
+		return { data: [
+			this.buildEntry("/.actions/add-bot", { meta: { description: "Add a bot instance at runtime" } }),
+			this.buildEntry("/.actions/remove-bot", { meta: { description: "Remove a bot instance" } }),
+			this.buildEntry("/.actions/process-event", { meta: { description: "Process an incoming Slack Events API payload" } })
+		] };
+	}
+	async execProcessEvent(_ctx, args) {
+		this._processEvent(args);
+		return {
+			success: true,
+			data: { ok: true }
+		};
+	}
+	/** Process a Slack Events API payload — delegates to emitMessageReceived(). */
+	_processEvent(payload) {
+		const parsed = require_client.SlackClient.parseEvent(payload);
+		if (!parsed) return;
+		if (parsed.type === "url_verification") return;
+		const { text, userId, channelId, ts } = parsed;
+		const botName = this._botOrder[0] ?? "default";
+		this.emitMessageReceived(botName, {
+			id: ts,
+			text,
+			from: {
+				id: userId,
+				name: userId
+			},
+			timestamp: Math.floor(Number.parseFloat(ts)),
+			conversationId: channelId,
+			platform: {
+				ts,
+				userId
+			}
+		});
+	}
+	/** Add a channel to a bot. Defaults to first bot. */
+	addChannel(channelId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (!convs || convs.has(channelId)) return;
+		convs.add(channelId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers && !buffers.has(channelId)) buffers.set(channelId, []);
+	}
+	/** Remove a channel from a bot. */
+	removeChannel(channelId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (convs) convs.delete(channelId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers) buffers.delete(channelId);
+	}
+	/** Add a message to the ring buffer directly. Public for testing/conformance. */
+	_addToBuffer(channelId, msg) {
+		const botName = this._botOrder[0] ?? "default";
+		const convs = this._botConversations.get(botName);
+		if (convs && !convs.has(channelId)) convs.add(channelId);
+		let botBuffers = this._botBuffers.get(botName);
+		if (!botBuffers) {
+			botBuffers = /* @__PURE__ */ new Map();
+			this._botBuffers.set(botName, botBuffers);
+		}
+		let buffer = botBuffers.get(channelId);
+		if (!buffer) {
+			buffer = [];
+			botBuffers.set(channelId, buffer);
+		}
+		buffer.push({
+			id: msg.ts,
+			text: msg.text,
+			from: {
+				id: msg.userId,
+				name: msg.userId
+			},
+			timestamp: msg.date,
+			conversationId: channelId,
+			platform: { ts: msg.ts }
+		});
+		while (buffer.length > this._bufferSize) buffer.shift();
+	}
+};
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/")], AFSSlack.prototype, "listRootActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "process-event")], AFSSlack.prototype, "execProcessEvent", null);
+
+//#endregion
+exports.AFSSlack = AFSSlack;

package/dist/index.d.cts

@@ -0,0 +1,97 @@
+import { SlackClient } from "./client.cjs";
+import { AFSExecResult, AFSListResult, ProviderTreeSchema } from "@aigne/afs";
+import { RouteContext } from "@aigne/afs/provider";
+import { BaseMessageProvider, BotConfig, BufferedMessage, MessageCapabilities, MessageSender, SendOptions } from "@aigne/afs-messaging";
+
+//#region src/index.d.ts
+interface AFSSlackOptions {
+  /** Multi-bot config */
+  bots?: Array<{
+    name: string;
+    botToken?: string;
+    webhook?: string;
+    channels?: string[];
+    apiBase?: string;
+  }>;
+  /** Single-bot backward compat: webhook URL */
+  webhook?: string;
+  /** Single-bot backward compat: bot token */
+  botToken?: string;
+  /** Single-bot backward compat: channel IDs */
+  channels?: string[];
+  apiBase?: string;
+  bufferSize?: number;
+}
+declare class AFSSlack extends BaseMessageProvider {
+  static manifest(): {
+    name: string;
+    description: string;
+    uriTemplate: string;
+    category: string;
+    schema: {
+      type: string;
+      properties: {
+        botToken: {
+          type: string;
+          description: string;
+          sensitive: boolean;
+        };
+        webhook: {
+          type: string;
+          description: string;
+          sensitive: boolean;
+        };
+        channels: {
+          type: string;
+          items: {
+            type: string;
+          };
+          description: string;
+        };
+      };
+    };
+    tags: string[];
+    capabilityTags: string[];
+    security: {
+      riskLevel: string;
+      resourceAccess: string[];
+      notes: string[];
+    };
+    capabilities: {
+      network: {
+        egress: boolean;
+        allowedDomains: string[];
+      };
+    };
+  };
+  static treeSchema(): ProviderTreeSchema;
+  readonly providerName = "slack";
+  readonly eventPrefix = "slack";
+  constructor(options: AFSSlackOptions);
+  getMessageCapabilities(): MessageCapabilities;
+  createBotClient(config: BotConfig): SlackClient;
+  sendMessage(client: unknown, convId: string, text: string, opts?: SendOptions): Promise<{
+    messageId: string;
+  }>;
+  sendTypingIndicator(_client: unknown, _convId: string): Promise<void>;
+  normalizeMessage(raw: Record<string, unknown>): BufferedMessage;
+  normalizeSender(raw: Record<string, unknown>): MessageSender;
+  listRootActions(_ctx: RouteContext): Promise<AFSListResult>;
+  execProcessEvent(_ctx: RouteContext, args: Record<string, unknown>): Promise<AFSExecResult>;
+  /** Process a Slack Events API payload — delegates to emitMessageReceived(). */
+  _processEvent(payload: any): void;
+  /** Add a channel to a bot. Defaults to first bot. */
+  addChannel(channelId: string, botName?: string): void;
+  /** Remove a channel from a bot. */
+  removeChannel(channelId: string, botName?: string): void;
+  /** Add a message to the ring buffer directly. Public for testing/conformance. */
+  _addToBuffer(channelId: string, msg: {
+    ts: string;
+    text: string;
+    userId: string;
+    date: number;
+  }): void;
+}
+//#endregion
+export { AFSSlack, AFSSlackOptions, type SlackClient };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;UAoCiB,eAAA;EAyFM;EAvFrB,IAAA,GAAO,KAAA;IACL,IAAA;IACA,QAAA;IACA,OAAA;IACA,QAAA;IACA,OAAA;EAAA;EAwK8C;EArKhD,OAAA;EAiL+C;EA/K/C,QAAA;EA0LmD;EAxLnD,QAAA;EACA,OAAA;EACA,UAAA;AAAA;AAAA,cAGW,QAAA,SAAiB,mBAAA;EAAA,OACrB,QAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAqCA,UAAA,CAAA,GAAc,kBAAA;EAAA,SA6BZ,YAAA;EAAA,SACA,WAAA;cAEG,OAAA,EAAS,eAAA;EA2BrB,sBAAA,CAAA,GAA0B,mBAAA;EAsB1B,eAAA,CAAgB,MAAA,EAAQ,SAAA,GAAY,WAAA;EAc9B,WAAA,CACJ,MAAA,WACA,MAAA,UACA,IAAA,UACA,IAAA,GAAO,WAAA,GACN,OAAA;IAAU,SAAA;EAAA;EAgBP,mBAAA,CAAoB,OAAA,WAAkB,OAAA,WAAkB,OAAA;EAE9D,gBAAA,CAAiB,GAAA,EAAK,MAAA,oBAA0B,eAAA;EAYhD,eAAA,CAAgB,GAAA,EAAK,MAAA,oBAA0B,aAAA;EAWzC,eAAA,CAAgB,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,aAAA;EAiB7C,gBAAA,CACJ,IAAA,EAAM,YAAA,EACN,IAAA,EAAM,MAAA,oBACL,OAAA,CAAQ,aAAA;EA7DE;EAqEb,aAAA,CAAc,OAAA;EArDY;EA0E1B,UAAA,CAAW,SAAA,UAAmB,OAAA;EA1EgC;EAuF9D,aAAA,CAAc,SAAA,UAAmB,OAAA;EArFX;EA+FtB,YAAA,CACE,SAAA,UACA,GAAA;IAAO,EAAA;IAAY,IAAA;IAAc,MAAA;IAAgB,IAAA;EAAA;AAAA"}

package/dist/index.d.mts

@@ -0,0 +1,97 @@
+import { SlackClient } from "./client.mjs";
+import { RouteContext } from "@aigne/afs/provider";
+import { BaseMessageProvider, BotConfig, BufferedMessage, MessageCapabilities, MessageSender, SendOptions } from "@aigne/afs-messaging";
+import { AFSExecResult, AFSListResult, ProviderTreeSchema } from "@aigne/afs";
+
+//#region src/index.d.ts
+interface AFSSlackOptions {
+  /** Multi-bot config */
+  bots?: Array<{
+    name: string;
+    botToken?: string;
+    webhook?: string;
+    channels?: string[];
+    apiBase?: string;
+  }>;
+  /** Single-bot backward compat: webhook URL */
+  webhook?: string;
+  /** Single-bot backward compat: bot token */
+  botToken?: string;
+  /** Single-bot backward compat: channel IDs */
+  channels?: string[];
+  apiBase?: string;
+  bufferSize?: number;
+}
+declare class AFSSlack extends BaseMessageProvider {
+  static manifest(): {
+    name: string;
+    description: string;
+    uriTemplate: string;
+    category: string;
+    schema: {
+      type: string;
+      properties: {
+        botToken: {
+          type: string;
+          description: string;
+          sensitive: boolean;
+        };
+        webhook: {
+          type: string;
+          description: string;
+          sensitive: boolean;
+        };
+        channels: {
+          type: string;
+          items: {
+            type: string;
+          };
+          description: string;
+        };
+      };
+    };
+    tags: string[];
+    capabilityTags: string[];
+    security: {
+      riskLevel: string;
+      resourceAccess: string[];
+      notes: string[];
+    };
+    capabilities: {
+      network: {
+        egress: boolean;
+        allowedDomains: string[];
+      };
+    };
+  };
+  static treeSchema(): ProviderTreeSchema;
+  readonly providerName = "slack";
+  readonly eventPrefix = "slack";
+  constructor(options: AFSSlackOptions);
+  getMessageCapabilities(): MessageCapabilities;
+  createBotClient(config: BotConfig): SlackClient;
+  sendMessage(client: unknown, convId: string, text: string, opts?: SendOptions): Promise<{
+    messageId: string;
+  }>;
+  sendTypingIndicator(_client: unknown, _convId: string): Promise<void>;
+  normalizeMessage(raw: Record<string, unknown>): BufferedMessage;
+  normalizeSender(raw: Record<string, unknown>): MessageSender;
+  listRootActions(_ctx: RouteContext): Promise<AFSListResult>;
+  execProcessEvent(_ctx: RouteContext, args: Record<string, unknown>): Promise<AFSExecResult>;
+  /** Process a Slack Events API payload — delegates to emitMessageReceived(). */
+  _processEvent(payload: any): void;
+  /** Add a channel to a bot. Defaults to first bot. */
+  addChannel(channelId: string, botName?: string): void;
+  /** Remove a channel from a bot. */
+  removeChannel(channelId: string, botName?: string): void;
+  /** Add a message to the ring buffer directly. Public for testing/conformance. */
+  _addToBuffer(channelId: string, msg: {
+    ts: string;
+    text: string;
+    userId: string;
+    date: number;
+  }): void;
+}
+//#endregion
+export { AFSSlack, AFSSlackOptions, type SlackClient };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;UAoCiB,eAAA;EAyFM;EAvFrB,IAAA,GAAO,KAAA;IACL,IAAA;IACA,QAAA;IACA,OAAA;IACA,QAAA;IACA,OAAA;EAAA;EAwK8C;EArKhD,OAAA;EAiL+C;EA/K/C,QAAA;EA0LmD;EAxLnD,QAAA;EACA,OAAA;EACA,UAAA;AAAA;AAAA,cAGW,QAAA,SAAiB,mBAAA;EAAA,OACrB,QAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAqCA,UAAA,CAAA,GAAc,kBAAA;EAAA,SA6BZ,YAAA;EAAA,SACA,WAAA;cAEG,OAAA,EAAS,eAAA;EA2BrB,sBAAA,CAAA,GAA0B,mBAAA;EAsB1B,eAAA,CAAgB,MAAA,EAAQ,SAAA,GAAY,WAAA;EAc9B,WAAA,CACJ,MAAA,WACA,MAAA,UACA,IAAA,UACA,IAAA,GAAO,WAAA,GACN,OAAA;IAAU,SAAA;EAAA;EAgBP,mBAAA,CAAoB,OAAA,WAAkB,OAAA,WAAkB,OAAA;EAE9D,gBAAA,CAAiB,GAAA,EAAK,MAAA,oBAA0B,eAAA;EAYhD,eAAA,CAAgB,GAAA,EAAK,MAAA,oBAA0B,aAAA;EAWzC,eAAA,CAAgB,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,aAAA;EAiB7C,gBAAA,CACJ,IAAA,EAAM,YAAA,EACN,IAAA,EAAM,MAAA,oBACL,OAAA,CAAQ,aAAA;EA7DE;EAqEb,aAAA,CAAc,OAAA;EArDY;EA0E1B,UAAA,CAAW,SAAA,UAAmB,OAAA;EA1EgC;EAuF9D,aAAA,CAAc,SAAA,UAAmB,OAAA;EArFX;EA+FtB,YAAA,CACE,SAAA,UACA,GAAA;IAAO,EAAA;IAAY,IAAA;IAAc,MAAA;IAAgB,IAAA;EAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,289 @@
+import { SlackClient } from "./client.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs";
+import { Actions } from "@aigne/afs/provider";
+import { BaseMessageProvider } from "@aigne/afs-messaging";
+
+//#region src/index.ts
+var AFSSlack = class extends BaseMessageProvider {
+	static manifest() {
+		return {
+			name: "slack",
+			description: "Slack messaging — webhook (outbound) or Bot API (bidirectional).\n- Incoming Webhook for simple notifications\n- Bot token + Events API for full interaction\n- Path: /:bot/conversations/:channelId/messages/:ts",
+			uriTemplate: "slack://{botToken}",
+			category: "messaging",
+			schema: {
+				type: "object",
+				properties: {
+					botToken: {
+						type: "string",
+						description: "Slack Bot OAuth token",
+						sensitive: true
+					},
+					webhook: {
+						type: "string",
+						description: "Incoming Webhook URL",
+						sensitive: true
+					},
+					channels: {
+						type: "array",
+						items: { type: "string" },
+						description: "Channel IDs"
+					}
+				}
+			},
+			tags: [
+				"slack",
+				"messaging",
+				"chat",
+				"workspace"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:token",
+				"remote",
+				"http",
+				"real-time",
+				"rate-limited"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet"],
+				notes: ["Connects to Slack API — requires bot token or webhook URL"]
+			},
+			capabilities: { network: {
+				egress: true,
+				allowedDomains: ["slack.com"]
+			} }
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "messaging:root",
+					operations: ["list", "exec"],
+					actions: [
+						"add-bot",
+						"remove-bot",
+						"process-event"
+					]
+				},
+				"/{bot}": {
+					kind: "messaging:bot",
+					operations: ["list", "read"]
+				},
+				"/{bot}/ctl": {
+					kind: "messaging:status",
+					operations: ["read"]
+				},
+				"/{bot}/conversations": {
+					kind: "messaging:conversations",
+					operations: ["list"]
+				},
+				"/{bot}/conversations/{convId}": {
+					kind: "messaging:conversation",
+					operations: ["list"]
+				},
+				"/{bot}/conversations/{convId}/messages": {
+					kind: "messaging:messages",
+					operations: ["list", "exec"],
+					actions: ["send"]
+				},
+				"/{bot}/conversations/{convId}/messages/{msgId}": {
+					kind: "messaging:message",
+					operations: ["read"]
+				}
+			},
+			auth: {
+				type: "token",
+				env: ["SLACK_BOT_TOKEN"]
+			},
+			bestFor: [
+				"team notifications",
+				"workflow alerts",
+				"chatops"
+			],
+			notFor: ["file storage", "database queries"]
+		};
+	}
+	providerName = "slack";
+	eventPrefix = "slack";
+	constructor(options) {
+		let bots;
+		if (options.bots) bots = options.bots.map((b) => ({
+			...b,
+			conversations: b.channels
+		}));
+		else {
+			if (!options.botToken && !options.webhook) throw new Error("AFSSlack requires either botToken or webhook");
+			bots = [{
+				name: "default",
+				botToken: options.botToken,
+				webhook: options.webhook,
+				conversations: options.channels ?? [],
+				apiBase: options.apiBase
+			}];
+		}
+		super({
+			bots,
+			bufferSize: options.bufferSize
+		});
+	}
+	getMessageCapabilities() {
+		return {
+			formats: {
+				send: ["text", "markdown"],
+				receive: ["text"]
+			},
+			maxMessageLength: 4e4,
+			features: {
+				edit: false,
+				delete: false,
+				reply: true,
+				thread: true,
+				reaction: true,
+				inlineKeyboard: false
+			},
+			limits: {
+				messagesPerSecond: 1,
+				messagesPerMinute: 60
+			}
+		};
+	}
+	createBotClient(config) {
+		const botToken = config.botToken;
+		const webhook = config.webhook;
+		const apiBase = config.apiBase;
+		if (botToken) return SlackClient.bot({
+			botToken,
+			apiBase
+		});
+		if (webhook) return SlackClient.webhook(webhook);
+		throw new Error(`Slack bot "${config.name}" requires botToken or webhook`);
+	}
+	async sendMessage(client, convId, text, opts) {
+		const sc = client;
+		const blocks = opts?.blocks;
+		const safeText = SlackClient.escapeSlack(text);
+		if (sc.mode === "bot") return { messageId: (await sc.postMessage(convId, safeText, { blocks })).ts };
+		await sc.sendWebhook(safeText, { blocks });
+		return { messageId: String(Date.now()) };
+	}
+	async sendTypingIndicator(_client, _convId) {}
+	normalizeMessage(raw) {
+		const msg = raw;
+		return {
+			id: String(msg.ts ?? "0"),
+			text: String(msg.text ?? ""),
+			from: this.normalizeSender({ id: msg.userId ?? msg.user }),
+			timestamp: Math.floor(Number.parseFloat(String(msg.ts ?? "0"))),
+			conversationId: String(msg.channelId ?? msg.channel ?? ""),
+			platform: { ts: msg.ts }
+		};
+	}
+	normalizeSender(raw) {
+		return {
+			id: String(raw.id ?? "0"),
+			name: String(raw.name ?? raw.id ?? ""),
+			isBot: raw.isBot
+		};
+	}
+	async listRootActions(_ctx) {
+		return { data: [
+			this.buildEntry("/.actions/add-bot", { meta: { description: "Add a bot instance at runtime" } }),
+			this.buildEntry("/.actions/remove-bot", { meta: { description: "Remove a bot instance" } }),
+			this.buildEntry("/.actions/process-event", { meta: { description: "Process an incoming Slack Events API payload" } })
+		] };
+	}
+	async execProcessEvent(_ctx, args) {
+		this._processEvent(args);
+		return {
+			success: true,
+			data: { ok: true }
+		};
+	}
+	/** Process a Slack Events API payload — delegates to emitMessageReceived(). */
+	_processEvent(payload) {
+		const parsed = SlackClient.parseEvent(payload);
+		if (!parsed) return;
+		if (parsed.type === "url_verification") return;
+		const { text, userId, channelId, ts } = parsed;
+		const botName = this._botOrder[0] ?? "default";
+		this.emitMessageReceived(botName, {
+			id: ts,
+			text,
+			from: {
+				id: userId,
+				name: userId
+			},
+			timestamp: Math.floor(Number.parseFloat(ts)),
+			conversationId: channelId,
+			platform: {
+				ts,
+				userId
+			}
+		});
+	}
+	/** Add a channel to a bot. Defaults to first bot. */
+	addChannel(channelId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (!convs || convs.has(channelId)) return;
+		convs.add(channelId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers && !buffers.has(channelId)) buffers.set(channelId, []);
+	}
+	/** Remove a channel from a bot. */
+	removeChannel(channelId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (convs) convs.delete(channelId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers) buffers.delete(channelId);
+	}
+	/** Add a message to the ring buffer directly. Public for testing/conformance. */
+	_addToBuffer(channelId, msg) {
+		const botName = this._botOrder[0] ?? "default";
+		const convs = this._botConversations.get(botName);
+		if (convs && !convs.has(channelId)) convs.add(channelId);
+		let botBuffers = this._botBuffers.get(botName);
+		if (!botBuffers) {
+			botBuffers = /* @__PURE__ */ new Map();
+			this._botBuffers.set(botName, botBuffers);
+		}
+		let buffer = botBuffers.get(channelId);
+		if (!buffer) {
+			buffer = [];
+			botBuffers.set(channelId, buffer);
+		}
+		buffer.push({
+			id: msg.ts,
+			text: msg.text,
+			from: {
+				id: msg.userId,
+				name: msg.userId
+			},
+			timestamp: msg.date,
+			conversationId: channelId,
+			platform: { ts: msg.ts }
+		});
+		while (buffer.length > this._bufferSize) buffer.shift();
+	}
+};
+__decorate([Actions("/")], AFSSlack.prototype, "listRootActions", null);
+__decorate([Actions.Exec("/", "process-event")], AFSSlack.prototype, "execProcessEvent", null);
+
+//#endregion
+export { AFSSlack };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * AFSSlack — AFS provider for Slack.\n *\n * Extends BaseMessageProvider (Plan 9 model).\n * Path structure (from base):\n *   /                                                → List bots\n *   /:botName/ctl                                    → Bot status\n *   /:botName/conversations/:channelId/messages       → List messages\n *   /:botName/conversations/:channelId/messages/:ts   → Read message\n *\n * Supports two modes:\n *   - Webhook mode (outbound only): Send messages via Incoming Webhook\n *   - Bot mode (bidirectional): Send via Bot API + receive Events API\n *\n * Additional Slack actions:\n *   /.actions/process-event → Process incoming Slack Events API payload\n *\n * Standard events (from base):\n *   messaging:message → Inbound text message\n *   messaging:command → Inbound /command\n */\n\nimport type { AFSExecResult, AFSListResult, ProviderTreeSchema } from \"@aigne/afs\";\nimport { Actions, type RouteContext } from \"@aigne/afs/provider\";\nimport type {\n  BotConfig,\n  BufferedMessage,\n  MessageCapabilities,\n  MessageSender,\n  SendOptions,\n} from \"@aigne/afs-messaging\";\nimport { BaseMessageProvider } from \"@aigne/afs-messaging\";\nimport { SlackClient } from \"./client.js\";\n\nexport type { SlackClient } from \"./client.js\";\n\nexport interface AFSSlackOptions {\n  /** Multi-bot config */\n  bots?: Array<{\n    name: string;\n    botToken?: string;\n    webhook?: string;\n    channels?: string[];\n    apiBase?: string;\n  }>;\n  /** Single-bot backward compat: webhook URL */\n  webhook?: string;\n  /** Single-bot backward compat: bot token */\n  botToken?: string;\n  /** Single-bot backward compat: channel IDs */\n  channels?: string[];\n  apiBase?: string;\n  bufferSize?: number;\n}\n\nexport class AFSSlack extends BaseMessageProvider {\n  static manifest() {\n    return {\n      name: \"slack\",\n      description:\n        \"Slack messaging — webhook (outbound) or Bot API (bidirectional).\\n- Incoming Webhook for simple notifications\\n- Bot token + Events API for full interaction\\n- Path: /:bot/conversations/:channelId/messages/:ts\",\n      uriTemplate: \"slack://{botToken}\",\n      category: \"messaging\",\n      schema: {\n        type: \"object\",\n        properties: {\n          botToken: { type: \"string\", description: \"Slack Bot OAuth token\", sensitive: true },\n          webhook: { type: \"string\", description: \"Incoming Webhook URL\", sensitive: true },\n          channels: { type: \"array\", items: { type: \"string\" }, description: \"Channel IDs\" },\n        },\n      },\n      tags: [\"slack\", \"messaging\", \"chat\", \"workspace\"],\n      capabilityTags: [\n        \"read-write\",\n        \"crud\",\n        \"search\",\n        \"auth:token\",\n        \"remote\",\n        \"http\",\n        \"real-time\",\n        \"rate-limited\",\n      ],\n      security: {\n        riskLevel: \"external\",\n        resourceAccess: [\"internet\"],\n        notes: [\"Connects to Slack API — requires bot token or webhook URL\"],\n      },\n      capabilities: {\n        network: { egress: true, allowedDomains: [\"slack.com\"] },\n      },\n    };\n  }\n\n  static treeSchema(): ProviderTreeSchema {\n    return {\n      operations: [\"list\", \"read\", \"exec\", \"stat\", \"explain\"],\n      tree: {\n        \"/\": {\n          kind: \"messaging:root\",\n          operations: [\"list\", \"exec\"],\n          actions: [\"add-bot\", \"remove-bot\", \"process-event\"],\n        },\n        \"/{bot}\": { kind: \"messaging:bot\", operations: [\"list\", \"read\"] },\n        \"/{bot}/ctl\": { kind: \"messaging:status\", operations: [\"read\"] },\n        \"/{bot}/conversations\": { kind: \"messaging:conversations\", operations: [\"list\"] },\n        \"/{bot}/conversations/{convId}\": { kind: \"messaging:conversation\", operations: [\"list\"] },\n        \"/{bot}/conversations/{convId}/messages\": {\n          kind: \"messaging:messages\",\n          operations: [\"list\", \"exec\"],\n          actions: [\"send\"],\n        },\n        \"/{bot}/conversations/{convId}/messages/{msgId}\": {\n          kind: \"messaging:message\",\n          operations: [\"read\"],\n        },\n      },\n      auth: { type: \"token\", env: [\"SLACK_BOT_TOKEN\"] },\n      bestFor: [\"team notifications\", \"workflow alerts\", \"chatops\"],\n      notFor: [\"file storage\", \"database queries\"],\n    };\n  }\n\n  readonly providerName = \"slack\";\n  readonly eventPrefix = \"slack\";\n\n  constructor(options: AFSSlackOptions) {\n    let bots: BotConfig[];\n    if (options.bots) {\n      bots = options.bots.map((b) => ({\n        ...b,\n        conversations: b.channels,\n      }));\n    } else {\n      if (!options.botToken && !options.webhook) {\n        throw new Error(\"AFSSlack requires either botToken or webhook\");\n      }\n      bots = [\n        {\n          name: \"default\",\n          botToken: options.botToken,\n          webhook: options.webhook,\n          conversations: options.channels ?? [],\n          apiBase: options.apiBase,\n        },\n      ];\n    }\n\n    super({ bots, bufferSize: options.bufferSize });\n  }\n\n  // ─── Abstract Implementation ─────────────────────────\n\n  getMessageCapabilities(): MessageCapabilities {\n    return {\n      formats: {\n        send: [\"text\", \"markdown\"],\n        receive: [\"text\"],\n      },\n      maxMessageLength: 40000,\n      features: {\n        edit: false,\n        delete: false,\n        reply: true,\n        thread: true,\n        reaction: true,\n        inlineKeyboard: false,\n      },\n      limits: {\n        messagesPerSecond: 1,\n        messagesPerMinute: 60,\n      },\n    };\n  }\n\n  createBotClient(config: BotConfig): SlackClient {\n    const botToken = config.botToken as string | undefined;\n    const webhook = config.webhook as string | undefined;\n    const apiBase = config.apiBase as string | undefined;\n\n    if (botToken) {\n      return SlackClient.bot({ botToken, apiBase });\n    }\n    if (webhook) {\n      return SlackClient.webhook(webhook);\n    }\n    throw new Error(`Slack bot \"${config.name}\" requires botToken or webhook`);\n  }\n\n  async sendMessage(\n    client: unknown,\n    convId: string,\n    text: string,\n    opts?: SendOptions,\n  ): Promise<{ messageId: string }> {\n    const sc = client as SlackClient;\n    const blocks = opts?.blocks as unknown[] | undefined;\n    // Escape Slack special characters to prevent injection (<!channel>, phishing links, etc.)\n    const safeText = SlackClient.escapeSlack(text);\n\n    if (sc.mode === \"bot\") {\n      const result = await sc.postMessage(convId, safeText, { blocks });\n      return { messageId: result.ts };\n    }\n\n    // Webhook mode — can't target specific channel\n    await sc.sendWebhook(safeText, { blocks });\n    return { messageId: String(Date.now()) };\n  }\n\n  async sendTypingIndicator(_client: unknown, _convId: string): Promise<void> {}\n\n  normalizeMessage(raw: Record<string, unknown>): BufferedMessage {\n    const msg = raw as any;\n    return {\n      id: String(msg.ts ?? \"0\"),\n      text: String(msg.text ?? \"\"),\n      from: this.normalizeSender({ id: msg.userId ?? msg.user }),\n      timestamp: Math.floor(Number.parseFloat(String(msg.ts ?? \"0\"))),\n      conversationId: String(msg.channelId ?? msg.channel ?? \"\"),\n      platform: { ts: msg.ts },\n    };\n  }\n\n  normalizeSender(raw: Record<string, unknown>): MessageSender {\n    return {\n      id: String(raw.id ?? \"0\"),\n      name: String(raw.name ?? raw.id ?? \"\"),\n      isBot: raw.isBot as boolean | undefined,\n    };\n  }\n\n  // ─── Slack-specific Actions ─────────────────────────\n\n  @Actions(\"/\")\n  async listRootActions(_ctx: RouteContext): Promise<AFSListResult> {\n    return {\n      data: [\n        this.buildEntry(\"/.actions/add-bot\", {\n          meta: { description: \"Add a bot instance at runtime\" },\n        }),\n        this.buildEntry(\"/.actions/remove-bot\", {\n          meta: { description: \"Remove a bot instance\" },\n        }),\n        this.buildEntry(\"/.actions/process-event\", {\n          meta: { description: \"Process an incoming Slack Events API payload\" },\n        }),\n      ],\n    };\n  }\n\n  @Actions.Exec(\"/\", \"process-event\")\n  async execProcessEvent(\n    _ctx: RouteContext,\n    args: Record<string, unknown>,\n  ): Promise<AFSExecResult> {\n    this._processEvent(args);\n    return { success: true, data: { ok: true } };\n  }\n\n  // ─── Event Processing (public for testing) ────────────\n\n  /** Process a Slack Events API payload — delegates to emitMessageReceived(). */\n  _processEvent(payload: any): void {\n    const parsed = SlackClient.parseEvent(payload);\n    if (!parsed) return;\n    if (parsed.type === \"url_verification\") return;\n\n    const { text, userId, channelId, ts } = parsed;\n    const botName = this._botOrder[0] ?? \"default\";\n\n    this.emitMessageReceived(botName, {\n      id: ts,\n      text,\n      from: { id: userId, name: userId },\n      timestamp: Math.floor(Number.parseFloat(ts)),\n      conversationId: channelId,\n      platform: { ts, userId },\n    });\n  }\n\n  // ─── Convenience Methods (backward compat) ─────────────\n\n  /** Add a channel to a bot. Defaults to first bot. */\n  addChannel(channelId: string, botName?: string): void {\n    const name = botName ?? this._botOrder[0];\n    if (!name) return;\n    const convs = this._botConversations.get(name);\n    if (!convs || convs.has(channelId)) return;\n    convs.add(channelId);\n    const buffers = this._botBuffers.get(name);\n    if (buffers && !buffers.has(channelId)) {\n      buffers.set(channelId, []);\n    }\n  }\n\n  /** Remove a channel from a bot. */\n  removeChannel(channelId: string, botName?: string): void {\n    const name = botName ?? this._botOrder[0];\n    if (!name) return;\n    const convs = this._botConversations.get(name);\n    if (convs) convs.delete(channelId);\n    const buffers = this._botBuffers.get(name);\n    if (buffers) buffers.delete(channelId);\n  }\n\n  /** Add a message to the ring buffer directly. Public for testing/conformance. */\n  _addToBuffer(\n    channelId: string,\n    msg: { ts: string; text: string; userId: string; date: number },\n  ): void {\n    const botName = this._botOrder[0] ?? \"default\";\n\n    // Auto-add conversation\n    const convs = this._botConversations.get(botName);\n    if (convs && !convs.has(channelId)) {\n      convs.add(channelId);\n    }\n\n    // Add to buffer directly (no event emission — for test setup)\n    let botBuffers = this._botBuffers.get(botName);\n    if (!botBuffers) {\n      botBuffers = new Map();\n      this._botBuffers.set(botName, botBuffers);\n    }\n    let buffer = botBuffers.get(channelId);\n    if (!buffer) {\n      buffer = [];\n      botBuffers.set(channelId, buffer);\n    }\n    buffer.push({\n      id: msg.ts,\n      text: msg.text,\n      from: { id: msg.userId, name: msg.userId },\n      timestamp: msg.date,\n      conversationId: channelId,\n      platform: { ts: msg.ts },\n    });\n    while (buffer.length > this._bufferSize) {\n      buffer.shift();\n    }\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@aigne/afs-slack",
+  "version": "1.11.0-beta.12",
+  "description": "AIGNE AFS provider for Slack (webhook + bot modes)",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Arcblock <blocklet@arcblock.io> https://github.com/arcblock",
+  "homepage": "https://github.com/arcblock/afs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arcblock/afs"
+  },
+  "bugs": {
+    "url": "https://github.com/arcblock/afs/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    },
+    "./*": "./*"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@aigne/afs": "^1.11.0-beta.12",
+    "@aigne/afs-messaging": "^1.11.0-beta.12"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.6",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^6.1.2",
+    "tsdown": "0.20.0-beta.3",
+    "typescript": "5.9.2",
+    "@aigne/scripts": "0.0.0",
+    "@aigne/typescript-config": "0.0.0",
+    "@aigne/afs-testing": "1.11.0-beta.12"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check-types": "tsc --noEmit",
+    "clean": "rimraf dist coverage",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter=lcov --coverage-reporter=text"
+  }
+}