@interactive-inc/claude-funnel 0.60.1 → 0.64.0

package/dist/slack-connector-CxpWagbT.js

@@ -0,0 +1,388 @@
+import { t as NodeFunnelHttpClient } from "./node-http-client-u00atiKx.js";
+import { t as FunnelAuthFailedError } from "./funnel-error-0t1MK1R6.js";
+import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
+import { t as slackConnectorSchema } from "./slack-connector-schema-Dem8to4P.js";
+import { t as FunnelConnectorAdapter } from "./connector-adapter-Dvs8N7ew.js";
+import { t as FunnelSlackEventProcessor } from "./slack-event-processor-xFDG3US0.js";
+import { t as resolveConnectorToken } from "./resolve-connector-token-DxDG9mhf.js";
+import { i as resolveFlumeDeps, n as FunnelFlumeSourceListener, r as flumeLogHandler, t as slotFields } from "./slot-fields-D-pvMgTK.js";
+import { z } from "zod";
+import { FlumeSlackSource } from "@interactive-inc/flume/slack";
+//#region lib/engine/connectors/slack-adapter.ts
+const SLACK_API_BASE = "https://slack.com/api/";
+const toRecord = (value) => {
+	const result = {};
+	for (const [key, val] of Object.entries(value)) result[key] = val;
+	return result;
+};
+/**
+* Slack Web API adapter over the injected `FunnelHttpClient`. `call()` posts
+* to `https://slack.com/api/<method>` with `Authorization: Bearer <botToken>`
+* and returns the parsed JSON body verbatim — Slack signals failures with
+* `{ ok: false, error: "..." }` in a 200 response, so we surface that body
+* unchanged and let the caller inspect `ok`.
+*/
+var FunnelSlackAdapter = class extends FunnelConnectorAdapter {
+	token;
+	http;
+	constructor(deps) {
+		super();
+		this.token = resolveConnectorToken({
+			literal: deps.config.botToken,
+			envVar: deps.config.botTokenEnv,
+			env: deps.env ?? process.env,
+			label: `${deps.config.name}.botToken`
+		});
+		this.http = deps.http ?? new NodeFunnelHttpClient();
+		Object.freeze(this);
+	}
+	async call(input) {
+		const url = `${SLACK_API_BASE}${input.path}`;
+		const body = input.body !== null && typeof input.body === "object" ? toRecord(input.body) : {};
+		const form = new URLSearchParams();
+		for (const [key, value] of Object.entries(body)) form.set(key, typeof value === "string" ? value : JSON.stringify(value));
+		const text = await (await this.http.fetch({
+			method: "POST",
+			url,
+			headers: {
+				Authorization: `Bearer ${this.token}`,
+				"Content-Type": "application/x-www-form-urlencoded"
+			},
+			body: form.toString()
+		})).text();
+		try {
+			return JSON.parse(text);
+		} catch {
+			return {
+				ok: false,
+				error: `non-JSON response: ${text.slice(0, 200)}`
+			};
+		}
+	}
+	async postMessage(props) {
+		return this.call({
+			method: "post",
+			path: "chat.postMessage",
+			body: {
+				channel: props.channel,
+				text: props.text,
+				...props.threadTs ? { thread_ts: props.threadTs } : {}
+			}
+		});
+	}
+	async addReaction(props) {
+		return this.call({
+			method: "post",
+			path: "reactions.add",
+			body: {
+				channel: props.channel,
+				timestamp: props.timestamp,
+				name: props.name
+			}
+		});
+	}
+	async removeReaction(props) {
+		return this.call({
+			method: "post",
+			path: "reactions.remove",
+			body: {
+				channel: props.channel,
+				timestamp: props.timestamp,
+				name: props.name
+			}
+		});
+	}
+};
+//#endregion
+//#region lib/engine/connectors/slack-flume-listener.ts
+const authTestResponseSchema = z.object({
+	ok: z.boolean(),
+	user_id: z.string().optional(),
+	bot_id: z.string().optional(),
+	error: z.string().optional()
+});
+const AUTH_TEST_URL = "https://slack.com/api/auth.test";
+/**
+* Slack listener backed by `@interactive-inc/flume`'s `FlumeSlackSource` (raw
+* Socket Mode WebSocket + Zod). The processor layer
+* (`FunnelSlackEventProcessor`) is the application layer — self-skip, mention
+* detection, dedup, minify. Self-detection needs `auth.test` to learn the
+* bot's own user/bot id, which the listener calls once at start using the
+* bot token. Flume delivers the events API envelope and nothing else; Bolt's
+* `app.action` / `app.command` / `preprocessEvent` hooks have no equivalent
+* here and must be re-implemented against Slack's HTTP endpoints if needed.
+*/
+var FunnelFlumeSlackListener = class extends FunnelFlumeSourceListener {
+	config;
+	env;
+	flumeDeps;
+	http;
+	signal;
+	preprocessEvent;
+	onInteractive;
+	processor = null;
+	botToken = "";
+	constructor(deps) {
+		super({
+			type: "slack",
+			connectorId: deps.config.id,
+			channelId: deps.channelId ?? null,
+			logger: deps.logger,
+			diagnosticLog: deps.diagnosticLog
+		});
+		this.config = deps.config;
+		this.env = deps.env ?? process.env;
+		this.flumeDeps = deps.flumeDeps ?? {};
+		this.http = deps.http ?? new NodeFunnelHttpClient();
+		this.signal = deps.signal;
+		this.preprocessEvent = deps.preprocessEvent;
+		this.onInteractive = deps.onInteractive;
+	}
+	async start(notify) {
+		this.diagnostics.recordConnection("started", "");
+		let appToken;
+		let botToken;
+		try {
+			appToken = resolveConnectorToken({
+				literal: this.config.appToken,
+				envVar: this.config.appTokenEnv,
+				env: this.env,
+				label: `${this.config.name}.appToken`
+			});
+			botToken = resolveConnectorToken({
+				literal: this.config.botToken,
+				envVar: this.config.botTokenEnv,
+				env: this.env,
+				label: `${this.config.name}.botToken`
+			});
+		} catch (error) {
+			this.diagnostics.recordConnection("auth-failed", errorMessageOf(error));
+			throw error;
+		}
+		this.botToken = botToken;
+		const auth = await this.callAuthTest();
+		if (!auth.ok) {
+			const detail = auth.error ?? "auth.test returned ok=false";
+			this.diagnostics.recordConnection("auth-failed", detail);
+			throw new FunnelAuthFailedError(this.config.name, detail);
+		}
+		this.processor = new FunnelSlackEventProcessor({
+			ownBotUserId: auth.user_id ?? "",
+			ownBotId: auth.bot_id ?? "",
+			minify: this.config.minify
+		});
+		const source = new FlumeSlackSource({
+			appToken,
+			botToken: this.botToken
+		});
+		await this.runStart({
+			source,
+			onLog: flumeLogHandler(this.logger),
+			deps: resolveFlumeDeps(this.flumeDeps),
+			signal: this.signal,
+			onEvent: (event) => {
+				if (event.source !== "slack") return Promise.resolve();
+				return this.handleEvent(event, notify);
+			}
+		});
+	}
+	onStop() {
+		this.processor = null;
+	}
+	async handleInteractive(payload) {
+		const eventId = crypto.randomUUID();
+		const rawJson = JSON.stringify(payload);
+		this.diagnostics.recordRaw(eventId, rawJson);
+		if (!this.onInteractive) {
+			this.diagnostics.recordProcessed(eventId, "skip:no-interactive-handler", "");
+			return;
+		}
+		const subtype = typeof payload.type === "string" ? payload.type : "unknown";
+		try {
+			await this.onInteractive(payload);
+			this.diagnostics.recordProcessed(eventId, `interactive:${subtype}`, "");
+		} catch (error) {
+			const message = errorMessageOf(error);
+			this.diagnostics.recordProcessed(eventId, `interactive-error:${subtype}`, message);
+			this.logger?.error(`slack interactive handler error (${subtype})`, { error: message });
+		}
+	}
+	async callAuthTest() {
+		let text;
+		try {
+			text = await (await this.http.fetch({
+				method: "POST",
+				url: AUTH_TEST_URL,
+				headers: {
+					Authorization: `Bearer ${this.botToken}`,
+					"Content-Type": "application/x-www-form-urlencoded"
+				}
+			})).text();
+		} catch (error) {
+			this.diagnostics.recordConnection("auth-failed", errorMessageOf(error));
+			throw error;
+		}
+		const parsed = authTestResponseSchema.safeParse(safeJsonParse(text));
+		if (!parsed.success) return {
+			ok: false,
+			error: `non-JSON auth.test response: ${text.slice(0, 200)}`
+		};
+		return parsed.data;
+	}
+	async handleEvent(event, notify) {
+		if (!this.processor) return;
+		if (event.type === "interactive") {
+			await this.handleInteractive(event.data);
+			return;
+		}
+		const rawEvent = event.data.event;
+		if (!isSlackRawEvent(rawEvent)) {
+			const skipId = crypto.randomUUID();
+			this.diagnostics.recordRaw(skipId, JSON.stringify(event.data));
+			this.diagnostics.recordProcessed(skipId, "skip:non-object-event", "");
+			return;
+		}
+		const eventId = crypto.randomUUID();
+		const rawJson = JSON.stringify(rawEvent);
+		this.diagnostics.recordRaw(eventId, rawJson);
+		let preprocessed = rawEvent;
+		if (this.preprocessEvent) {
+			const next = await this.preprocessEvent(rawEvent);
+			if (next === null) {
+				this.diagnostics.recordProcessed(eventId, "skip:preprocess", rawJson);
+				return;
+			}
+			preprocessed = next;
+		}
+		const result = this.processor.process(preprocessed);
+		if (result.skip) {
+			this.diagnostics.recordProcessed(eventId, result.reason, rawJson);
+			return;
+		}
+		await this.deliver(notify, eventId, rawJson, result.content, result.meta, result.shouldReact);
+	}
+	async deliver(notify, eventId, rawJson, content, meta, shouldReact) {
+		try {
+			await notify(content, meta);
+		} catch (error) {
+			this.diagnostics.recordProcessed(eventId, "emitted:delivery-failed", content || rawJson);
+			this.logger?.error("slack notify error", { error: errorMessageOf(error) });
+			return;
+		}
+		this.diagnostics.recordProcessed(eventId, "emitted", content);
+		if (shouldReact) this.postReaction(meta).catch((error) => {
+			this.diagnostics.recordProcessed(eventId, "emitted:reaction-failed", errorMessageOf(error));
+			this.logger?.warn("slack reaction failed", { error: errorMessageOf(error) });
+		});
+	}
+	async postReaction(meta) {
+		const res = await this.http.fetch({
+			method: "POST",
+			url: "https://slack.com/api/reactions.add",
+			headers: {
+				Authorization: `Bearer ${this.botToken}`,
+				"Content-Type": "application/x-www-form-urlencoded"
+			},
+			body: new URLSearchParams({
+				channel: meta.channel_id ?? "",
+				timestamp: meta.thread_ts ?? "",
+				name: "eyes"
+			}).toString()
+		});
+		const parsed = parseSlackResponse(await res.text());
+		if (!parsed.ok) throw new Error(`slack reactions.add: ${parsed.error ?? `status=${res.status}`}`);
+	}
+};
+const isSlackRawEvent = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const safeJsonParse = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+};
+const slackResponseSchema = z.object({
+	ok: z.boolean(),
+	error: z.string().optional()
+});
+const parseSlackResponse = (text) => {
+	const parsed = slackResponseSchema.safeParse(safeJsonParse(text));
+	if (!parsed.success) return {
+		ok: false,
+		error: `non-JSON response: ${text.slice(0, 200)}`
+	};
+	return parsed.data;
+};
+//#endregion
+//#region lib/engine/connectors/slack-connector.ts
+/**
+* Slack connector descriptor. Pass `slackConnector()` to
+* `new Funnel({ connectors: [...] })` to enable the type.
+*
+* The listener is backed by `@interactive-inc/flume`'s `FlumeSlackSource`
+* (raw Socket Mode WebSocket). Both the `events_api` envelope (messages,
+* mentions, reactions, …) and the `interactive` envelope (block actions,
+* view submissions, message actions, shortcuts) are delivered — the former
+* runs through the funnel processor and emits notifications, the latter is
+* handed to the optional `onInteractive` host hook (funnel auto-acks the
+* envelope, so the host can respond via the Slack web API at its leisure).
+* Slash commands (`slash_commands` envelope) and Bolt's middleware chain
+* have no equivalent here yet — wire those via the Slack HTTP endpoints if
+* needed.
+*/
+const slackConnector = (options = {}) => ({
+	type: "slack",
+	toolExposed: true,
+	createListener(config, deps) {
+		return new FunnelFlumeSlackListener({
+			config: slackConnectorSchema.parse(config),
+			channelId: deps.channelId,
+			logger: deps.logger,
+			diagnosticLog: deps.diagnosticLog,
+			http: deps.http,
+			signal: deps.signal,
+			preprocessEvent: options.preprocessEvent,
+			onInteractive: options.onInteractive
+		});
+	},
+	createAdapter(config, deps) {
+		return new FunnelSlackAdapter({
+			config: slackConnectorSchema.parse(config),
+			http: deps.http
+		});
+	},
+	secretTokens(config) {
+		const parsed = slackConnectorSchema.parse(config);
+		return [parsed.botToken, parsed.appToken].filter((token) => token !== void 0);
+	},
+	buildConfig(input, context) {
+		return slackConnectorSchema.parse({
+			id: context.id,
+			type: "slack",
+			name: input.name,
+			...typeof input.botToken === "string" ? { botToken: input.botToken } : {},
+			...typeof input.appToken === "string" ? { appToken: input.appToken } : {},
+			...typeof input.botTokenEnv === "string" ? { botTokenEnv: input.botTokenEnv } : {},
+			...typeof input.appTokenEnv === "string" ? { appTokenEnv: input.appTokenEnv } : {},
+			minify: typeof input.minify === "boolean" ? input.minify : true,
+			createdAt: context.now,
+			updatedAt: context.now
+		});
+	},
+	applyUpdate(config, fields, context) {
+		const current = slackConnectorSchema.parse(config);
+		return slackConnectorSchema.parse({
+			id: current.id,
+			name: current.name,
+			type: "slack",
+			minify: current.minify,
+			createdAt: current.createdAt,
+			updatedAt: context.now,
+			...slotFields("botToken", "botTokenEnv", fields, current),
+			...slotFields("appToken", "appTokenEnv", fields, current)
+		});
+	},
+	operations: {}
+});
+//#endregion
+export { FunnelFlumeSlackListener as n, FunnelSlackAdapter as r, slackConnector as t };

package/dist/slack-event-processor-BhCf5Wiy.d.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+
+//#region lib/engine/connectors/slack-connector-schema.d.ts
+/**
+ * A slack connector resolves its tokens one of two ways, set at sync time:
+ *
+ *   - literal: `botToken` / `appToken` hold the real `xoxb-`/`xapp-` secret
+ *     (set by a `fnl channels` command or a TTY prompt at launch).
+ *   - by reference: `botTokenEnv` / `appTokenEnv` hold the *name* of an env var.
+ *     The secret never lands in settings.json; the listener resolves it from
+ *     `process.env` at start. This form is only set through the engine API
+ *     (`new Funnel(...)`) — funnel.json and the `fnl` CLI produce literals.
+ *
+ * Both are optional at the schema level (a discriminated-union member can't
+ * carry a cross-field refine); the listener requires exactly one resolved
+ * token per slot and errors loudly otherwise.
+ */
+declare const slackConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"slack">;
+  botToken: z.ZodOptional<z.ZodString>;
+  appToken: z.ZodOptional<z.ZodString>;
+  botTokenEnv: z.ZodOptional<z.ZodString>;
+  appTokenEnv: z.ZodOptional<z.ZodString>;
+  minify: z.ZodDefault<z.ZodBoolean>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>;
+//#endregion
+//#region lib/engine/connectors/slack-event-types.d.ts
+type SlackMessageEvent = {
+  kind: "message";
+  channel: string;
+  user: string;
+  rawText: string;
+  text: string;
+  threadTs: string;
+  ts: string;
+  isThreadRoot: boolean;
+  mentioned: boolean;
+  source: "app_mention" | "message";
+};
+type SlackReactionEvent = {
+  kind: "reaction_added" | "reaction_removed";
+  channel: string;
+  user: string;
+  emoji: string;
+  targetTs: string;
+  targetUser: string | null;
+};
+type SlackEvent = SlackMessageEvent | SlackReactionEvent;
+//#endregion
+//#region lib/engine/connectors/slack-event-processor.d.ts
+type SlackRawEvent = Record<string, unknown>;
+/**
+ * Why the processor dropped an event. Mirrored verbatim into the diagnostic
+ * log's processed `outcome` column so "Slack delivered it but no notification arrived" is
+ * traceable to the exact gate that dropped it. The listener may additionally
+ * record `skip:preprocess` for events a host preprocessor dropped before the
+ * processor ran — that gate is outside this type.
+ */
+type SlackSkipReason = "skip:type" | "skip:subtype" | "skip:dedup" | "skip:self-user" | "skip:self-bot";
+type SlackProcessedSkip = {
+  skip: true;
+  reason: SlackSkipReason;
+};
+type SlackProcessedEmit = {
+  skip: false;
+  event: SlackEvent;
+  content: string;
+  meta: Record<string, string>;
+  shouldReact: boolean;
+  channel: string;
+  timestamp: string;
+};
+type SlackProcessed = SlackProcessedSkip | SlackProcessedEmit;
+type Props = {
+  ownBotUserId: string;
+  ownBotId: string;
+  minify?: boolean;
+  now?: () => number;
+};
+declare class FunnelSlackEventProcessor {
+  private readonly ownBotUserId;
+  private readonly ownBotId;
+  private readonly minify;
+  private readonly now;
+  private readonly dedup;
+  constructor(props: Props);
+  process(event: SlackRawEvent): SlackProcessed;
+}
+//#endregion
+export { SlackRawEvent as a, SlackMessageEvent as c, slackConnectorSchema as d, SlackProcessedSkip as i, SlackReactionEvent as l, SlackProcessed as n, SlackSkipReason as o, SlackProcessedEmit as r, SlackEvent as s, FunnelSlackEventProcessor as t, SlackConnectorConfig as u };

package/dist/slack-event-processor-xFDG3US0.js

@@ -0,0 +1,176 @@
+//#region lib/engine/connectors/minify-slack-event.ts
+const TOP_LEVEL_KEYS = [
+	"type",
+	"subtype",
+	"user",
+	"bot_id",
+	"text",
+	"ts",
+	"thread_ts",
+	"channel",
+	"channel_type",
+	"files",
+	"attachments"
+];
+const FILE_KEYS = [
+	"id",
+	"name",
+	"mimetype",
+	"filetype",
+	"size",
+	"url_private",
+	"permalink"
+];
+const ATTACHMENT_KEYS = [
+	"title",
+	"text",
+	"fallback"
+];
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const pickDefined = (source, keys) => {
+	const picked = {};
+	for (const key of keys) if (source[key] !== void 0) picked[key] = source[key];
+	return picked;
+};
+const hasThumbOrPreviewKey = (file) => {
+	return Object.keys(file).some((key) => key.startsWith("thumb") || key.startsWith("preview"));
+};
+const minifyFile = (file) => {
+	if (!isRecord(file)) return file;
+	const minified = pickDefined(file, FILE_KEYS);
+	if (hasThumbOrPreviewKey(file)) minified._funnel_omitted = ["thumb_*"];
+	return minified;
+};
+const flattenRichText = (node) => {
+	if (!isRecord(node)) return "";
+	const text = node.text;
+	if (typeof text === "string") return text;
+	const elements = node.elements;
+	if (!Array.isArray(elements)) return "";
+	return elements.map(flattenRichText).join("");
+};
+const flattenTableRow = (row) => {
+	if (!Array.isArray(row)) return "";
+	return row.map(flattenRichText).join("	");
+};
+const flattenBlock = (block) => {
+	if (!isRecord(block)) return "";
+	if (block.type === "table" && Array.isArray(block.rows)) return block.rows.map(flattenTableRow).join("\n");
+	return flattenRichText(block);
+};
+const flattenBlocks = (blocks) => {
+	return blocks.map(flattenBlock).filter((line) => line.length > 0).join("\n");
+};
+const minifyAttachment = (attachment) => {
+	if (!isRecord(attachment)) return attachment;
+	const minified = pickDefined(attachment, ATTACHMENT_KEYS);
+	const blocks = attachment.blocks;
+	if (Array.isArray(blocks)) {
+		const flattened = flattenBlocks(blocks);
+		const existingText = typeof minified.text === "string" ? minified.text : "";
+		minified.text = existingText ? `${existingText}\n${flattened}` : flattened;
+		minified._funnel_omitted = ["blocks"];
+	}
+	return minified;
+};
+const minifySlackEvent = (event) => {
+	const minified = pickDefined(event, TOP_LEVEL_KEYS);
+	if (Array.isArray(minified.files)) minified.files = minified.files.map(minifyFile);
+	if (Array.isArray(minified.attachments)) minified.attachments = minified.attachments.map(minifyAttachment);
+	return minified;
+};
+//#endregion
+//#region lib/engine/connectors/slack-event-processor.ts
+const ALLOWED_EVENTS = new Set(["message", "app_mention"]);
+const ALLOWED_SUBTYPES = new Set([
+	void 0,
+	"thread_broadcast",
+	"bot_message",
+	"file_share"
+]);
+const DEDUP_WINDOW = 1e4;
+const getString = (event, key) => {
+	const value = event[key];
+	return typeof value === "string" ? value : void 0;
+};
+var FunnelSlackEventProcessor = class {
+	ownBotUserId;
+	ownBotId;
+	minify;
+	now;
+	dedup = /* @__PURE__ */ new Map();
+	constructor(props) {
+		this.ownBotUserId = props.ownBotUserId;
+		this.ownBotId = props.ownBotId;
+		this.minify = props.minify ?? true;
+		this.now = props.now ?? (() => Date.now());
+	}
+	process(event) {
+		const eventType = getString(event, "type");
+		if (!eventType || !ALLOWED_EVENTS.has(eventType)) return {
+			skip: true,
+			reason: "skip:type"
+		};
+		const subtype = getString(event, "subtype");
+		if (!ALLOWED_SUBTYPES.has(subtype)) return {
+			skip: true,
+			reason: "skip:subtype"
+		};
+		const channelId = getString(event, "channel") ?? "";
+		const dedupKey = `${channelId}:${getString(event, "event_ts") ?? getString(event, "ts") ?? ""}`;
+		const now = this.now();
+		if (this.dedup.has(dedupKey)) return {
+			skip: true,
+			reason: "skip:dedup"
+		};
+		this.dedup.set(dedupKey, now);
+		for (const key of this.dedup.keys()) if ((this.dedup.get(key) ?? 0) < now - DEDUP_WINDOW) this.dedup.delete(key);
+		const userId = getString(event, "user");
+		const botId = getString(event, "bot_id");
+		if (userId === this.ownBotUserId) return {
+			skip: true,
+			reason: "skip:self-user"
+		};
+		if (botId === this.ownBotId) return {
+			skip: true,
+			reason: "skip:self-bot"
+		};
+		const rawText = getString(event, "text") ?? "";
+		const mentioned = rawText.includes(`<@${this.ownBotUserId}>`);
+		const threadTs = getString(event, "thread_ts") ?? getString(event, "ts") ?? "";
+		const ts = getString(event, "ts") ?? "";
+		const source = eventType === "app_mention" ? "app_mention" : "message";
+		const emitted = this.minify ? minifySlackEvent(event) : event;
+		return {
+			skip: false,
+			event: {
+				kind: "message",
+				channel: channelId,
+				user: userId ?? "",
+				rawText,
+				text: stripMention(rawText, this.ownBotUserId),
+				threadTs,
+				ts,
+				isThreadRoot: threadTs === ts,
+				mentioned,
+				source
+			},
+			content: JSON.stringify(emitted),
+			meta: {
+				event_type: "slack",
+				channel_id: channelId,
+				user_id: userId ?? "",
+				mentioned: String(mentioned),
+				thread_ts: threadTs
+			},
+			shouldReact: mentioned,
+			channel: channelId,
+			timestamp: ts
+		};
+	}
+};
+const stripMention = (text, botUserId) => text.replace(new RegExp(`<@${botUserId}>`, "g"), "").trim();
+//#endregion
+export { FunnelSlackEventProcessor as t };