@interactive-inc/claude-funnel 0.59.0 → 0.60.0

package/dist/channels-2g_BU1N0.d.ts

@@ -0,0 +1,174 @@
+import { n as ChannelDeliveryMode, t as ChannelConfig } from "./settings-schema-D1xcOqRu.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-BIFB_j2f.js";
+import { A as FunnelConnectorAdapter, B as FunnelLogger, D as FunnelConnectorListener, I as FunnelProcessRunner, M as BaseConnectorConfig, k as CallInput, n as ConnectorBuildContext, o as ConnectorOperationContext, p as ConnectorDiagnosticLog, r as ConnectorDescriptor, s as ConnectorUpdateContext } from "./connector-descriptor-6SXJoszo.js";
+import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
+
+//#region lib/engine/connectors/connector-registry.d.ts
+type Deps$1 = {
+  /** Connector types this funnel handles. Each is a self-describing descriptor;
+   *  importing it is what pulls its (heavy) listener/adapter code into the bundle,
+   *  so omitting a type keeps it out entirely. */
+  descriptors: ConnectorDescriptor[];
+  fs?: FunnelFileSystem;
+  process?: FunnelProcessRunner;
+  logger?: FunnelLogger;
+  diagnosticLog?: ConnectorDiagnosticLog;
+  dir?: string;
+};
+/**
+ * Dispatches connector work to injected descriptors by `type`. Replaces the old
+ * hard-coded factory: core never imports a concrete connector, so listener and
+ * adapter code (and their SDKs) is bundled only when the host passes that type's
+ * descriptor to `new Funnel({ connectors: [...] })`.
+ *
+ * `dir` is the funnel home; per-connector state files land at
+ * `<dir>/channels/<channel-id>/connectors/<connector-id>/`.
+ */
+declare class FunnelConnectorRegistry {
+  private readonly descriptors;
+  private readonly fs;
+  private readonly process;
+  private readonly logger;
+  private readonly diagnosticLog;
+  private readonly dir;
+  constructor(deps: Deps$1);
+  has(type: string): boolean;
+  types(): string[];
+  createListener(channelId: string, config: BaseConnectorConfig): FunnelConnectorListener;
+  createAdapter(config: BaseConnectorConfig): FunnelConnectorAdapter | null;
+  secretTokens(config: BaseConnectorConfig): string[];
+  buildConfig(input: Record<string, unknown>, context: ConnectorBuildContext): BaseConnectorConfig;
+  applyUpdate(config: BaseConnectorConfig, fields: Record<string, unknown>, context: ConnectorUpdateContext): BaseConnectorConfig;
+  runOperation(config: BaseConnectorConfig, name: string, args: unknown, context: ConnectorOperationContext): {
+    config: BaseConnectorConfig;
+    result: unknown;
+  };
+  connectorDir(channelId: string, connectorId: string): string;
+  channelDir(channelId: string): string;
+  private require;
+  private listenerDeps;
+  private adapterDeps;
+}
+//#endregion
+//#region lib/engine/profiles/profile-channel-checker.d.ts
+/**
+ * Read-side dependency that lets FunnelChannels ask whether a profile
+ * references a given channel id, without depending on FunnelProfiles directly.
+ */
+type ProfileChannelChecker = {
+  hasChannelRef(channelId: string): boolean;
+};
+//#endregion
+//#region lib/engine/time/clock.d.ts
+/**
+ * Time boundary. Default NodeFunnelClock returns `new Date()`; MemoryFunnelClock
+ * is settable and `advance(ms)`-able for deterministic schedule / timeout tests.
+ */
+declare abstract class FunnelClock {
+  abstract now(): Date;
+  millis(): number;
+  iso(): string;
+}
+//#endregion
+//#region lib/engine/channels/channels.d.ts
+type Deps = {
+  store: FunnelSettingsReader;
+  registry: FunnelConnectorRegistry;
+  profileChecker?: ProfileChannelChecker;
+  clock?: FunnelClock;
+  idGenerator?: FunnelIdGenerator;
+};
+type ChannelConnectorView = BaseConnectorConfig & {
+  channelId: string;
+  channelName: string;
+};
+/**
+ * Add-connector input. Core does not enumerate connector types, so the shape is
+ * the common pair plus arbitrary type-specific fields — the connector's
+ * descriptor (via the registry) builds and validates the concrete config.
+ */
+type AddConnectorInput = {
+  type: string;
+  name: string;
+} & Record<string, unknown>;
+/**
+ * Channels own their connectors. Each channel has a stable id (UUID); the
+ * `name` is the human-facing label used by the CLI. Connectors live nested
+ * inside `channel.connectors[]`, so add/remove/rename are channel-scoped — no
+ * global connector namespace exists. Token uniqueness is enforced across all
+ * channels at add/update time so the same Slack/Discord credentials cannot
+ * be registered twice.
+ *
+ * Connector type knowledge lives entirely in the injected registry (descriptors):
+ * this class builds, updates, and runs operations on connectors generically and
+ * never imports a concrete connector type.
+ */
+declare class FunnelChannels {
+  private readonly store;
+  private readonly registry;
+  private readonly profileChecker;
+  private readonly clock;
+  private readonly idGenerator;
+  constructor(deps: Deps);
+  list(): ChannelConfig[];
+  get(name: string): ChannelConfig | null;
+  getById(id: string): ChannelConfig | null;
+  add(input: {
+    name: string;
+    delivery?: ChannelDeliveryMode;
+  }): ChannelConfig;
+  setDelivery(name: string, delivery: ChannelDeliveryMode): void;
+  remove(name: string): void;
+  rename(oldName: string, newName: string): void;
+  listConnectors(channelName: string): BaseConnectorConfig[];
+  getConnector(channelName: string, connectorName: string): BaseConnectorConfig | null;
+  listAllConnectors(): ChannelConnectorView[];
+  addConnector(channelName: string, input: AddConnectorInput): BaseConnectorConfig;
+  removeConnector(channelName: string, connectorName: string): void;
+  renameConnector(channelName: string, oldName: string, newName: string): void;
+  /**
+   * Update a connector's mutable fields generically. The connector's descriptor
+   * rebuilds the config from `fields` (e.g. Slack/Discord token slots are rebuilt
+   * so a slot can move between a literal and an env reference cleanly).
+   */
+  updateConnector(channelName: string, connectorName: string, fields: Record<string, unknown>): void;
+  /** Back-compat wrapper for `updateConnector` on a slack connector. */
+  updateSlackConnector(channelName: string, connectorName: string, fields: {
+    botToken?: string;
+    appToken?: string;
+    botTokenEnv?: string;
+    appTokenEnv?: string;
+  }): void;
+  /** Back-compat wrapper for `updateConnector` on a gh connector. */
+  updateGhConnector(channelName: string, connectorName: string, fields: {
+    pollInterval?: number;
+  }): void;
+  /** Back-compat wrapper for `updateConnector` on a discord connector. */
+  updateDiscordConnector(channelName: string, connectorName: string, fields: {
+    botToken?: string;
+    botTokenEnv?: string;
+  }): void;
+  /**
+   * Run a connector-type-specific operation (e.g. schedule `addEntry` /
+   * `removeEntry` / `listEntries`). The descriptor returns the next config and a
+   * result; the config is persisted only when the operation actually mutated it.
+   */
+  connectorOp(channelName: string, connectorName: string, operation: string, args: unknown): unknown;
+  call(channelName: string, connectorName: string, input: CallInput): Promise<unknown>;
+  createListener(channelName: string, connectorName: string): {
+    config: BaseConnectorConfig;
+    channelId: string;
+    listener: FunnelConnectorListener;
+  } | null;
+  createAllListeners(): {
+    config: BaseConnectorConfig;
+    channelId: string;
+    channelName: string;
+    listener: FunnelConnectorListener;
+  }[];
+  private requireChannel;
+  private replaceConnector;
+  private assertNoTokenCollision;
+}
+//#endregion
+export { FunnelConnectorRegistry as a, FunnelClock as i, ChannelConnectorView as n, FunnelChannels as r, AddConnectorInput as t };

package/dist/claude.d.ts

@@ -1,8 +1,9 @@
-import { a as ProcessGuard, c as ChannelResolver, i as SessionStore, n as FunnelClaude, o as McpInstaller, r as LaunchOptions, s as GatewayController, t as FileProcessGuard } from "./file-process-guard-B3IFCj_G.js";
-import { n as FunnelFileSystem } from "./file-system-DxpnnUVb.js";
-import { t as FunnelProfiles } from "./profiles-g2qGVOWv.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--f739oCJ.js";
-import { i as funnelJsonSchema, n as NodeFunnelTokenPrompter, r as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-BlFwK9k7.js";
+import { a as ProcessGuard, c as ChannelResolver, i as SessionStore, n as FunnelClaude, o as McpInstaller, r as LaunchOptions, s as GatewayController, t as FileProcessGuard } from "./file-process-guard-DOlCr4GF.js";
+import { r as ConnectorDescriptor } from "./connector-descriptor-6SXJoszo.js";
+import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
+import { t as FunnelProfiles } from "./profiles-Cy5wXQ0L.js";
+import { a as FunnelLocalConfig, c as LOCAL_CONFIG_FILENAME, d as channelSpecSchema, f as connectorSpecSchema, i as FunnelTokenPrompter, l as LocalConfig, m as profileSpecSchema, n as FunnelLocalConfigSync, o as ChannelSpec, p as localConfigSchema, r as LocalConfigSyncResult, s as ConnectorSpec, t as ConnectorSyncOutcome, u as ProfileSpec } from "./local-config-sync-Dh1Croqe.js";
+import { i as funnelJsonSchema, n as NodeFunnelTokenPrompter, r as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-B4sjyaAq.js";
 
 //#region lib/engine/mcp/mcp.d.ts
 declare const FUNNEL_MCP_COMMAND = "bun";
@@ -40,6 +41,9 @@ type ChannelServerOptions = {
   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;
+  /** Connector descriptors whose tools this MCP server exposes. Defaults to the
+   *  four built-in connectors; the tool-exposed subset is derived from them. */
+  connectors?: ConnectorDescriptor[];
 };
 /**
  * Start the funnel MCP server over stdio. Wires:

package/dist/claude.js

@@ -1,9 +1,15 @@
-import { f as settingsSchema, s as resolveFunnelPort, t as gatewayLoopbackUrl } from "./gateway-base-url-6foMXfFf.js";
-import { a as FunnelMcp, i as FUNNEL_MCP_NAME, n as FUNNEL_MCP_ARGS, o as FileProcessGuard, r as FUNNEL_MCP_COMMAND, s as FunnelClaude, t as renderYaml } from "./yaml-render-C9Hhjk-0.js";
-import { t as FunnelDocs } from "./funnel-docs-ng5K8w4j.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-DE1zkMcb.js";
-import { t as FunnelProfiles } from "./profiles-MnXvYfZF.js";
-import { n as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-C7vREzCL.js";
+import { t as gatewayLoopbackUrl } from "./gateway-base-url-Dy4Ykuoh.js";
+import { d as settingsSchema, o as resolveFunnelPort } from "./settings-store-CUKSeTXC.js";
+import { a as FunnelMcp, i as FUNNEL_MCP_NAME, n as FUNNEL_MCP_ARGS, o as FileProcessGuard, r as FUNNEL_MCP_COMMAND, s as FunnelClaude, t as renderYaml } from "./yaml-render-qW34NlYz.js";
+import { t as FunnelDocs } from "./funnel-docs-BxXZ9Ksx.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-JyLqOQNX.js";
+import { t as FunnelProfiles } from "./profiles-DSzTeKQw.js";
+import { t as errorMessageOf } from "./error-message-of-Byi4y0Uf.js";
+import { t as discordConnector } from "./discord-connector-BL36yvbL.js";
+import { t as ghConnector } from "./gh-connector-DpiixfQZ.js";
+import { t as scheduleConnector } from "./schedule-connector-L4uzg5M8.js";
+import { t as slackConnector } from "./slack-connector-DQIFPdBF.js";
+import { n as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-CZde7e6y.js";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -411,13 +417,17 @@ const MAX_RECONNECT_DELAY = 1e4;
 var FunnelChannelSubscriber = class {
 	state = {
 		reconnectDelay: RECONNECT_DELAY,
-		lastOffset: 0
+		lastOffset: 0,
+		isStarted: false,
+		hasPendingReconnect: false
 	};
 	constructor(props) {
 		this.props = props;
 		Object.freeze(this);
 	}
 	start() {
+		if (this.state.isStarted) return;
+		this.state.isStarted = true;
 		this.connect();
 	}
 	connect() {
@@ -430,8 +440,13 @@ var FunnelChannelSubscriber = class {
 		});
 		ws.addEventListener("message", (event) => this.handleMessage(event));
 		ws.addEventListener("close", () => {
+			if (this.state.hasPendingReconnect) return;
+			this.state.hasPendingReconnect = true;
 			process.stderr.write(`funnel: disconnected, reconnecting in ${this.state.reconnectDelay}ms\n`);
-			setTimeout(() => this.connect(), this.state.reconnectDelay);
+			setTimeout(() => {
+				this.state.hasPendingReconnect = false;
+				this.connect();
+			}, this.state.reconnectDelay);
 			this.state.reconnectDelay = Math.min(this.state.reconnectDelay * 2, MAX_RECONNECT_DELAY);
 		});
 		ws.addEventListener("error", () => {});
@@ -450,18 +465,34 @@ var FunnelChannelSubscriber = class {
 				}
 			});
 		} catch (error) {
-			process.stderr.write(`funnel: error: ${error instanceof Error ? error.message : String(error)}\n`);
+			process.stderr.write(`funnel: error: ${errorMessageOf(error)}\n`);
 		}
 	}
 };
 //#endregion
+//#region lib/engine/connectors/builtin-connectors.ts
+/**
+* The four built-in connector descriptors. Importing this pulls every connector
+* SDK (@slack/bolt, discord.js, …) into the bundle, so it is used ONLY by
+* full-bundle entry points (the `fnl` CLI, the gateway daemon, the MCP server) —
+* never by the library's public barrel. Programmatic hosts pass the descriptors
+* they actually need to `new Funnel({ connectors: [...] })` instead.
+*/
+const builtinConnectors = () => [
+	slackConnector(),
+	ghConnector(),
+	discordConnector(),
+	scheduleConnector()
+];
+//#endregion
 //#region lib/engine/mcp/read-channel-connectors.ts
-const TOOL_CONNECTOR_TYPES = new Set([
-	"slack",
-	"gh",
-	"discord"
-]);
-const readChannelConnectors = (dir, channelId) => {
+/**
+* Reads the connectors of one channel from settings.json, keeping only the
+* tool-exposed types. The exposed set is supplied by the caller (the MCP server
+* builds it from the connector descriptors it imports) — core does not enumerate
+* connector types here.
+*/
+const readChannelConnectors = (dir, channelId, toolConnectorTypes) => {
 	const settingsPath = join(dir, "settings.json");
 	if (!existsSync(settingsPath)) return null;
 	const raw = JSON.parse(readFileSync(settingsPath, "utf-8"));
@@ -469,7 +500,7 @@ const readChannelConnectors = (dir, channelId) => {
 	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) => ({
+	const connectors = channel.connectors.filter((c) => toolConnectorTypes.has(c.type)).map((c) => ({
 		name: c.name,
 		type: c.type
 	}));
@@ -491,6 +522,11 @@ const readGatewayToken = (dir) => {
 //#endregion
 //#region lib/engine/mcp/channel-server.ts
 const DEFAULT_FUNNEL_DIR = join(homedir(), ".funnel");
+const toolConnectorTypesOf = (descriptors) => {
+	const out = /* @__PURE__ */ new Set();
+	for (const descriptor of descriptors) if (descriptor.toolExposed) out.add(descriptor.type);
+	return out;
+};
 const readAllChannels = (dir) => {
 	const settingsPath = join(dir, "settings.json");
 	if (!existsSync(settingsPath)) return [];
@@ -522,7 +558,8 @@ const startChannelServer = async (options = {}) => {
 	const gatewayBaseUrl = options.gatewayUrl ?? process.env.FUNNEL_GATEWAY_URL ?? gatewayLoopbackUrl(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 toolConnectorTypes = toolConnectorTypesOf(options.connectors ?? builtinConnectors());
+	const channel = channelId ? readChannelConnectors(dir, channelId, toolConnectorTypes) : null;
 	const token = options.token ?? readGatewayToken(dir);
 	const allChannels = readAllChannels(dir);
 	const currentChannelName = channel?.channelName ?? null;

package/dist/{diagnostic-log-Cb3v8P7p.d.ts → connector-descriptor-6SXJoszo.d.ts}

@@ -1,3 +1,4 @@
+import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
 import { z } from "zod";
 
 //#region lib/engine/logger/logger.d.ts
@@ -13,6 +14,98 @@ declare abstract class FunnelLogger {
   abstract readonly file: string | null;
 }
 //#endregion
+//#region lib/engine/process/process-runner.d.ts
+type RunOptions = {
+  cwd?: string;
+  env?: Record<string, string>;
+  input?: string;
+};
+type RunResult = {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+};
+type AttachOptions = {
+  cwd?: string;
+  env?: Record<string, string>;
+  /** Invoked synchronously after the child process has been spawned, with its PID.
+   *  Useful for hosts that need to register the spawned process before it exits. */
+  onSpawned?: (pid: number) => void;
+};
+type DetachOptions = {
+  env?: Record<string, string>; /** Append stdout to this file. Parent dir is the caller's responsibility. */
+  stdoutFile?: string; /** Append stderr to this file. Parent dir is the caller's responsibility. */
+  stderrFile?: string;
+};
+type ProcessSnapshot = {
+  pid: number;
+  command: string;
+};
+/**
+ * Process boundary covering one-shot runs, sync runs, foreground attach, and
+ * detached background spawns. Default is NodeFunnelProcessRunner (Bun.spawn);
+ * MemoryFunnelProcessRunner records calls and lets tests stub responses.
+ *
+ * Liveness and process-listing helpers absorb POSIX/Windows differences so
+ * callers do not branch on `process.platform`. `isAlive` checks whether a PID
+ * names a live (non-zombie) process; `listProcessesContaining` enumerates
+ * processes whose command line includes `marker`, used for funnel-gateway tag
+ * matching across daemons that share a home dir. `getStartTime` returns a
+ * stable string identifying when a PID was started, used to detect PID reuse
+ * after the original process died abnormally (no exit hook fired).
+ */
+declare abstract class FunnelProcessRunner {
+  abstract run(command: string[], options?: RunOptions): Promise<RunResult>;
+  abstract runSync(command: string[]): RunResult;
+  abstract attach(command: string[], options?: AttachOptions): Promise<number>;
+  abstract detach(command: string[], options?: DetachOptions): void;
+  abstract kill(pid: number, signal?: string): void;
+  abstract isAlive(pid: number): boolean;
+  abstract listProcessesContaining(marker: string): ProcessSnapshot[];
+  abstract getStartTime(pid: number): string | null;
+}
+//#endregion
+//#region lib/engine/connectors/base-connector-config.d.ts
+/**
+ * Fields every connector config carries, regardless of type. The discriminated
+ * union of concrete connector configs no longer lives in core: each connector
+ * type owns its full schema inside its descriptor, and core handles connectors
+ * through this base shape plus the injected registry. `type` is an open string
+ * here on purpose — core does not enumerate the known connector types.
+ */
+declare const baseConnectorConfigSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodString;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type BaseConnectorConfig = z.infer<typeof baseConnectorConfigSchema>;
+//#endregion
+//#region lib/engine/connectors/connector-adapter.d.ts
+/**
+ * A JSON-serializable value. Connector call bodies are sent to external APIs as
+ * JSON, so the body must be representable as JSON — `JsonValue` says exactly
+ * that, replacing a bare `unknown` that let non-serializable values (functions,
+ * symbols, class instances) slip through to `JSON.stringify`.
+ */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+type CallInput = {
+  method: string;
+  path: string; /** JSON request body. Omit for GET-like calls. */
+  body?: JsonValue;
+};
+declare abstract class FunnelConnectorAdapter {
+  /**
+   * Dispatches one Claude → external call. The response is the external API's
+   * raw payload, typed `unknown` because its shape is the provider's concern —
+   * the caller (Claude, via MCP) interprets it.
+   */
+  abstract call(input: CallInput): Promise<unknown>;
+}
+//#endregion
 //#region lib/engine/connectors/connector-listener.d.ts
 type NotifyFn = (content: string, meta?: Record<string, string>) => Promise<void>;
 /**
@@ -32,7 +125,7 @@ declare abstract class FunnelConnectorListener {
   isAlive(): boolean;
 }
 //#endregion
-//#region lib/gateway/diagnostic-log/diagnostic-log.d.ts
+//#region lib/engine/diagnostic-log/diagnostic-log.d.ts
 /**
  * Points in the listener's connection lifecycle. The single source of truth
  * for the value set: the `status` column schema, the `ConnectorConnectionStatus`
@@ -205,4 +298,67 @@ declare abstract class ConnectorDiagnosticLog {
   abstract close(): void;
 }
 //#endregion
-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 };
+//#region lib/engine/connectors/connector-descriptor.d.ts
+/** Boundaries a listener needs, supplied by the registry at build time. */
+type ConnectorListenerDeps = {
+  channelId: string;
+  fs: FunnelFileSystem;
+  process: FunnelProcessRunner;
+  logger?: FunnelLogger;
+  diagnosticLog?: ConnectorDiagnosticLog; /** Resolves the per-connector state directory (`<dir>/channels/<id>/connectors/<id>`). */
+  connectorDir: (channelId: string, connectorId: string) => string;
+};
+/** Boundaries an adapter needs. Adapters are channel-agnostic. */
+type ConnectorAdapterDeps = {
+  fs: FunnelFileSystem;
+  process: FunnelProcessRunner;
+  logger?: FunnelLogger;
+};
+type ConnectorBuildContext = {
+  id: string;
+  now: string;
+};
+type ConnectorUpdateContext = {
+  now: string;
+};
+type ConnectorOperationContext = {
+  generateId: () => string;
+  now: string;
+};
+/**
+ * One named operation a connector type exposes beyond plain CRUD (e.g. schedule
+ * entry add/remove/list). Returns the next config and an arbitrary result; when
+ * the returned config is reference-equal to the input, the channels layer treats
+ * the call as a read and skips persistence.
+ */
+type ConnectorOperation = (props: {
+  config: BaseConnectorConfig;
+  args: unknown;
+  context: ConnectorOperationContext;
+}) => {
+  config: BaseConnectorConfig;
+  result: unknown;
+};
+/**
+ * Everything core needs to handle one connector type, without importing it. A
+ * descriptor accepts/returns `BaseConnectorConfig` at every boundary and parses
+ * to its concrete config internally (via `schema`), so the registry can hold a
+ * homogeneous `ConnectorDescriptor[]` with no variance gymnastics. Type-specific
+ * launch hooks (Slack `onAppCreated`, Schedule `onFired`) are closed over by the
+ * descriptor factory, not threaded through here. Each descriptor parses configs
+ * to its concrete shape internally (it owns its zod schema), so no schema is
+ * exposed here — that also sidesteps the variance trap of a `ZodType<Slack>`
+ * field declared as `ZodType<BaseConnectorConfig>`.
+ */
+type ConnectorDescriptor = {
+  type: string;
+  createListener: (config: BaseConnectorConfig, deps: ConnectorListenerDeps) => FunnelConnectorListener;
+  createAdapter: ((config: BaseConnectorConfig, deps: ConnectorAdapterDeps) => FunnelConnectorAdapter) | null; /** Whether the MCP channel server exposes this type as a callable tool. */
+  toolExposed: boolean;
+  secretTokens: (config: BaseConnectorConfig) => string[];
+  buildConfig: (input: Record<string, unknown>, context: ConnectorBuildContext) => BaseConnectorConfig;
+  applyUpdate: (config: BaseConnectorConfig, fields: Record<string, unknown>, context: ConnectorUpdateContext) => BaseConnectorConfig;
+  operations: Record<string, ConnectorOperation>;
+};
+//#endregion
+export { FunnelConnectorAdapter as A, FunnelLogger as B, StoredRawEvent as C, FunnelConnectorListener as D, connectorRawEventSchema as E, DetachOptions as F, FunnelProcessRunner as I, ProcessSnapshot as L, BaseConnectorConfig as M, baseConnectorConfigSchema as N, NotifyFn as O, AttachOptions as P, RunOptions as R, StoredProcessedEvent as S, connectorProcessedEventSchema as T, ConnectorQuery as _, ConnectorOperation as a, ConnectorRawRecord as b, CONNECTOR_CONNECTION_STATUSES as c, ConnectorConnectionRecord as d, ConnectorConnectionStatus as f, ConnectorProcessedRecord as g, ConnectorProcessedQuery as h, ConnectorListenerDeps as i, JsonValue as j, CallInput as k, ConnectorConnectionEvent as l, ConnectorProcessedEvent as m, ConnectorBuildContext as n, ConnectorOperationContext as o, ConnectorDiagnosticLog as p, ConnectorDescriptor as r, ConnectorUpdateContext as s, ConnectorAdapterDeps as t, ConnectorConnectionQuery as u, ConnectorRawEvent as v, connectorConnectionEventSchema as w, StoredConnectionEvent as x, ConnectorRawQuery as y, RunResult as z };

package/dist/connectors/discord.d.ts

@@ -1,7 +1,26 @@
-import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "../diagnostic-log-Cb3v8P7p.js";
-import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-DGacCppE.js";
-import { n as discordConnectorSchema, r as FunnelHttpClient, t as DiscordConnectorConfig } from "../discord-connector-schema-CQyfDkLD.js";
+import { A as FunnelConnectorAdapter, B as FunnelLogger, D as FunnelConnectorListener, O as NotifyFn, k as CallInput, p as ConnectorDiagnosticLog, r as ConnectorDescriptor } from "../connector-descriptor-6SXJoszo.js";
+import { t as FunnelHttpClient } from "../http-client-oICicjuO.js";
+import { z } from "zod";
 
+//#region lib/engine/connectors/discord-connector-schema.d.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.
+ */
+declare const discordConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"discord">;
+  botToken: z.ZodOptional<z.ZodString>;
+  botTokenEnv: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type DiscordConnectorConfig = z.infer<typeof discordConnectorSchema>;
+//#endregion
 //#region lib/engine/connectors/discord-adapter.d.ts
 type Deps$1 = {
   config: DiscordConnectorConfig; /** Environment used to resolve a `botTokenEnv` reference. Defaults to process.env. */
@@ -15,6 +34,13 @@ declare class FunnelDiscordAdapter extends FunnelConnectorAdapter {
   call(input: CallInput): Promise<unknown>;
 }
 //#endregion
+//#region lib/engine/connectors/discord-connector.d.ts
+/**
+ * Discord connector descriptor. Pass `discordConnector()` to
+ * `new Funnel({ connectors: [...] })` to enable the type.
+ */
+declare const discordConnector: () => ConnectorDescriptor;
+//#endregion
 //#region lib/engine/connectors/discord-event-processor.d.ts
 type DiscordInboundMessage = {
   authorId: string;
@@ -66,4 +92,4 @@ declare class FunnelDiscordListener extends FunnelConnectorListener {
   private recordConnection;
 }
 //#endregion
-export { DiscordConnectorConfig, DiscordInboundMessage, DiscordProcessed, DiscordProcessedEmit, DiscordProcessedSkip, FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnectorSchema };
+export { DiscordConnectorConfig, DiscordInboundMessage, DiscordProcessed, DiscordProcessedEmit, DiscordProcessedSkip, FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnector, discordConnectorSchema };

package/dist/connectors/discord.js

@@ -1,3 +1,3 @@
-import { n as FunnelDiscordEventProcessor, r as FunnelDiscordAdapter, t as FunnelDiscordListener } from "../discord-listener-CKsZGTnH.js";
 import { t as discordConnectorSchema } from "../discord-connector-schema-B_N6IXLz.js";
-export { FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnectorSchema };
+import { i as FunnelDiscordAdapter, n as FunnelDiscordListener, r as FunnelDiscordEventProcessor, t as discordConnector } from "../discord-connector-BL36yvbL.js";
+export { FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnector, discordConnectorSchema };

package/dist/connectors/gh.d.ts

@@ -1,7 +1,5 @@
-import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "../diagnostic-log-Cb3v8P7p.js";
-import { r as FunnelProcessRunner } from "../process-runner-Cx5O_fTf.js";
-import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-DGacCppE.js";
-import { n as ghConnectorSchema, t as GhConnectorConfig } from "../gh-connector-schema-CZzwzvqY.js";
+import { A as FunnelConnectorAdapter, B as FunnelLogger, D as FunnelConnectorListener, I as FunnelProcessRunner, O as NotifyFn, k as CallInput, p as ConnectorDiagnosticLog, r as ConnectorDescriptor } from "../connector-descriptor-6SXJoszo.js";
+import { z } from "zod";
 
 //#region lib/engine/connectors/gh-adapter.d.ts
 type Deps$1 = {
@@ -13,6 +11,24 @@ declare class FunnelGhAdapter extends FunnelConnectorAdapter {
   call(input: CallInput): Promise<unknown>;
 }
 //#endregion
+//#region lib/engine/connectors/gh-connector.d.ts
+/**
+ * GitHub connector descriptor. Pass `ghConnector()` to
+ * `new Funnel({ connectors: [...] })` to enable the type.
+ */
+declare const ghConnector: () => ConnectorDescriptor;
+//#endregion
+//#region lib/engine/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
 //#region lib/engine/connectors/gh-listener.d.ts
 type Deps = {
   config: GhConnectorConfig; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
@@ -43,4 +59,4 @@ declare class FunnelGhListener extends FunnelConnectorListener {
   private recordConnection;
 }
 //#endregion
-export { FunnelGhAdapter, FunnelGhListener, GhConnectorConfig, ghConnectorSchema };
+export { FunnelGhAdapter, FunnelGhListener, GhConnectorConfig, ghConnector, ghConnectorSchema };

package/dist/connectors/gh.js

@@ -1,3 +1,3 @@
-import { t as ghConnectorSchema } from "../gh-connector-schema-DUcZgN2Q.js";
-import { n as FunnelGhAdapter, t as FunnelGhListener } from "../gh-listener-Dsx6AmhH.js";
-export { FunnelGhAdapter, FunnelGhListener, ghConnectorSchema };
+import { t as ghConnectorSchema } from "../gh-connector-schema-Rzwc1c1N.js";
+import { n as FunnelGhListener, r as FunnelGhAdapter, t as ghConnector } from "../gh-connector-DpiixfQZ.js";
+export { FunnelGhAdapter, FunnelGhListener, ghConnector, ghConnectorSchema };