@interactive-inc/claude-funnel 0.26.1 → 0.27.0

package/dist/resolve-connector-token-Ch6XWMJM.js

@@ -0,0 +1,22 @@
+//#region lib/connectors/resolve-connector-token.ts
+/**
+* Resolves a connector token from either a literal value or the name of an env
+* var. A connector config carries one or the other per slot (see
+* slack-connector-schema): literals are inlined into settings.json, references
+* keep the secret in the environment (`.env.local`) and out of settings.json.
+*
+* Errors loudly when neither yields a value — a misconfigured connector should
+* fail at listener start, not connect with an empty token and silently never
+* receive events.
+*/
+const resolveConnectorToken = (props) => {
+	if (props.literal !== void 0 && props.literal !== "") return props.literal;
+	if (props.envVar !== void 0 && props.envVar !== "") {
+		const fromEnv = props.env[props.envVar];
+		if (fromEnv !== void 0 && fromEnv !== "") return fromEnv;
+		throw new Error(`${props.label} references env var "${props.envVar}" but it is not set in the environment`);
+	}
+	throw new Error(`${props.label} has neither a literal token nor an env var reference`);
+};
+//#endregion
+export { resolveConnectorToken as t };

package/dist/{schedule-connector-schema-CuCjP7z4.js → schedule-connector-schema-CM-sRkac.js}

@@ -1,4 +1,4 @@
-import { n as FunnelConnectorListener } from "./logger-D1A3_JXV.js";
+import { n as FunnelConnectorListener } from "./logger-Czli2OKh.js";
 import { dirname } from "node:path";
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { z } from "zod";
@@ -157,7 +157,9 @@ const MAX_CATCHUP_MINUTES = 1440;
 var FunnelScheduleListener = class extends FunnelConnectorListener {
 	config;
 	lastFiredStore;
+	channelId;
 	logger;
+	diagnosticLog;
 	now;
 	onFired;
 	timer = null;
@@ -166,12 +168,15 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		super();
 		this.config = deps.config;
 		this.lastFiredStore = deps.lastFiredStore;
+		this.channelId = deps.channelId ?? null;
 		this.logger = deps.logger;
+		this.diagnosticLog = deps.diagnosticLog;
 		this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
 		this.onFired = deps.onFired ?? null;
 	}
 	async start(notify) {
 		this.stopped = false;
+		this.recordConnection("started", "");
 		const scheduleNext = () => {
 			if (this.stopped) return;
 			const date = this.now();
@@ -192,6 +197,7 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 			clearTimeout(this.timer);
 			this.timer = null;
 		}
+		this.recordConnection("stopped", "");
 	}
 	isAlive() {
 		return !this.stopped && this.timer !== null;
@@ -243,7 +249,15 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 			catchup_policy: entry.catchupPolicy
 		};
 		if (catchup) meta.catchup = "true";
-		await notify(entry.prompt, meta);
+		const eventId = `${entry.id}@${firedAt.toISOString()}`;
+		this.recordRaw(eventId, entry, firedAt, catchup);
+		try {
+			await notify(entry.prompt, meta);
+		} catch (error) {
+			this.recordProcessed(eventId, entry, "emitted:delivery-failed");
+			throw error;
+		}
+		this.recordProcessed(eventId, entry, "emitted");
 		if (this.onFired) try {
 			await this.onFired(entry, firedAt);
 		} catch (error) {
@@ -289,11 +303,13 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		return matches;
 	}
 	logInvalidCron(entry, error) {
+		const message = error instanceof Error ? error.message : String(error);
+		this.recordConnection("error", `invalid cron "${entry.cron}" (entry ${entry.id}): ${message}`);
 		this.logger?.error("invalid cron expression in schedule", {
 			connector: this.config.name,
 			id: entry.id,
 			cron: entry.cron,
-			error: error instanceof Error ? error.message : String(error)
+			error: message
 		});
 	}
 	truncateToMinute(date) {
@@ -301,6 +317,40 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		copy.setSeconds(0, 0);
 		return copy;
 	}
+	recordRaw(eventId, entry, firedAt, catchup) {
+		this.diagnosticLog?.recordRaw({
+			eventId,
+			type: "schedule",
+			connectorId: this.config.id,
+			channelId: this.channelId,
+			payload: JSON.stringify({
+				schedule_id: entry.id,
+				cron: entry.cron,
+				prompt: entry.prompt,
+				fired_at: firedAt.toISOString(),
+				catchup
+			})
+		});
+	}
+	recordProcessed(eventId, entry, outcome) {
+		this.diagnosticLog?.recordProcessed({
+			eventId,
+			type: "schedule",
+			connectorId: this.config.id,
+			channelId: this.channelId,
+			outcome,
+			payload: entry.prompt
+		});
+	}
+	recordConnection(status, detail) {
+		this.diagnosticLog?.recordConnection({
+			type: "schedule",
+			connectorId: this.config.id,
+			channelId: this.channelId,
+			status,
+			detail
+		});
+	}
 };
 //#endregion
 //#region lib/connectors/schedule-connector-schema.ts

package/dist/{schedule-listener-CBYF2bGZ.d.ts → schedule-listener-C2-KqHQc.d.ts}

@@ -1,4 +1,4 @@
-import { n as FunnelConnectorListener, r as NotifyFn, t as FunnelLogger } from "./logger-B3aXsVcX.js";
+import { S as NotifyFn, b as FunnelLogger, o as ConnectorDiagnosticLog, x as FunnelConnectorListener } from "./connector-diagnostic-log-Clb2sCcz.js";
 import { z } from "zod";
 
 //#region lib/connectors/schedule-connector-schema.d.ts
@@ -95,8 +95,10 @@ declare class ScheduleStateStore {
 type ScheduleOnFired = (entry: ScheduleEntry, firedAt: Date) => void | Promise<void>;
 type Deps = {
   config: ScheduleConnectorConfig;
-  lastFiredStore: ScheduleStateStore;
-  logger?: FunnelLogger;
+  lastFiredStore: ScheduleStateStore; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
+  channelId?: string;
+  logger?: FunnelLogger; /** Diagnostic log of fired entries and lifecycle. No-op when absent. */
+  diagnosticLog?: ConnectorDiagnosticLog;
   now?: () => Date;
   /**
    * Invoked after a schedule entry fires successfully. Use to remove one-shot
@@ -108,7 +110,9 @@ type Deps = {
 declare class FunnelScheduleListener extends FunnelConnectorListener {
   private readonly config;
   private readonly lastFiredStore;
+  private readonly channelId;
   private readonly logger;
+  private readonly diagnosticLog;
   private readonly now;
   private readonly onFired;
   private timer;
@@ -124,6 +128,9 @@ declare class FunnelScheduleListener extends FunnelConnectorListener {
   private findAllMatches;
   private logInvalidCron;
   private truncateToMinute;
+  private recordRaw;
+  private recordProcessed;
+  private recordConnection;
 }
 //#endregion
 export { FunnelFileSystem as a, ScheduleEntry as c, scheduleEntrySchema as d, FileStat as i, scheduleCatchupPolicySchema as l, ScheduleOnFired as n, ScheduleCatchupPolicy as o, ScheduleStateStore as r, ScheduleConnectorConfig as s, FunnelScheduleListener as t, scheduleConnectorSchema as u };

package/dist/{slack-connector-schema-BWL7dWlY.js → slack-connector-schema-CHbRJHGp.js}

@@ -1,5 +1,6 @@
 import { t as FunnelConnectorAdapter } from "./connector-adapter-D5Utumgz.js";
-import { n as FunnelConnectorListener } from "./logger-D1A3_JXV.js";
+import { t as resolveConnectorToken } from "./resolve-connector-token-Ch6XWMJM.js";
+import { n as FunnelConnectorListener } from "./logger-Czli2OKh.js";
 import { z } from "zod";
 import { WebClient } from "@slack/web-api";
 import { App, LogLevel } from "@slack/bolt";
@@ -31,7 +32,13 @@ var FunnelSlackAdapter = class extends FunnelConnectorAdapter {
 	client;
 	constructor(deps) {
 		super();
-		this.client = deps.client ?? new WebClient(deps.config.botToken);
+		const botToken = resolveConnectorToken({
+			literal: deps.config.botToken,
+			envVar: deps.config.botTokenEnv,
+			env: deps.env ?? process.env,
+			label: `${deps.config.name}.botToken`
+		});
+		this.client = deps.client ?? new WebClient(botToken);
 		Object.freeze(this);
 	}
 	async call(input) {
@@ -157,19 +164,34 @@ var FunnelSlackEventProcessor = class {
 	}
 	process(event) {
 		const eventType = getString(event, "type");
-		if (!eventType || !ALLOWED_EVENTS.has(eventType)) return { skip: true };
+		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 };
+		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 };
+		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 };
-		if (botId === this.ownBotId) return { skip: true };
+		if (userId === this.ownBotUserId) return {
+			skip: true,
+			reason: "skip:self-user"
+		};
+		if (botId === this.ownBotId) return {
+			skip: true,
+			reason: "skip:self-bot"
+		};
 		const mentioned = (getString(event, "text") ?? "").includes(`<@${this.ownBotUserId}>`);
 		const threadTs = getString(event, "thread_ts") ?? getString(event, "ts") ?? "";
 		const emitted = this.minify ? minifySlackEvent(event) : event;
@@ -194,25 +216,49 @@ var FunnelSlackEventProcessor = class {
 const middlewareArgsSchema = z.object({ event: z.record(z.string(), z.unknown()).optional() });
 var FunnelSlackListener = class extends FunnelConnectorListener {
 	config;
+	channelId;
+	env;
 	logger;
+	diagnosticLog;
 	onAppCreated;
 	preprocessEvent;
 	app = null;
 	constructor(deps) {
 		super();
 		this.config = deps.config;
+		this.channelId = deps.channelId ?? null;
+		this.env = deps.env ?? process.env;
 		this.logger = deps.logger;
+		this.diagnosticLog = deps.diagnosticLog;
 		this.onAppCreated = deps.onAppCreated ?? null;
 		this.preprocessEvent = deps.preprocessEvent ?? null;
 	}
 	async start(notify) {
+		this.recordConnection("started", "");
+		const botToken = resolveConnectorToken({
+			literal: this.config.botToken,
+			envVar: this.config.botTokenEnv,
+			env: this.env,
+			label: `${this.config.name}.botToken`
+		});
 		const app = new App({
-			token: this.config.botToken,
-			appToken: this.config.appToken,
+			token: botToken,
+			appToken: resolveConnectorToken({
+				literal: this.config.appToken,
+				envVar: this.config.appTokenEnv,
+				env: this.env,
+				label: `${this.config.name}.appToken`
+			}),
 			socketMode: true,
 			logLevel: LogLevel.ERROR
 		});
-		const authResult = await app.client.auth.test({ token: this.config.botToken });
+		let authResult;
+		try {
+			authResult = await app.client.auth.test({ token: botToken });
+		} catch (error) {
+			this.recordConnection("auth-failed", messageOf(error));
+			throw error;
+		}
 		const processor = new FunnelSlackEventProcessor({
 			ownBotUserId: authResult.user_id ?? "",
 			ownBotId: authResult.bot_id ?? "",
@@ -226,14 +272,28 @@ var FunnelSlackListener = class extends FunnelConnectorListener {
 				return;
 			}
 			const rawEvent = parsed.data.event;
+			const eventId = crypto.randomUUID();
+			this.recordRaw(eventId, rawEvent);
 			const event = preprocess ? preprocess(rawEvent) : rawEvent;
-			if (event === null) return;
+			if (event === null) {
+				this.recordProcessed(eventId, rawEvent, "skip:preprocess", "");
+				return;
+			}
 			const result = processor.process(event);
-			if (result.skip) return;
-			await notify(result.content, result.meta);
+			if (result.skip) {
+				this.recordProcessed(eventId, event, result.reason, "");
+				return;
+			}
+			try {
+				await notify(result.content, result.meta);
+			} catch (error) {
+				this.recordProcessed(eventId, event, "emitted:delivery-failed", result.content);
+				throw error;
+			}
+			this.recordProcessed(eventId, event, "emitted", result.content);
 			if (result.shouldReact) try {
 				await app.client.reactions.add({
-					token: this.config.botToken,
+					token: botToken,
 					channel: result.channel,
 					timestamp: result.timestamp,
 					name: "eyes"
@@ -241,34 +301,95 @@ var FunnelSlackListener = class extends FunnelConnectorListener {
 			} catch {}
 		});
 		app.error(async (error) => {
-			this.logger?.error("Slack error", { error: error instanceof Error ? error.message : String(error) });
+			const message = messageOf(error);
+			this.recordConnection("error", message);
+			this.logger?.error("Slack error", { error: message });
 		});
 		if (this.onAppCreated) await this.onAppCreated(app);
-		await app.start();
+		try {
+			await app.start();
+		} catch (error) {
+			this.recordConnection("error", messageOf(error));
+			throw error;
+		}
 		this.app = app;
+		this.recordConnection("connected", "");
 	}
 	async stop() {
 		if (!this.app) return;
 		try {
 			await this.app.stop();
+			this.recordConnection("disconnected", "");
 		} catch (error) {
-			this.logger?.error("Slack stop error", { error: error instanceof Error ? error.message : String(error) });
+			this.recordConnection("error", messageOf(error));
+			this.logger?.error("Slack stop error", { error: messageOf(error) });
 		} finally {
 			this.app = null;
+			this.recordConnection("stopped", "");
 		}
 	}
 	isAlive() {
 		return this.app !== null;
 	}
+	recordRaw(eventId, event) {
+		this.diagnosticLog?.recordRaw({
+			eventId,
+			type: "slack",
+			connectorId: this.config.id,
+			channelId: this.channelId,
+			payload: JSON.stringify(event)
+		});
+	}
+	recordProcessed(eventId, event, outcome, content) {
+		this.diagnosticLog?.recordProcessed({
+			eventId,
+			type: "slack",
+			connectorId: this.config.id,
+			channelId: this.channelId,
+			outcome,
+			payload: content || JSON.stringify(event)
+		});
+	}
+	recordConnection(status, detail) {
+		this.diagnosticLog?.recordConnection({
+			type: "slack",
+			connectorId: this.config.id,
+			channelId: this.channelId,
+			status,
+			detail
+		});
+	}
+};
+const messageOf = (error) => {
+	return error instanceof Error ? error.message : String(error);
 };
 //#endregion
 //#region lib/connectors/slack-connector-schema.ts
+/**
+* A slack connector resolves its tokens one of two ways, set at sync time:
+*
+*   - literal: `botToken` / `appToken` hold the real `xoxb-`/`xapp-` secret
+*     (funnel.json gave a literal, or a `fnl channels` command did).
+*   - by reference: `botTokenEnv` / `appTokenEnv` hold the *name* of an env var
+*     (funnel.json used `env: { botToken: "SLACK_BOT_TOKEN" }`). The secret
+*     never lands in settings.json; the listener resolves it from the
+*     environment at start. This keeps repo-local launches' tokens in
+*     `.env.local` only.
+*
+* 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.
+*/
 const slackConnectorSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	type: z.literal("slack"),
-	botToken: z.string().startsWith("xoxb-"),
-	appToken: z.string().startsWith("xapp-"),
+	botToken: z.string().startsWith("xoxb-").optional(),
+	appToken: z.string().startsWith("xapp-").optional(),
+	/** Name of the env var holding the bot token, resolved at listener start. */
+	botTokenEnv: z.string().optional(),
+	/** Name of the env var holding the app token, resolved at listener start. */
+	appTokenEnv: z.string().optional(),
 	minify: z.boolean().default(true),
 	createdAt: z.string().datetime().optional(),
 	updatedAt: z.string().datetime().optional()

package/dist/slack-listener-BMknoyVr.d.ts

@@ -0,0 +1,112 @@
+import { S as NotifyFn, b as FunnelLogger, o as ConnectorDiagnosticLog, x as FunnelConnectorListener } from "./connector-diagnostic-log-Clb2sCcz.js";
+import { z } from "zod";
+import { App } from "@slack/bolt";
+
+//#region lib/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
+ *     (funnel.json gave a literal, or a `fnl channels` command did).
+ *   - by reference: `botTokenEnv` / `appTokenEnv` hold the *name* of an env var
+ *     (funnel.json used `env: { botToken: "SLACK_BOT_TOKEN" }`). The secret
+ *     never lands in settings.json; the listener resolves it from the
+ *     environment at start. This keeps repo-local launches' tokens in
+ *     `.env.local` only.
+ *
+ * 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/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;
+  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
+//#region lib/connectors/slack-listener.d.ts
+type SlackOnAppCreated = (app: App) => void | Promise<void>;
+type SlackPreprocessEvent = (event: SlackRawEvent) => SlackRawEvent | null;
+type Deps = {
+  config: SlackConnectorConfig; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
+  channelId?: string; /** Environment used to resolve `botTokenEnv`/`appTokenEnv` references. Defaults to process.env. */
+  env?: NodeJS.ProcessEnv;
+  logger?: FunnelLogger; /** Diagnostic log of inbound events, before and after processing. No-op when absent. */
+  diagnosticLog?: ConnectorDiagnosticLog;
+  /**
+   * Invoked after the Bolt App is constructed, before it starts.
+   * Use to attach app.action handlers, custom middleware, etc.
+   */
+  onAppCreated?: SlackOnAppCreated;
+  /**
+   * Transform or drop the raw Slack event before the built-in processor sees it.
+   * Return null to drop the event entirely.
+   */
+  preprocessEvent?: SlackPreprocessEvent;
+};
+declare class FunnelSlackListener extends FunnelConnectorListener {
+  private readonly config;
+  private readonly channelId;
+  private readonly env;
+  private readonly logger;
+  private readonly diagnosticLog;
+  private readonly onAppCreated;
+  private readonly preprocessEvent;
+  private app;
+  constructor(deps: Deps);
+  start(notify: NotifyFn): Promise<void>;
+  stop(): Promise<void>;
+  isAlive(): boolean;
+  private recordRaw;
+  private recordProcessed;
+  private recordConnection;
+}
+//#endregion
+export { SlackProcessed as a, SlackRawEvent as c, slackConnectorSchema as d, FunnelSlackEventProcessor as i, SlackSkipReason as l, SlackOnAppCreated as n, SlackProcessedEmit as o, SlackPreprocessEvent as r, SlackProcessedSkip as s, FunnelSlackListener as t, SlackConnectorConfig as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interactive-inc/claude-funnel",
-  "version": "0.26.1",
+  "version": "0.27.0",
   "description": "Hub CLI that routes external events (Slack / GitHub / Discord) to Claude Code agents through subscription channels over MCP.",
   "keywords": [
     "bun",

package/dist/logger-B3aXsVcX.d.ts

@@ -1,33 +0,0 @@
-//#region lib/connectors/connector-listener.d.ts
-type NotifyFn = (content: string, meta?: Record<string, string>) => Promise<void>;
-/**
- * Long-lived event source for one connector.
- *
- * `start()` opens the underlying connection (Slack Socket Mode, Discord
- * Gateway, GH polling, schedule tick) and pushes events through `notify`.
- * `stop()` releases the resources so the supervisor can recreate the listener
- * with new config without restarting the whole gateway. `isAlive()` lets the
- * supervisor periodically health-check and auto-restart dead listeners; the
- * default optimistic implementation is fine for poll/tick-based listeners
- * that self-heal.
- */
-declare abstract class FunnelConnectorListener {
-  abstract start(notify: NotifyFn): Promise<void>;
-  abstract stop(): Promise<void>;
-  isAlive(): boolean;
-}
-//#endregion
-//#region lib/engine/logger/logger.d.ts
-/**
- * Structured logger with three levels and an optional log-file path.
- * Defaults to NodeFunnelLogger (appends to `<os.tmpdir()>/funnel/funnel.log`);
- * MemoryFunnelLogger captures entries in memory and NoopFunnelLogger silences output.
- */
-declare abstract class FunnelLogger {
-  abstract info(message: string, meta?: Record<string, unknown>): void;
-  abstract warn(message: string, meta?: Record<string, unknown>): void;
-  abstract error(message: string, meta?: Record<string, unknown>): void;
-  abstract readonly file: string | null;
-}
-//#endregion
-export { FunnelConnectorListener as n, NotifyFn as r, FunnelLogger as t };

package/dist/slack-listener-DbNCPMqY.d.ts

@@ -1,77 +0,0 @@
-import { n as FunnelConnectorListener, r as NotifyFn, t as FunnelLogger } from "./logger-B3aXsVcX.js";
-import { z } from "zod";
-import { App } from "@slack/bolt";
-
-//#region lib/connectors/slack-connector-schema.d.ts
-declare const slackConnectorSchema: z.ZodObject<{
-  id: z.ZodString;
-  name: z.ZodString;
-  type: z.ZodLiteral<"slack">;
-  botToken: z.ZodString;
-  appToken: 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/connectors/slack-event-processor.d.ts
-type SlackRawEvent = Record<string, unknown>;
-type SlackProcessedSkip = {
-  skip: true;
-};
-type SlackProcessedEmit = {
-  skip: false;
-  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
-//#region lib/connectors/slack-listener.d.ts
-type SlackOnAppCreated = (app: App) => void | Promise<void>;
-type SlackPreprocessEvent = (event: SlackRawEvent) => SlackRawEvent | null;
-type Deps = {
-  config: SlackConnectorConfig;
-  logger?: FunnelLogger;
-  /**
-   * Invoked after the Bolt App is constructed, before it starts.
-   * Use to attach app.action handlers, custom middleware, etc.
-   */
-  onAppCreated?: SlackOnAppCreated;
-  /**
-   * Transform or drop the raw Slack event before the built-in processor sees it.
-   * Return null to drop the event entirely.
-   */
-  preprocessEvent?: SlackPreprocessEvent;
-};
-declare class FunnelSlackListener extends FunnelConnectorListener {
-  private readonly config;
-  private readonly logger;
-  private readonly onAppCreated;
-  private readonly preprocessEvent;
-  private app;
-  constructor(deps: Deps);
-  start(notify: NotifyFn): Promise<void>;
-  stop(): Promise<void>;
-  isAlive(): boolean;
-}
-//#endregion
-export { SlackProcessed as a, SlackRawEvent as c, FunnelSlackEventProcessor as i, SlackConnectorConfig as l, SlackOnAppCreated as n, SlackProcessedEmit as o, SlackPreprocessEvent as r, SlackProcessedSkip as s, FunnelSlackListener as t, slackConnectorSchema as u };