@interactive-inc/claude-funnel 0.49.0 → 0.51.0

package/dist/claude.js

@@ -0,0 +1,322 @@
+import { d as settingsSchema, o as resolveFunnelPort } from "./settings-store-D2XSXTyt.js";
+import { a as FileProcessGuard, i as FunnelMcp, n as FUNNEL_MCP_COMMAND, o as FunnelClaude, r as FUNNEL_MCP_NAME, t as FUNNEL_MCP_ARGS } from "./mcp-Dr-nIBwN.js";
+import { a as FunnelLocalConfig, c as connectorSpecSchema, i as FunnelTokenPrompter, l as localConfigSchema, n as NodeFunnelTokenPrompter, o as LOCAL_CONFIG_FILENAME, r as FunnelLocalConfigSync, s as channelSpecSchema, t as funnelJsonSchema, u as profileSpecSchema } from "./local-config-json-schema-8IHjS4Q7.js";
+import { t as FunnelProfiles } from "./profiles-wMRnjSid.js";
+import { n as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-CLerGsgM.js";
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+//#region lib/engine/mcp/channel-subscriber.ts
+const RECONNECT_DELAY = 1e3;
+const MAX_RECONNECT_DELAY = 1e4;
+/**
+* Subscribes to the gateway WebSocket for a single channel and forwards
+* incoming events to the MCP server as `notifications/claude/channel`.
+* Reconnects with exponential backoff and replays missed events via `?since=<offset>`.
+*/
+var FunnelChannelSubscriber = class {
+	state = {
+		reconnectDelay: RECONNECT_DELAY,
+		lastOffset: 0
+	};
+	constructor(props) {
+		this.props = props;
+		Object.freeze(this);
+	}
+	start() {
+		this.connect();
+	}
+	connect() {
+		const sinceQuery = this.state.lastOffset > 0 ? `&since=${this.state.lastOffset}` : "";
+		const wsUrl = `${this.props.baseUrl}${sinceQuery}`;
+		const ws = new WebSocket(wsUrl, this.props.protocols);
+		ws.addEventListener("open", () => {
+			this.state.reconnectDelay = RECONNECT_DELAY;
+			process.stderr.write(`funnel: connected (${wsUrl})\n`);
+		});
+		ws.addEventListener("message", (event) => this.handleMessage(event));
+		ws.addEventListener("close", () => {
+			process.stderr.write(`funnel: disconnected, reconnecting in ${this.state.reconnectDelay}ms\n`);
+			setTimeout(() => this.connect(), this.state.reconnectDelay);
+			this.state.reconnectDelay = Math.min(this.state.reconnectDelay * 2, MAX_RECONNECT_DELAY);
+		});
+		ws.addEventListener("error", () => {});
+	}
+	async handleMessage(event) {
+		try {
+			const payload = JSON.parse(String(event.data));
+			const eventType = payload.meta?.event_type ?? "unknown";
+			if (typeof payload.offset === "number" && payload.offset > this.state.lastOffset) this.state.lastOffset = payload.offset;
+			process.stderr.write(`funnel: received event (${eventType})\n`);
+			await this.props.server.notification({
+				method: "notifications/claude/channel",
+				params: {
+					content: payload.content,
+					meta: payload.meta
+				}
+			});
+		} catch (error) {
+			process.stderr.write(`funnel: error: ${error instanceof Error ? error.message : String(error)}\n`);
+		}
+	}
+};
+//#endregion
+//#region lib/engine/mcp/read-channel-connectors.ts
+const TOOL_CONNECTOR_TYPES = new Set([
+	"slack",
+	"gh",
+	"discord"
+]);
+const readChannelConnectors = (dir, channelId) => {
+	const settingsPath = join(dir, "settings.json");
+	if (!existsSync(settingsPath)) return null;
+	const raw = JSON.parse(readFileSync(settingsPath, "utf-8"));
+	const parsed = settingsSchema.safeParse(raw);
+	if (!parsed.success) return null;
+	const channel = parsed.data.channels.find((c) => c.id === channelId);
+	if (!channel) return null;
+	const connectors = channel.connectors.filter((c) => TOOL_CONNECTOR_TYPES.has(c.type)).map((c) => ({
+		name: c.name,
+		type: c.type
+	}));
+	return {
+		channelName: channel.name,
+		connectors
+	};
+};
+//#endregion
+//#region lib/engine/mcp/read-gateway-token.ts
+const readGatewayToken = (dir) => {
+	const fromEnv = process.env.FUNNEL_GATEWAY_TOKEN;
+	if (fromEnv && fromEnv.length > 0) return fromEnv;
+	const path = join(dir, "gateway.token");
+	if (!existsSync(path)) return null;
+	const value = readFileSync(path, "utf-8").trim();
+	return value.length > 0 ? value : null;
+};
+//#endregion
+//#region lib/engine/mcp/usage-hint-for-type.ts
+const usageHintForType = (type) => {
+	if (type === "slack") return [
+		"Slack Web API.",
+		"To reply in the same thread: method=POST path=chat.postMessage body={ channel: meta.channel_id, text: \"...\", thread_ts: meta.thread_ts }",
+		"To react: method=POST path=reactions.add body={ channel: meta.channel_id, timestamp: meta.thread_ts, name: \"thumbsup\" }",
+		"Use meta fields from the incoming event: channel_id (Slack channel), thread_ts (thread anchor), user_id (sender)."
+	].join(" ");
+	if (type === "discord") return [
+		"Discord REST API.",
+		"To reply: method=POST path=/channels/<meta.channel_id>/messages body={ content: \"...\" }",
+		"Use meta fields: channel_id (Discord channel), user_id (sender), guild_id."
+	].join(" ");
+	if (type === "gh") return [
+		"GitHub REST via gh CLI.",
+		"To comment: method=POST path=repos/<meta.repository>/issues/<number>/comments body={ body: \"...\" }",
+		"Parse <number> from meta.subject_url. meta fields: repository (owner/repo), subject_type, subject_url, reason."
+	].join(" ");
+	return "Generic adapter call.";
+};
+//#endregion
+//#region lib/engine/mcp/channel-server.ts
+const DEFAULT_FUNNEL_DIR = join(homedir(), ".funnel");
+const BUILTIN_TOOL_NAMES = ["fnl_status", "fnl_debug"];
+const isBuiltinTool = (name) => BUILTIN_TOOL_NAMES.includes(name);
+const readAllChannels = (dir) => {
+	const settingsPath = join(dir, "settings.json");
+	if (!existsSync(settingsPath)) return [];
+	try {
+		const raw = JSON.parse(readFileSync(settingsPath, "utf-8"));
+		const parsed = settingsSchema.safeParse(raw);
+		if (!parsed.success) return [];
+		return parsed.data.channels.map((c) => ({
+			id: c.id,
+			name: c.name
+		}));
+	} catch {
+		return [];
+	}
+};
+const startChannelServer = async (options = {}) => {
+	const dir = options.dir ?? DEFAULT_FUNNEL_DIR;
+	const gatewayBaseUrl = options.gatewayUrl ?? process.env.FUNNEL_GATEWAY_URL ?? `http://127.0.0.1:${resolveFunnelPort()}`;
+	const gatewayWsUrl = `${gatewayBaseUrl.replace(/^http/, "ws")}/ws`;
+	const channelId = options.channelId ?? process.env.FUNNEL_CHANNEL_ID;
+	const channel = channelId ? readChannelConnectors(dir, channelId) : null;
+	const token = options.token ?? readGatewayToken(dir);
+	const allChannels = readAllChannels(dir);
+	const currentChannelName = channel?.channelName ?? null;
+	const channelContext = allChannels.length > 0 ? [
+		"",
+		"Configured channels (use as the `channel` argument to fnl_debug):",
+		...allChannels.map((ch) => `  ${ch.name}${ch.name === currentChannelName ? " ← this session" : ""}`)
+	].join("\n") : "";
+	const server = new Server({
+		name: FUNNEL_MCP_NAME,
+		version: "1.0.0"
+	}, {
+		capabilities: {
+			experimental: { "claude/channel": {} },
+			tools: {}
+		},
+		instructions: [
+			`Events arrive as notifications (method: notifications/claude/channel) with two fields:`,
+			`  content — the event payload as a JSON string (parse it to read the message)`,
+			`  meta    — key/value strings describing the event`,
+			"",
+			"meta fields by event_type:",
+			"  slack:    event_type=slack  channel_id=C…  thread_ts=1234.5678  user_id=U…  mentioned=true|false",
+			"  gh:       event_type=gh     repository=owner/repo  subject_type=Issue|PullRequest  subject_url=…  reason=…",
+			"  discord:  event_type=discord  channel_id=…  user_id=…  guild_id=…  mentioned=true|false",
+			"  schedule: event_type=schedule  entry_id=…",
+			"",
+			"To reply to a Slack message in the same thread, call the connector tool with:",
+			`  method: POST`,
+			`  path:   chat.postMessage`,
+			`  body:   { channel: meta.channel_id, text: "your reply", thread_ts: meta.thread_ts }`,
+			"",
+			"To comment on a GitHub issue/PR (extract from subject_url in meta):",
+			`  method: POST`,
+			`  path:   repos/<meta.repository>/issues/<number>/comments   (parse number from meta.subject_url)`,
+			`  body:   { body: "your reply" }`,
+			"",
+			"Built-in diagnostic tools — call proactively when events seem missing or delayed:",
+			"  fnl_status — gateway running state, all listeners alive/dead, Claude WS clients",
+			"  fnl_debug  — per-channel diagnosis with last 10 events, rootCause, suggestedActions",
+			"               omit channel arg to diagnose all channels; check summary.suggestedActions first",
+			channelContext
+		].join("\n")
+	});
+	server.setRequestHandler(ListToolsRequestSchema, async () => {
+		const connectorTools = (channel?.connectors ?? []).map((c) => ({
+			name: c.name,
+			description: `Call the "${c.name}" (${c.type}) connector. ${usageHintForType(c.type)}`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					method: {
+						type: "string",
+						description: "HTTP verb or API method (e.g. POST, chat.postMessage)"
+					},
+					path: {
+						type: "string",
+						description: "API path or method name (adapter-specific)"
+					},
+					body: {
+						type: "object",
+						description: "Request body / params (adapter-specific)"
+					}
+				},
+				required: ["method", "path"]
+			}
+		}));
+		const channelEnum = allChannels.length > 0 ? allChannels.map((ch) => ch.name) : void 0;
+		const builtinTools = [{
+			name: "fnl_status",
+			description: "Return the current funnel gateway status as JSON — gateway running state, listener alive/dead per channel, and connected Claude WS clients. Call this when you need to check whether the gateway is up or why events stopped arriving.",
+			inputSchema: {
+				type: "object",
+				properties: {}
+			}
+		}, {
+			name: "fnl_debug",
+			description: "Return a full channel diagnosis as JSON — gateway health, listener state, Claude WS connection, last 10 inbound events with outcome, connectionErrors (when listener is dead), and diagnosis.rootCause. Call this first when debugging missing events. Omit `channel` to diagnose all channels at once.",
+			inputSchema: {
+				type: "object",
+				properties: { channel: channelEnum ? {
+					type: "string",
+					description: `Channel name to inspect. One of: ${channelEnum.join(", ")}. Omit to get all channels.`,
+					enum: channelEnum
+				} : {
+					type: "string",
+					description: "Channel name to inspect. Omit to get all channels."
+				} }
+			}
+		}];
+		return { tools: [...connectorTools, ...builtinTools] };
+	});
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const toolName = request.params.name;
+		if (isBuiltinTool(toolName)) return handleBuiltinTool(toolName, request.params.arguments, gatewayBaseUrl, token, allChannels);
+		if (!channel) throw new Error("FUNNEL_CHANNEL_ID is not set or channel not found in settings.json");
+		const args = request.params.arguments ?? {};
+		const method = typeof args.method === "string" ? args.method : "";
+		const path = typeof args.path === "string" ? args.path : "";
+		const body = args.body ?? {};
+		if (!method || !path) throw new Error("`method` and `path` are required");
+		const url = `${gatewayBaseUrl}/channels/${encodeURIComponent(channel.channelName)}/connectors/${encodeURIComponent(toolName)}/call`;
+		const headers = { "content-type": "application/json" };
+		if (token) headers.authorization = `Bearer ${token}`;
+		const res = await fetch(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				method,
+				path,
+				body
+			})
+		});
+		const text = await res.text();
+		if (!res.ok) throw new Error(`gateway call failed (${res.status}): ${text}`);
+		return { content: [{
+			type: "text",
+			text
+		}] };
+	});
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	if (!channelId) return;
+	new FunnelChannelSubscriber({
+		server,
+		baseUrl: `${gatewayWsUrl}?channel=${encodeURIComponent(channelId)}`,
+		protocols: token ? [`funnel.token.${token}`] : void 0
+	}).start();
+};
+const handleBuiltinTool = async (name, args, gatewayBaseUrl, token, allChannels) => {
+	const headers = {};
+	if (token) headers.authorization = `Bearer ${token}`;
+	if (name === "fnl_status") {
+		const res = await fetch(`${gatewayBaseUrl}/status`, { headers }).catch(() => null);
+		if (!res) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				running: false,
+				error: "gateway unreachable",
+				hint: "run: fnl gateway start",
+				knownChannels: allChannels.map((ch) => ch.name)
+			})
+		}] };
+		const body = await res.json();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(body)
+		}] };
+	}
+	const channelArg = typeof args?.channel === "string" ? args.channel : null;
+	const url = channelArg ? `${gatewayBaseUrl}/debug?channel=${encodeURIComponent(channelArg)}` : `${gatewayBaseUrl}/debug`;
+	const res = await fetch(url, { headers }).catch(() => null);
+	if (!res) return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			gateway: { running: false },
+			channels: allChannels.map((ch) => ({
+				id: ch.id,
+				name: ch.name,
+				diagnosis: {
+					status: "error",
+					message: "gateway is not running",
+					nextAction: "fnl gateway start",
+					rootCause: null
+				}
+			}))
+		})
+	}] };
+	const body = await res.json();
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(body)
+	}] };
+};
+//#endregion
+export { FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FileProcessGuard, FunnelClaude, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelMcp, FunnelProfiles, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, MemoryFunnelTokenPrompter, NodeFunnelTokenPrompter, channelSpecSchema, connectorSpecSchema, funnelJsonSchema, localConfigSchema, profileSpecSchema, startChannelServer };

package/dist/{connector-diagnostic-log-OPpPi9V9.d.ts → connector-diagnostic-log-yTOojKUR.d.ts}

@@ -1,5 +1,18 @@
 import { z } from "zod";
 
+//#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
 //#region lib/connectors/connector-listener.d.ts
 type NotifyFn = (content: string, meta?: Record<string, string>) => Promise<void>;
 /**
@@ -19,19 +32,6 @@ declare abstract class FunnelConnectorListener {
   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
 //#region lib/gateway/connector-diagnostic-log.d.ts
 /**
  * Points in the listener's connection lifecycle. The single source of truth
@@ -205,4 +205,4 @@ declare abstract class ConnectorDiagnosticLog {
   abstract close(): void;
 }
 //#endregion
-export { NotifyFn as S, connectorConnectionEventSchema as _, ConnectorConnectionStatus as a, FunnelLogger as b, ConnectorProcessedQuery as c, ConnectorRawEvent as d, ConnectorRawQuery as f, StoredRawEvent as g, StoredProcessedEvent as h, ConnectorConnectionRecord as i, ConnectorProcessedRecord as l, StoredConnectionEvent as m, ConnectorConnectionEvent as n, ConnectorDiagnosticLog as o, ConnectorRawRecord as p, ConnectorConnectionQuery as r, ConnectorProcessedEvent as s, CONNECTOR_CONNECTION_STATUSES as t, ConnectorQuery as u, connectorProcessedEventSchema as v, FunnelConnectorListener as x, connectorRawEventSchema as y };
+export { FunnelLogger as S, connectorConnectionEventSchema as _, ConnectorConnectionStatus as a, FunnelConnectorListener as b, ConnectorProcessedQuery as c, ConnectorRawEvent as d, ConnectorRawQuery as f, StoredRawEvent as g, StoredProcessedEvent as h, ConnectorConnectionRecord as i, ConnectorProcessedRecord as l, StoredConnectionEvent as m, ConnectorConnectionEvent as n, ConnectorDiagnosticLog as o, ConnectorRawRecord as p, ConnectorConnectionQuery as r, ConnectorProcessedEvent as s, CONNECTOR_CONNECTION_STATUSES as t, ConnectorQuery as u, connectorProcessedEventSchema as v, NotifyFn as x, connectorRawEventSchema as y };

package/dist/{logger-Czli2OKh.js → connector-listener-DU54DN-f.js}

@@ -16,12 +16,4 @@ var FunnelConnectorListener = class {
 	}
 };
 //#endregion
-//#region lib/engine/logger/logger.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.
-*/
-var FunnelLogger = class {};
-//#endregion
-export { FunnelConnectorListener as n, FunnelLogger as t };
+export { FunnelConnectorListener as t };

package/dist/connectors/discord.d.ts

@@ -1,6 +1,6 @@
-import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-VA6undzc.js";
-import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-DF4pL3Sc.js";
-import { S as NotifyFn, b as FunnelLogger, o as ConnectorDiagnosticLog, x as FunnelConnectorListener } from "../connector-diagnostic-log-OPpPi9V9.js";
+import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "../connector-diagnostic-log-yTOojKUR.js";
+import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-DKgsVuMH.js";
+import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-R0Uu-3ns.js";
 
 //#region lib/engine/http/http-client.d.ts
 type HttpRequest = {

package/dist/connectors/discord.js

@@ -1,2 +1,3 @@
-import { i as FunnelDiscordAdapter, n as FunnelDiscordListener, r as FunnelDiscordEventProcessor, t as discordConnectorSchema } from "../discord-connector-schema-BeThExJp.js";
+import { n as FunnelDiscordEventProcessor, r as FunnelDiscordAdapter, t as FunnelDiscordListener } from "../discord-listener-_jSE3HsQ.js";
+import { t as discordConnectorSchema } from "../discord-connector-schema-CBDyGdOI.js";
 export { FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnectorSchema };

package/dist/connectors/gh.d.ts

@@ -1,6 +1,7 @@
-import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-VA6undzc.js";
-import { S as NotifyFn, b as FunnelLogger, o as ConnectorDiagnosticLog, x as FunnelConnectorListener } from "../connector-diagnostic-log-OPpPi9V9.js";
-import { a as FunnelProcessRunner, n as ghConnectorSchema, t as GhConnectorConfig } from "../gh-connector-schema-CQmEWzdV.js";
+import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "../connector-diagnostic-log-yTOojKUR.js";
+import { r as FunnelProcessRunner } from "../process-runner-DfniuWVU.js";
+import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-DKgsVuMH.js";
+import { n as ghConnectorSchema, t as GhConnectorConfig } from "../gh-connector-schema-eoTtHbY6.js";
 
 //#region lib/connectors/gh-adapter.d.ts
 type Deps$1 = {

package/dist/connectors/gh.js

@@ -1,2 +1,3 @@
-import { n as FunnelGhListener, r as FunnelGhAdapter, t as ghConnectorSchema } from "../gh-connector-schema-eYE4g77K.js";
+import { t as ghConnectorSchema } from "../gh-connector-schema-o3Q1-ojL.js";
+import { n as FunnelGhAdapter, t as FunnelGhListener } from "../gh-listener-DH-fClQm.js";
 export { FunnelGhAdapter, FunnelGhListener, ghConnectorSchema };

package/dist/connectors/schedule.d.ts

@@ -1,4 +1,4 @@
-import { c as ScheduleEntry, d as scheduleEntrySchema, l as scheduleCatchupPolicySchema, n as ScheduleOnFired, o as ScheduleCatchupPolicy, r as ScheduleStateStore, s as ScheduleConnectorConfig, t as FunnelScheduleListener, u as scheduleConnectorSchema } from "../schedule-listener-3M6WkH1Y.js";
+import { a as ScheduleEntry, c as scheduleEntrySchema, i as ScheduleConnectorConfig, l as ScheduleStateStore, n as ScheduleOnFired, o as scheduleCatchupPolicySchema, r as ScheduleCatchupPolicy, s as scheduleConnectorSchema, t as FunnelScheduleListener } from "../schedule-listener-CUyUFFR1.js";
 
 //#region lib/connectors/match-cron.d.ts
 declare const matchCron: (expr: string, date: Date) => boolean;

package/dist/connectors/schedule.js

@@ -1,2 +1,3 @@
-import { a as ScheduleStateStore, c as matchCron, i as FunnelScheduleListener, n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "../schedule-connector-schema-CM-sRkac.js";
+import { n as ScheduleStateStore, r as matchCron, t as FunnelScheduleListener } from "../schedule-listener-ePAjians.js";
+import { n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "../schedule-connector-schema-iCI61gzU.js";
 export { FunnelScheduleListener, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema };

package/dist/connectors/slack.d.ts

@@ -1,5 +1,5 @@
-import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-VA6undzc.js";
-import { a as SlackProcessed, c as SlackRawEvent, d as slackConnectorSchema, i as FunnelSlackEventProcessor, l as SlackSkipReason, n as SlackOnAppCreated, o as SlackProcessedEmit, r as SlackPreprocessEvent, s as SlackProcessedSkip, t as FunnelSlackListener, u as SlackConnectorConfig } from "../slack-listener-9UdAn_ui.js";
+import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-DKgsVuMH.js";
+import { a as slackConnectorSchema, c as SlackProcessedEmit, d as SlackSkipReason, i as SlackConnectorConfig, l as SlackProcessedSkip, n as SlackOnAppCreated, o as FunnelSlackEventProcessor, r as SlackPreprocessEvent, s as SlackProcessed, t as FunnelSlackListener, u as SlackRawEvent } from "../slack-listener-Bv5xI9gC.js";
 
 //#region lib/connectors/slack-adapter.d.ts
 type SlackWebClientLike = {

package/dist/connectors/slack.js

@@ -1,2 +1,3 @@
-import { i as FunnelSlackAdapter, n as FunnelSlackListener, r as FunnelSlackEventProcessor, t as slackConnectorSchema } from "../slack-connector-schema-DDbSGPZn.js";
+import { n as FunnelSlackEventProcessor, r as FunnelSlackAdapter, t as FunnelSlackListener } from "../slack-listener-ClQuHhEF.js";
+import { t as slackConnectorSchema } from "../slack-connector-schema-BCNWluHM.js";
 export { FunnelSlackAdapter, FunnelSlackEventProcessor, FunnelSlackListener, slackConnectorSchema };

package/dist/discord-connector-schema-CBDyGdOI.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+//#region lib/connectors/discord-connector-schema.ts
+/**
+* Like slack, a discord connector holds either a literal `botToken` or a
+* `botTokenEnv` reference resolved from `process.env` at listener start. The
+* reference form keeps the secret out of settings.json, but is only set through
+* the engine API (`new Funnel(...)`); funnel.json and the `fnl` CLI produce
+* literals.
+*/
+const discordConnectorSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.literal("discord"),
+	botToken: z.string().min(10).optional(),
+	/** Name of the env var holding the bot token, resolved at listener start. */
+	botTokenEnv: z.string().optional(),
+	createdAt: z.string().datetime().optional(),
+	updatedAt: z.string().datetime().optional()
+});
+//#endregion
+export { discordConnectorSchema as t };

package/dist/{discord-connector-schema-BeThExJp.js → discord-listener-_jSE3HsQ.js}

@@ -1,8 +1,7 @@
 import { t as FunnelConnectorAdapter } from "./connector-adapter-D5Utumgz.js";
 import { t as resolveConnectorToken } from "./resolve-connector-token-BHmZLRrV.js";
-import { n as FunnelConnectorListener } from "./logger-Czli2OKh.js";
+import { t as FunnelConnectorListener } from "./connector-listener-DU54DN-f.js";
 import { Client, GatewayIntentBits, Partials } from "discord.js";
-import { z } from "zod";
 //#region lib/engine/http/http-client.ts
 var FunnelHttpClient = class {};
 //#endregion
@@ -225,23 +224,4 @@ const messageOf = (error) => {
 	return error instanceof Error ? error.message : String(error);
 };
 //#endregion
-//#region lib/connectors/discord-connector-schema.ts
-/**
-* Like slack, a discord connector holds either a literal `botToken` or a
-* `botTokenEnv` reference resolved from `process.env` at listener start. The
-* reference form keeps the secret out of settings.json, but is only set through
-* the engine API (`new Funnel(...)`); funnel.json and the `fnl` CLI produce
-* literals.
-*/
-const discordConnectorSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	type: z.literal("discord"),
-	botToken: z.string().min(10).optional(),
-	/** Name of the env var holding the bot token, resolved at listener start. */
-	botTokenEnv: z.string().optional(),
-	createdAt: z.string().datetime().optional(),
-	updatedAt: z.string().datetime().optional()
-});
-//#endregion
-export { FunnelDiscordAdapter as i, FunnelDiscordListener as n, FunnelDiscordEventProcessor as r, discordConnectorSchema as t };
+export { FunnelDiscordEventProcessor as n, FunnelDiscordAdapter as r, FunnelDiscordListener as t };

package/dist/file-system-BeOKXjlV.d.ts

@@ -0,0 +1,26 @@
+//#region lib/engine/fs/file-system.d.ts
+type FileStat = {
+  mtimeMs: number; /** POSIX mode bits (e.g. 0o600). `null` when the underlying FS does not expose mode. */
+  mode: number | null;
+};
+/**
+ * Filesystem boundary used everywhere funnel reads or writes.
+ * Default is NodeFunnelFileSystem (real `node:fs`); MemoryFunnelFileSystem
+ * provides a sandbox for tests and embedded use.
+ */
+declare abstract class FunnelFileSystem {
+  abstract existsSync(path: string): boolean;
+  abstract readFileSync(path: string): string;
+  abstract writeFileSync(path: string, data: string): void;
+  /** Write `data` and ensure the resulting file is owner-only (0600). Use for tokens and any file that may contain secrets. */
+  abstract writeSecretFileSync(path: string, data: string): void;
+  abstract appendFileSync(path: string, data: string): void;
+  abstract unlink(path: string): void;
+  abstract mkdirSync(path: string, options?: {
+    recursive?: boolean;
+  }): void;
+  abstract readdirSync(path: string): string[];
+  abstract statSync(path: string): FileStat;
+}
+//#endregion
+export { FunnelFileSystem as n, FileStat as t };

package/dist/file-system-PWKKU7lA.js

@@ -0,0 +1,9 @@
+//#region lib/engine/fs/file-system.ts
+/**
+* Filesystem boundary used everywhere funnel reads or writes.
+* Default is NodeFunnelFileSystem (real `node:fs`); MemoryFunnelFileSystem
+* provides a sandbox for tests and embedded use.
+*/
+var FunnelFileSystem = class {};
+//#endregion
+export { FunnelFileSystem as t };

package/dist/gateway.d.ts

@@ -0,0 +1,3 @@
+import { _ as connectorConnectionEventSchema, a as ConnectorConnectionStatus, c as ConnectorProcessedQuery, d as ConnectorRawEvent, f as ConnectorRawQuery, g as StoredRawEvent, h as StoredProcessedEvent, i as ConnectorConnectionRecord, l as ConnectorProcessedRecord, m as StoredConnectionEvent, n as ConnectorConnectionEvent, o as ConnectorDiagnosticLog, p as ConnectorRawRecord, r as ConnectorConnectionQuery, s as ConnectorProcessedEvent, t as CONNECTOR_CONNECTION_STATUSES, u as ConnectorQuery, v as connectorProcessedEventSchema, y as connectorRawEventSchema } from "./connector-diagnostic-log-yTOojKUR.js";
+import { $ as FunnelGatewayToken, G as SqliteFunnelEventLog, H as MemoryConnectorDiagnosticLog, J as PublishResponse, K as FunnelChannelPublisher, Q as DEFAULT_GATEWAY_TOKEN_PATH, U as SqliteConnectorDiagnosticLog, W as MemoryFunnelEventLog, X as publishRequestSchema, Y as PublishResult, Z as publishResponseSchema, at as Env, ct as FunnelListenerSupervisor, dt as FunnelBroadcaster, et as FunnelGatewayServer, ft as ReplayableEvent, it as funnelEventSchema, lt as BroadcastEvent, nt as FunnelEventLog, ot as GatewayEmitInput, q as PublishRequest, rt as FunnelEventRecord, st as GatewayRouteDeps, t as GatewayApp, tt as FunnelEvent, ut as BroadcastSubscriber } from "./index-BM0-f6KL.js";
+export { BroadcastEvent, BroadcastSubscriber, CONNECTOR_CONNECTION_STATUSES, ConnectorConnectionEvent, ConnectorConnectionQuery, ConnectorConnectionRecord, ConnectorConnectionStatus, ConnectorDiagnosticLog, ConnectorProcessedEvent, ConnectorProcessedQuery, ConnectorProcessedRecord, ConnectorQuery, ConnectorRawEvent, ConnectorRawQuery, ConnectorRawRecord, DEFAULT_GATEWAY_TOKEN_PATH, FunnelBroadcaster, FunnelChannelPublisher, FunnelEvent, FunnelEventLog, FunnelEventRecord, FunnelGatewayServer, FunnelGatewayToken, FunnelListenerSupervisor, type GatewayApp, type GatewayEmitInput, type GatewayRouteDeps, type Env as GatewayServerEnv, MemoryConnectorDiagnosticLog, MemoryFunnelEventLog, PublishRequest, PublishResponse, PublishResult, ReplayableEvent, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, StoredConnectionEvent, StoredProcessedEvent, StoredRawEvent, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, funnelEventSchema, publishRequestSchema, publishResponseSchema };

package/dist/gateway.js

@@ -0,0 +1,2 @@
+import { _ as FunnelBroadcaster, a as connectorConnectionEventSchema, b as publishResponseSchema, c as MemoryFunnelEventLog, d as FunnelGatewayServer, g as funnelEventSchema, h as FunnelEventLog, i as ConnectorDiagnosticLog, l as DEFAULT_GATEWAY_TOKEN_PATH, m as SqliteFunnelEventLog, n as SqliteConnectorDiagnosticLog, o as connectorProcessedEventSchema, p as FunnelListenerSupervisor, r as CONNECTOR_CONNECTION_STATUSES, s as connectorRawEventSchema, t as MemoryConnectorDiagnosticLog, u as FunnelGatewayToken, v as FunnelChannelPublisher, y as publishRequestSchema } from "./memory-connector-diagnostic-log-CrW1ltLM.js";
+export { CONNECTOR_CONNECTION_STATUSES, ConnectorDiagnosticLog, DEFAULT_GATEWAY_TOKEN_PATH, FunnelBroadcaster, FunnelChannelPublisher, FunnelEventLog, FunnelGatewayServer, FunnelGatewayToken, FunnelListenerSupervisor, MemoryConnectorDiagnosticLog, MemoryFunnelEventLog, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, funnelEventSchema, publishRequestSchema, publishResponseSchema };

package/dist/gh-connector-schema-eoTtHbY6.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+//#region lib/connectors/gh-connector-schema.d.ts
+declare const ghConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"gh">;
+  pollInterval: z.ZodOptional<z.ZodNumber>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GhConnectorConfig = z.infer<typeof ghConnectorSchema>;
+//#endregion
+export { ghConnectorSchema as n, GhConnectorConfig as t };