@interactive-inc/claude-funnel 0.60.1 → 0.63.0

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 };

package/dist/slot-fields-D-pvMgTK.js

@@ -0,0 +1,249 @@
+import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
+import { t as FunnelConnectorListener } from "./connector-listener-mPGZYa8e.js";
+import { t as FunnelConnectorDiagnosticsRecorder } from "./connector-diagnostics-recorder-COtNEmUp.js";
+import { Flume, createFlumeDefaultDeps } from "@interactive-inc/flume";
+//#region lib/engine/connectors/flume-deps.ts
+/**
+* Builds the merged runtime deps Flume listeners pass to a source. Spreads the
+* default IO over any partial test override and returns `undefined` when no
+* override exists so Flume gets to use its own internal default and there is
+* one less degree of freedom to debug.
+*/
+const resolveFlumeDeps = (override) => {
+	if (!override || Object.keys(override).length === 0) return void 0;
+	return {
+		...createFlumeDefaultDeps(),
+		...override
+	};
+};
+/**
+* Bridges a `FunnelLogger` into Flume's structured log stream. Returns
+* `undefined` when no logger is wired so Flume's option stays cleanly absent
+* instead of carrying a no-op handler.
+*
+* Forwards everything Flume produces: `detail` (reconnect counters, HTTP codes,
+* parse offsets) is merged into the logger meta, and on errors the full stack
+* is preserved — the leaf message alone is rarely enough to pinpoint a socket
+* close or parse failure. Debug entries are dropped because FunnelLogger has no
+* debug level and routing them to info would drown the operator log in
+* heartbeats.
+*/
+const flumeLogHandler = (logger) => {
+	if (!logger) return void 0;
+	return (log) => {
+		if (log.level === "debug") return;
+		const line = `${log.source}/${log.action}: ${log.message}`;
+		const meta = buildMeta(log);
+		if (log.level === "error") {
+			logger.error(line, meta);
+			return;
+		}
+		if (log.level === "warn") {
+			logger.warn(line, meta);
+			return;
+		}
+		logger.info(line, meta);
+	};
+};
+const buildMeta = (log) => {
+	const meta = { ...log.detail ?? {} };
+	if (log.error) {
+		meta.error = log.error.message;
+		if (log.error.stack) meta.stack = log.error.stack;
+		if (log.error.name && log.error.name !== "Error") meta.errorName = log.error.name;
+	}
+	return Object.keys(meta).length > 0 ? meta : void 0;
+};
+//#endregion
+//#region lib/engine/connectors/flume-source-listener.ts
+/**
+* Shared lifecycle for any listener whose transport is a `FlumeSource`. Owns
+* the per-listener `Flume` instance + the `FlumeRunning` handle returned by
+* `open()`, the connected/alive bit, the `FlumeStatus ↔
+* ConnectorConnectionStatus` mapping, and the close sequence — every Flume
+* subclass plugs in only its own token resolution, source construction, and
+* event dispatch around this skeleton.
+*
+* Flume 0.9 collapsed every observation channel into one firehose: events
+* and all logs arrive through `onEvent` as a discriminated union
+* (`{ kind: "event" } | { kind: "log" }`). This base class splits that back
+* into the funnel-shaped trio (typed event handler, log forward, status
+* mapping) so subclasses keep their per-protocol code unchanged.
+*/
+var FunnelFlumeSourceListener = class extends FunnelConnectorListener {
+	logger;
+	diagnostics;
+	type;
+	running = null;
+	connected = false;
+	/**
+	* Flipped on by Flume's `reconnecting` status, off when the new socket
+	* lands on `connected` or the source gives up with `disconnected`. Used by
+	* `isAlive()` to treat a brief reconnect window as "still alive" so the
+	* supervisor does not preempt Flume's in-progress recovery with a heavier
+	* stop+start cycle (which would discard auth.test results and rebuild
+	* every per-listener state).
+	*/
+	reconnecting = false;
+	/**
+	* Promise chain that serializes typed-event delivery. Flume's emitItem
+	* fire-and-forgets the onEvent callback (see flume.ts emitItem:
+	* `Promise.resolve(onEvent(item)).catch(() => {})`), so awaiting onEvent
+	* inside the handler does NOT pause flume's source queue — multiple event
+	* deliveries would race their microtask chains. Chaining each new event
+	* onto the previous promise's `.then(...)` guarantees per-listener
+	* end-to-end FIFO regardless of whether the notify path is sync or async.
+	*/
+	deliveryChain = Promise.resolve();
+	constructor(props) {
+		super();
+		this.type = props.type;
+		this.logger = props.logger;
+		this.diagnostics = new FunnelConnectorDiagnosticsRecorder({
+			type: props.type,
+			connectorId: props.connectorId,
+			channelId: props.channelId,
+			log: props.diagnosticLog
+		});
+	}
+	/**
+	* Assemble a single-source Flume, open it, and store the `FlumeRunning`
+	* handle. Records `error` on any `Error` returned by `flume.open()` and
+	* rethrows so the supervisor sees the failure.
+	*
+	* The firehose handler routes:
+	*   - `kind: "event"`   → subclass's typed `onEvent`
+	*   - `kind: "log"` with `action === "status"` → `handleStatus()`
+	*   - `kind: "log"` (any)                     → optional `onLog` handler
+	*/
+	async runStart(options) {
+		const reconnectOption = options.reconnect ?? true;
+		const flumeReconnect = reconnectOption === false ? void 0 : reconnectOption === true ? {} : reconnectOption;
+		const handleItem = (item) => {
+			if (item.kind === "event") {
+				this.deliveryChain = this.deliveryChain.catch(() => {}).then(() => Promise.resolve(options.onEvent(item.event)));
+				return;
+			}
+			const log = item.log;
+			const statusEvent = readStatusLog(log);
+			if (statusEvent) this.handleStatus(statusEvent);
+			options.onLog?.(log);
+		};
+		const flumeOptions = {
+			sources: [options.source],
+			onEvent: handleItem
+		};
+		if (options.deps) flumeOptions.deps = options.deps;
+		if (options.signal) flumeOptions.signal = options.signal;
+		if (flumeReconnect) flumeOptions.reconnect = flumeReconnect;
+		const result = await new Flume(flumeOptions).open();
+		if (result instanceof Error) {
+			this.diagnostics.recordConnection("error", errorMessageOf(result));
+			throw result;
+		}
+		this.running = result;
+	}
+	async stop() {
+		if (!this.running) return;
+		try {
+			await this.running.close();
+			this.diagnostics.recordConnection("disconnected", "");
+		} catch (error) {
+			this.diagnostics.recordConnection("error", errorMessageOf(error));
+			this.logger?.error(`${this.type} stop error`, { error: errorMessageOf(error) });
+		} finally {
+			this.running = null;
+			this.connected = false;
+			this.reconnecting = false;
+			this.deliveryChain = Promise.resolve();
+			this.onStop();
+			this.diagnostics.recordConnection("stopped", "");
+		}
+	}
+	isAlive() {
+		if (this.running === null) return false;
+		return this.connected || this.reconnecting;
+	}
+	/**
+	* Maps Flume's transport status to the connection table. `reconnecting`
+	* deliberately produces no row — Flume drives many transient reconnects per
+	* minute on a flaky network, and the row would drown the more meaningful
+	* `connected`/`disconnected` pair. The `reconnecting` flag still flips so
+	* `isAlive()` can surface it to the supervisor.
+	*/
+	handleStatus(event) {
+		if (event.status === "connected") {
+			this.connected = true;
+			this.reconnecting = false;
+			this.diagnostics.recordConnection("connected", event.detail ?? "");
+			return;
+		}
+		if (event.status === "disconnected") {
+			this.connected = false;
+			this.reconnecting = false;
+			this.diagnostics.recordConnection("disconnected", event.detail ?? "");
+			return;
+		}
+		if (event.status === "reconnecting") {
+			this.connected = false;
+			this.reconnecting = true;
+		}
+	}
+	/**
+	* Hook for subclass-specific cleanup that has to run inside the stop()
+	* finally block (after the running handle is cleared, before the `stopped`
+	* row is recorded). Default is no-op.
+	*/
+	onStop() {}
+};
+const STATUS_VALUES = [
+	"disconnected",
+	"connecting",
+	"connected",
+	"reconnecting"
+];
+const isFlumeStatus = (value) => typeof value === "string" && STATUS_VALUES.includes(value);
+/**
+* Reconstructs the old `FlumeStatusEvent` shape from a `status` log entry.
+* Returns `null` for anything else so the firehose pump is a single check.
+* Flume 0.9 emits these as `log.action === "status"` with a structured
+* `detail: { from, to, reason }` payload (see flume's FlumeStatusEmitter).
+*/
+const readStatusLog = (log) => {
+	if (log.action !== "status") return null;
+	const detail = log.detail;
+	if (!detail) return null;
+	const to = detail.to;
+	if (!isFlumeStatus(to)) return null;
+	const reason = typeof detail.reason === "string" ? detail.reason : null;
+	return {
+		source: log.source,
+		status: to,
+		detail: reason
+	};
+};
+//#endregion
+//#region lib/engine/connectors/slot-fields.ts
+/**
+* Resolves one token slot (e.g. botToken/botTokenEnv) for a connector update.
+* The literal and the env-ref form are mutually exclusive: if `fields` supplies
+* either, that form wins and the other key is omitted entirely; if it supplies
+* neither, the connector's current slot is carried over unchanged. Returns a
+* partial object spread into the rebuilt connector, so an omitted key is truly
+* absent rather than set to undefined — switching a slot from literal to ref
+* drops the stale literal instead of leaving both behind.
+*/
+const slotFields = (literalKey, envKey, fields, current) => {
+	const literal = fields[literalKey];
+	if (typeof literal === "string") return { [literalKey]: literal };
+	const envVar = fields[envKey];
+	if (typeof envVar === "string") return { [envKey]: envVar };
+	const result = {};
+	const currentLiteral = current[literalKey];
+	const currentEnv = current[envKey];
+	if (typeof currentLiteral === "string") result[literalKey] = currentLiteral;
+	if (typeof currentEnv === "string") result[envKey] = currentEnv;
+	return result;
+};
+//#endregion
+export { resolveFlumeDeps as i, FunnelFlumeSourceListener as n, flumeLogHandler as r, slotFields as t };