@interactive-inc/claude-funnel 0.60.1 → 0.63.0

package/dist/{schedule-connector-L4uzg5M8.js → schedule-connector-9k3gOIgl.js}

@@ -1,7 +1,8 @@
-import { t as NodeFunnelFileSystem } from "./node-file-system-Blr8pAir.js";
-import { t as FunnelConnectorListener } from "./connector-listener-DR3aKOuK.js";
-import { n as scheduleConnectorSchema, r as scheduleEntrySchema } from "./schedule-connector-schema-CfyuMCMh.js";
-import { t as errorMessageOf } from "./error-message-of-Byi4y0Uf.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-BOXIHW_Q.js";
+import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
+import { t as FunnelConnectorListener } from "./connector-listener-mPGZYa8e.js";
+import { n as scheduleConnectorSchema, r as scheduleEntrySchema } from "./schedule-connector-schema-DKEPZnVv.js";
+import { t as FunnelConnectorDiagnosticsRecorder } from "./connector-diagnostics-recorder-COtNEmUp.js";
 import { dirname, join } from "node:path";
 import { z } from "zod";
 //#region lib/engine/connectors/match-cron.ts
@@ -87,7 +88,7 @@ const defaultFs = new NodeFunnelFileSystem();
 * connectorDir) so this store does not know about the funnel directory layout
 * (`channels/<id>/connectors/<id>/state.json` lives outside this class).
 */
-var ScheduleStateStore = class {
+var FunnelScheduleStateStore = class {
 	path;
 	fs;
 	constructor(deps) {
@@ -116,50 +117,75 @@ const MAX_CATCHUP_MINUTES = 1440;
 var FunnelScheduleListener = class extends FunnelConnectorListener {
 	config;
 	lastFiredStore;
-	channelId;
 	logger;
-	diagnosticLog;
+	diagnostics;
 	now;
 	onFired;
 	timer = null;
 	stopped = false;
+	tickScheduled = false;
 	constructor(deps) {
 		super();
 		this.config = deps.config;
 		this.lastFiredStore = deps.lastFiredStore;
-		this.channelId = deps.channelId ?? null;
 		this.logger = deps.logger;
-		this.diagnosticLog = deps.diagnosticLog;
+		this.diagnostics = new FunnelConnectorDiagnosticsRecorder({
+			type: "schedule",
+			connectorId: deps.config.id,
+			channelId: deps.channelId ?? null,
+			log: deps.diagnosticLog
+		});
 		this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
 		this.onFired = deps.onFired ?? null;
 	}
 	async start(notify) {
 		this.stopped = false;
-		this.recordConnection("started", "");
+		this.tickScheduled = true;
+		this.diagnostics.recordConnection("started", "");
 		const scheduleNext = () => {
 			if (this.stopped) return;
 			const date = this.now();
 			const msUntilNextMinute = 6e4 - (date.getSeconds() * 1e3 + date.getMilliseconds());
 			this.timer = setTimeout(async () => {
 				if (this.stopped) return;
-				await this.tick(notify);
+				try {
+					await this.tick(notify);
+				} catch (error) {
+					this.recordTickError(error);
+				}
 				scheduleNext();
 			}, msUntilNextMinute);
 			this.timer.unref();
+			this.tickScheduled = true;
 		};
-		await this.tick(notify);
+		try {
+			await this.tick(notify);
+		} catch (error) {
+			this.recordTickError(error);
+		}
+		this.diagnostics.recordConnection("connected", "");
 		scheduleNext();
 	}
 	async stop() {
 		this.stopped = true;
+		this.tickScheduled = false;
 		if (this.timer) {
 			clearTimeout(this.timer);
 			this.timer = null;
 		}
-		this.recordConnection("stopped", "");
+		this.diagnostics.recordConnection("disconnected", "");
+		this.diagnostics.recordConnection("stopped", "");
+	}
+	recordTickError(error) {
+		const message = errorMessageOf(error);
+		this.diagnostics.recordConnection("error", `tick: ${message}`);
+		this.logger?.error("schedule tick failed", {
+			connector: this.config.name,
+			error: message
+		});
 	}
 	isAlive() {
-		return !this.stopped && this.timer !== null;
+		return !this.stopped && this.tickScheduled;
 	}
 	async tick(notify) {
 		const now = this.truncateToMinute(this.now());
@@ -209,14 +235,20 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		};
 		if (catchup) meta.catchup = "true";
 		const eventId = `${entry.id}@${firedAt.toISOString()}`;
-		this.recordRaw(eventId, entry, firedAt, catchup);
+		this.diagnostics.recordRaw(eventId, JSON.stringify({
+			schedule_id: entry.id,
+			cron: entry.cron,
+			prompt: entry.prompt,
+			fired_at: firedAt.toISOString(),
+			catchup
+		}));
 		try {
 			await notify(entry.prompt, meta);
 		} catch (error) {
-			this.recordProcessed(eventId, entry, "emitted:delivery-failed");
+			this.diagnostics.recordProcessed(eventId, "emitted:delivery-failed", entry.prompt);
 			throw error;
 		}
-		this.recordProcessed(eventId, entry, "emitted");
+		this.diagnostics.recordProcessed(eventId, "emitted", entry.prompt);
 		if (this.onFired) try {
 			await this.onFired(entry, firedAt);
 		} catch (error) {
@@ -263,7 +295,7 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 	}
 	logInvalidCron(entry, error) {
 		const message = errorMessageOf(error);
-		this.recordConnection("error", `invalid cron "${entry.cron}" (entry ${entry.id}): ${message}`);
+		this.diagnostics.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,
@@ -276,40 +308,6 @@ 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/engine/connectors/schedule-connector.ts
@@ -335,14 +333,15 @@ const scheduleConnector = (options = {}) => ({
 		const parsed = scheduleConnectorSchema.parse(config);
 		return new FunnelScheduleListener({
 			config: parsed,
-			lastFiredStore: new ScheduleStateStore({
+			lastFiredStore: new FunnelScheduleStateStore({
 				path: join(deps.connectorDir(deps.channelId, parsed.id), "state.json"),
 				fs: deps.fs
 			}),
 			channelId: deps.channelId,
 			logger: deps.logger,
 			diagnosticLog: deps.diagnosticLog,
-			onFired: options.onFired
+			onFired: options.onFired,
+			now: () => deps.clock.now()
 		});
 	},
 	createAdapter: null,
@@ -409,4 +408,4 @@ const scheduleConnector = (options = {}) => ({
 	}
 });
 //#endregion
-export { matchCron as i, FunnelScheduleListener as n, ScheduleStateStore as r, scheduleConnector as t };
+export { matchCron as i, FunnelScheduleListener as n, FunnelScheduleStateStore as r, scheduleConnector as t };

package/dist/schedule-connector-schema-Z0RXLgPI.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+
+//#region lib/engine/connectors/schedule-connector-schema.d.ts
+/**
+ * Catch-up behavior when the daemon was down past one or more matching minutes.
+ *
+ * - `latest`: fire once with the most recent missed match (default; preserves prior behavior).
+ * - `all`: fire once per missed minute, oldest first (capped at 24 h).
+ * - `skip`: never fire missed matches; only fire when the current minute matches.
+ */
+declare const scheduleCatchupPolicySchema: z.ZodEnum<{
+  latest: "latest";
+  all: "all";
+  skip: "skip";
+}>;
+type ScheduleCatchupPolicy = z.infer<typeof scheduleCatchupPolicySchema>;
+declare const scheduleEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  cron: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+}, z.core.$strip>;
+type ScheduleEntry = z.infer<typeof scheduleEntrySchema>;
+declare const scheduleConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"schedule">;
+  entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    cron: z.ZodString;
+    prompt: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    catchupPolicy: z.ZodDefault<z.ZodEnum<{
+      latest: "latest";
+      all: "all";
+      skip: "skip";
+    }>>;
+  }, z.core.$strip>>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>;
+//#endregion
+export { scheduleConnectorSchema as a, scheduleCatchupPolicySchema as i, ScheduleConnectorConfig as n, scheduleEntrySchema as o, ScheduleEntry as r, ScheduleCatchupPolicy as t };

package/dist/settings-reader-BNxjsxCB.d.ts

@@ -0,0 +1,27 @@
+import { a as Settings } from "./settings-schema-BL_c2Udm.js";
+
+//#region lib/engine/id/id-generator.d.ts
+/**
+ * ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
+ * MemoryFunnelIdGenerator emits `<prefix>-1, <prefix>-2, ...` for deterministic tests.
+ */
+declare abstract class FunnelIdGenerator {
+  abstract generate(): string;
+}
+//#endregion
+//#region lib/engine/settings/settings-reader.d.ts
+declare abstract class FunnelSettingsReader {
+  abstract read(): Settings;
+  abstract write(settings: Settings): void;
+  /**
+   * Atomic read-modify-write. Implementations must serialize against
+   * concurrent processes touching the same file (the Node store does so via
+   * an exclusive lockfile; Memory stores are single-threaded). Engine
+   * classes must use `update` for any mutation that depends on prior state,
+   * otherwise a concurrent CLI invocation or `fnl claude` launch can lose
+   * the edit through a read-modify-write race.
+   */
+  abstract update<T>(mutator: (settings: Settings) => T): T;
+}
+//#endregion
+export { FunnelIdGenerator as n, FunnelSettingsReader as t };

package/dist/{settings-store-CUKSeTXC.js → settings-store-C2QdOH-t.js}

@@ -1,5 +1,5 @@
-import { t as NodeFunnelFileSystem } from "./node-file-system-Blr8pAir.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-CtQ-Ix8_.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-BOXIHW_Q.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-9FcX3qS1.js";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { z } from "zod";
@@ -29,11 +29,11 @@ const baseConnectorConfigSchema = z.object({
 //#region lib/engine/settings/settings-schema.ts
 /**
 * Connectors are stored loosely here: settings validates only the common base
-* fields and preserves every type-specific key verbatim (`.passthrough()`).
+* fields and preserves every type-specific key verbatim (`.loose()`).
 * Core does not enumerate connector types, so strict per-type validation happens
 * at the registry/descriptor layer (CRUD time), not on every settings read.
 */
-const storedConnectorSchema = baseConnectorConfigSchema.passthrough();
+const storedConnectorSchema = baseConnectorConfigSchema.loose();
 /**
 * Routing mode when multiple WS clients are subscribed to the same channel.
 *
@@ -192,6 +192,25 @@ var FunnelSettingsStore = class extends FunnelSettingsReader {
 		};
 		this.fs.writeSecretFileSync(this.path, `${JSON.stringify(versioned, null, 2)}\n`);
 	}
+	/**
+	* Run `mutator` against a freshly-read settings object inside an exclusive
+	* file lock, then persist the result. Use this instead of bare `read()` +
+	* `write()` for any logical edit (add channel, set token, rename profile),
+	* so two concurrent CLI invocations or `fnl claude` launches cannot lose
+	* each other's updates via a read-modify-write race. The mutator may
+	* mutate `settings` in place and/or return a value; the value is returned
+	* to the caller. A thrown error from the mutator skips the write but still
+	* releases the lock.
+	*/
+	update(mutator) {
+		this.fs.mkdirSync(dirname(this.path), { recursive: true });
+		return this.fs.withFileLock(`${this.path}.lock`, () => {
+			const settings = this.read();
+			const result = mutator(settings);
+			this.write(settings);
+			return result;
+		});
+	}
 };
 //#endregion
 export { resolveFunnelDir as a, channelConfigSchema as c, settingsSchema as d, baseConnectorConfigSchema as f, SETTINGS_PATH as i, channelDeliveryModeSchema as l, FUNNEL_DIR as n, resolveFunnelPort as o, NodeFunnelIdGenerator as p, FunnelSettingsStore as r, SETTINGS_VERSION as s, DEFAULT_GATEWAY_PORT as t, profileConfigSchema as u };

package/dist/slack-connector-BU86fIge.js

@@ -0,0 +1,359 @@
+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;
+	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;
+	}
+	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 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;
+		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). Only the events API envelope is delivered —
+* there is no equivalent for the Bolt-style `app.action` / `app.command`
+* dispatch. For HTTP-side interactivity (buttons, slash commands), run a
+* separate Bolt app outside funnel; this descriptor only handles the
+* incoming events firehose.
+*/
+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
+		});
+	},
+	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 };