@interactive-inc/claude-funnel 0.41.0 → 0.50.0

package/dist/claude-CB1WkV77.d.ts

@@ -0,0 +1,115 @@
+import { n as FunnelIdGenerator, r as ChannelConfig } from "./settings-reader-BSU6JyvM.js";
+import { S as FunnelLogger } from "./connector-diagnostic-log-yTOojKUR.js";
+import { r as FunnelProcessRunner } from "./process-runner-DfniuWVU.js";
+
+//#region lib/engine/claude/channel-resolver.d.ts
+type ChannelResolver = {
+  get(name: string): ChannelConfig | null;
+  getById(id: string): ChannelConfig | null;
+};
+//#endregion
+//#region lib/engine/claude/gateway-controller.d.ts
+type GatewayController = {
+  isRunning(): boolean;
+  start(options?: {
+    caffeinate?: boolean;
+  }): Promise<boolean>;
+};
+//#endregion
+//#region lib/engine/claude/mcp-installer.d.ts
+type McpInstaller = {
+  findInstalledName(cwd: string): string | null;
+  install(cwd: string): void;
+};
+//#endregion
+//#region lib/engine/claude/process-guard.d.ts
+type ProcessGuard = {
+  /** Returns true if a live process is already registered for this profile. */isRunning(profileId: string): boolean; /** Writes the PID file and registers an exit hook to clean it up. */
+  acquire(profileId: string): void; /** Removes the PID file. */
+  release(profileId: string): void;
+};
+//#endregion
+//#region lib/engine/claude/session-store.d.ts
+type SessionStore = {
+  getSessionId(profileId: string): string | null;
+  setSessionId(profileId: string, sessionId: string): void; /** Returns true when the session jsonl exists on disk and is non-empty. */
+  sessionFileExists(cwd: string, sessionId: string, env: Record<string, string>): boolean;
+};
+//#endregion
+//#region lib/engine/claude/claude.d.ts
+type LaunchOptions = {
+  channel: string;
+  cwd?: string;
+  userArgs?: string[];
+  /** Stable id of the launching profile (uuid). Keys the singleton PID file and
+   *  the resumable session. Absent for a profile-less launch (raw `--channel`),
+   *  which never enforces singleton-ness and never resumes. */
+  profileId?: string; /** Args prepended to the claude argv (typically a profile's recipe). Defaults to none. */
+  options?: string[]; /** Env vars layered under the launched claude process. process.env wins on collision. */
+  env?: Record<string, string>;
+  /** Whether to inject a `--session-id`/`--resume` for this profile.
+   *  Defaults to false: resuming is opt-in and only meaningful for a profile,
+   *  since the persisted session is owned by the profile (by id). A launch
+   *  without a profile always starts a fresh session regardless of this flag. */
+  resume?: boolean;
+  /** Invoked synchronously after the child claude process has been spawned, with its PID.
+   *  Useful for hosts that need to register the spawned process before it exits
+   *  (e.g. multi-session registries that track per-claude liveness). */
+  onSpawned?: (pid: number) => void;
+  /** Whether to install the funnel MCP entry into `.mcp.json` (default: true).
+   *  Set to false when the host already provides its own MCP server entry and
+   *  does not need the funnel binary as an MCP endpoint. */
+  installMcp?: boolean;
+};
+type Deps = {
+  channels: ChannelResolver;
+  mcp: McpInstaller;
+  gateway: GatewayController;
+  sessions: SessionStore;
+  guard: ProcessGuard;
+  process?: FunnelProcessRunner;
+  idGenerator?: FunnelIdGenerator;
+  logger?: FunnelLogger;
+};
+/**
+ * Launches Claude Code with funnel pre-wired: ensures the gateway is running,
+ * installs the funnel MCP into the target repo's `.mcp.json` if missing,
+ * injects `FUNNEL_CHANNEL_ID` into the child env, and delegates singleton
+ * enforcement to a ProcessGuard.
+ */
+declare class FunnelClaude {
+  private readonly channels;
+  private readonly mcp;
+  private readonly gateway;
+  private readonly sessions;
+  private readonly guard;
+  private readonly process;
+  private readonly idGenerator;
+  private readonly logger;
+  constructor(deps: Deps);
+  launch(options: LaunchOptions): Promise<number>;
+  private buildArgs;
+  /**
+   * Decides whether funnel should resume an existing claude session or start
+   * a freshly minted one. Backs off when the user already passed a
+   * session-shaping flag, since combining them would either confuse claude
+   * or override the explicit user intent.
+   *
+   * The session is owned by the profile (by id), not by cwd: two profiles
+   * pointing at the same repo each keep their own conversation, and a launch
+   * with no profile never resumes — so an unrelated session in the same repo
+   * can't bleed in. The channel never enters into it; sessions belong to the
+   * launch layer (profiles), keeping the transport layer ignorant of them.
+   *
+   * A persisted id is only resumed when its session jsonl still exists on
+   * disk. claude errors out on `--resume <id>` for a missing conversation, and
+   * a persisted id can outlive its jsonl (claude pruned it, or the very first
+   * launch was aborted after the id was written but before the jsonl
+   * appeared). When the file is gone we mint a fresh session instead, which
+   * overwrites the dangling entry — so the store self-heals.
+   */
+  private resolveSession;
+  private buildEnv;
+}
+//#endregion
+export { McpInstaller as a, ProcessGuard as i, LaunchOptions as n, GatewayController as o, SessionStore as r, ChannelResolver as s, FunnelClaude as t };

package/dist/claude.d.ts

@@ -0,0 +1,59 @@
+import { a as McpInstaller, i as ProcessGuard, n as LaunchOptions, o as GatewayController, r as SessionStore, s as ChannelResolver, t as FunnelClaude } from "./claude-CB1WkV77.js";
+import { r as FunnelProcessRunner } from "./process-runner-DfniuWVU.js";
+import { n as FunnelFileSystem } from "./file-system-BeOKXjlV.js";
+import { t as FunnelProfiles } from "./profiles-f0mNmEyP.js";
+import { C as profileSpecSchema, S as localConfigSchema, _ as LOCAL_CONFIG_FILENAME, b as channelSpecSchema, g as ConnectorSpec, h as ChannelSpec, i as FunnelTokenPrompter, m as FunnelLocalConfig, n as FunnelLocalConfigSync, r as LocalConfigSyncResult, t as ConnectorSyncOutcome, v as LocalConfig, x as connectorSpecSchema, y as ProfileSpec } from "./local-config-sync-BdsrDZOu.js";
+import { i as funnelJsonSchema, n as NodeFunnelTokenPrompter, r as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-B5FFCsGP.js";
+
+//#region lib/engine/claude/file-process-guard.d.ts
+type Deps$1 = {
+  fs?: FunnelFileSystem;
+  process?: FunnelProcessRunner;
+  dir?: string;
+};
+declare class FileProcessGuard implements ProcessGuard {
+  private readonly fs;
+  private readonly process;
+  private readonly pidDir;
+  constructor(deps?: Deps$1);
+  isRunning(profileId: string): boolean;
+  acquire(profileId: string): void;
+  release(profileId: string): void;
+  private pidPath;
+  private readPid;
+}
+//#endregion
+//#region lib/engine/mcp/mcp.d.ts
+declare const FUNNEL_MCP_COMMAND = "bun";
+declare const FUNNEL_MCP_ARGS: string[];
+declare const FUNNEL_MCP_NAME = "funnel";
+type Deps = {
+  fs?: FunnelFileSystem;
+};
+/**
+ * Installs/uninstalls the funnel MCP entry into a target repository's
+ * `.mcp.json`. Detects an existing entry by command match so renaming is
+ * preserved across re-installs.
+ */
+declare class FunnelMcp {
+  private readonly fs;
+  constructor(deps?: Deps);
+  install(repoPath: string): void;
+  uninstall(repoPath: string): void;
+  findInstalledName(cwd: string): string | null;
+  private findServerName;
+  private isFunnelEntry;
+  private readConfig;
+  private writeConfig;
+}
+//#endregion
+//#region lib/engine/mcp/channel-server.d.ts
+type ChannelServerOptions = {
+  /** Funnel home directory (settings.json + gateway.token). Defaults to ~/.funnel. */dir?: string; /** Gateway base URL. Defaults to `$FUNNEL_GATEWAY_URL` or `http://127.0.0.1:<port>`. */
+  gatewayUrl?: string; /** Channel id to subscribe to. Defaults to `$FUNNEL_CHANNEL_ID`. */
+  channelId?: string; /** Auth token. Defaults to `$FUNNEL_GATEWAY_TOKEN` then `<dir>/gateway.token`. */
+  token?: string;
+};
+declare const startChannelServer: (options?: ChannelServerOptions) => Promise<void>;
+//#endregion
+export { ChannelResolver, ChannelServerOptions, ChannelSpec, ConnectorSpec, ConnectorSyncOutcome, FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FileProcessGuard, FunnelClaude, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelMcp, FunnelProfiles, FunnelTokenPrompter, GatewayController, LOCAL_CONFIG_FILENAME, LaunchOptions, LocalConfig, LocalConfigSyncResult, McpInstaller, MemoryFunnelTokenPrompter, NodeFunnelTokenPrompter, ProcessGuard, ProfileSpec, SessionStore, channelSpecSchema, connectorSpecSchema, funnelJsonSchema, localConfigSchema, profileSpecSchema, startChannelServer };

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