@interactive-inc/claude-funnel 0.59.1 → 0.60.0

package/dist/settings-schema-D1xcOqRu.d.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+
+//#region lib/engine/settings/settings-schema.d.ts
+/**
+ * Routing mode when multiple WS clients are subscribed to the same channel.
+ *
+ * - `fanout` (default): every connected client receives every event. Right when each
+ *   subscriber has its own job (e.g., TUI mirrors, distinct Claude profiles each running
+ *   their own pipeline against the same source).
+ * - `exclusive`: each event is delivered to exactly one connected client, picked
+ *   round-robin per channel. Right when subscribers are interchangeable workers and you
+ *   want each event handled once. Tap=all clients (TUI dashboard) always receive,
+ *   regardless of mode, so they can passively observe.
+ */
+declare const channelDeliveryModeSchema: z.ZodEnum<{
+  fanout: "fanout";
+  exclusive: "exclusive";
+}>;
+type ChannelDeliveryMode = z.infer<typeof channelDeliveryModeSchema>;
+declare const channelConfigSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  delivery: z.ZodDefault<z.ZodEnum<{
+    fanout: "fanout";
+    exclusive: "exclusive";
+  }>>;
+  connectors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>>>;
+}, z.core.$strip>;
+type ChannelConfig = z.infer<typeof channelConfigSchema>;
+declare const profileConfigSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  path: z.ZodString;
+  channelId: z.ZodString;
+  options: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+  resume: z.ZodDefault<z.ZodBoolean>;
+  sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ProfileConfig = z.infer<typeof profileConfigSchema>;
+declare const SETTINGS_VERSION = 1;
+declare const settingsSchema: z.ZodObject<{
+  version: z.ZodDefault<z.ZodLiteral<1>>;
+  channels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    delivery: z.ZodDefault<z.ZodEnum<{
+      fanout: "fanout";
+      exclusive: "exclusive";
+    }>>;
+    connectors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodString;
+      createdAt: z.ZodOptional<z.ZodString>;
+      updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+  }, z.core.$strip>>>;
+  profiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    path: z.ZodString;
+    channelId: z.ZodString;
+    options: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    resume: z.ZodDefault<z.ZodBoolean>;
+    sessionId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Settings = z.infer<typeof settingsSchema>;
+//#endregion
+export { Settings as a, profileConfigSchema as c, SETTINGS_VERSION as i, settingsSchema as l, ChannelDeliveryMode as n, channelConfigSchema as o, ProfileConfig as r, channelDeliveryModeSchema as s, ChannelConfig as t };

package/dist/{gateway-base-url-DxVjjDoW.js → settings-store-CUKSeTXC.js}

@@ -1,12 +1,8 @@
-import { t as ghConnectorSchema } from "./gh-connector-schema-ClPLSYD9.js";
-import { t as NodeFunnelFileSystem } from "./node-file-system-BcrmWN9I.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-DPqrpV7s.js";
-import { t as discordConnectorSchema } from "./discord-connector-schema-B_N6IXLz.js";
-import { n as scheduleConnectorSchema } from "./schedule-connector-schema-B_xO5z5B.js";
-import { t as slackConnectorSchema } from "./slack-connector-schema-C1zEf4TG.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-Blr8pAir.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-CtQ-Ix8_.js";
 import { dirname, join } from "node:path";
-import { z } from "zod";
 import { homedir } from "node:os";
+import { z } from "zod";
 //#region lib/engine/id/node-id-generator.ts
 var NodeFunnelIdGenerator = class extends FunnelIdGenerator {
 	generate() {
@@ -14,16 +10,31 @@ var NodeFunnelIdGenerator = class extends FunnelIdGenerator {
 	}
 };
 //#endregion
-//#region lib/engine/connectors/connector-config-schema.ts
-const connectorConfigSchema = z.discriminatedUnion("type", [
-	slackConnectorSchema,
-	ghConnectorSchema,
-	discordConnectorSchema,
-	scheduleConnectorSchema
-]);
+//#region lib/engine/connectors/base-connector-config.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.
+*/
+const baseConnectorConfigSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.string(),
+	createdAt: z.string().datetime().optional(),
+	updatedAt: z.string().datetime().optional()
+});
 //#endregion
 //#region lib/engine/settings/settings-schema.ts
 /**
+* Connectors are stored loosely here: settings validates only the common base
+* fields and preserves every type-specific key verbatim (`.passthrough()`).
+* Core does not enumerate connector types, so strict per-type validation happens
+* at the registry/descriptor layer (CRUD time), not on every settings read.
+*/
+const storedConnectorSchema = baseConnectorConfigSchema.passthrough();
+/**
 * Routing mode when multiple WS clients are subscribed to the same channel.
 *
 * - `fanout` (default): every connected client receives every event. Right when each
@@ -39,7 +50,7 @@ const channelConfigSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	delivery: channelDeliveryModeSchema.default("fanout"),
-	connectors: z.array(connectorConfigSchema).default([])
+	connectors: z.array(storedConnectorSchema).default([])
 });
 const profileConfigSchema = z.object({
 	/** Stable identity (uuid). The primary key everything internal resolves to;
@@ -183,17 +194,4 @@ var FunnelSettingsStore = class extends FunnelSettingsReader {
 	}
 };
 //#endregion
-//#region lib/gateway/gateway-base-url.ts
-/**
-* The HTTP base URL of a gateway daemon on the loopback interface. The daemon
-* always binds 127.0.0.1 for its management API (only the WS `/ws` endpoint is
-* ever exposed off-box), so every in-process HTTP client — publisher, listeners
-* client, MCP channel server — talks to it here. Centralizing the construction
-* keeps the host/port shape in one place instead of re-spelling
-* `http://127.0.0.1:${port}` at each call site.
-*/
-function gatewayLoopbackUrl(port) {
-	return `http://127.0.0.1:${port}`;
-}
-//#endregion
-export { SETTINGS_PATH as a, SETTINGS_VERSION as c, profileConfigSchema as d, settingsSchema as f, FunnelSettingsStore as i, channelConfigSchema as l, NodeFunnelIdGenerator as m, DEFAULT_GATEWAY_PORT as n, resolveFunnelDir as o, connectorConfigSchema as p, FUNNEL_DIR as r, resolveFunnelPort as s, gatewayLoopbackUrl as t, channelDeliveryModeSchema as u };
+export { resolveFunnelDir as a, channelConfigSchema as c, settingsSchema as d, baseConnectorConfigSchema as f, SETTINGS_PATH as i, channelDeliveryModeSchema as l, FUNNEL_DIR as n, resolveFunnelPort as o, NodeFunnelIdGenerator as p, FunnelSettingsStore as r, SETTINGS_VERSION as s, DEFAULT_GATEWAY_PORT as t, profileConfigSchema as u };

package/dist/{slack-listener-C4wlZaOq.js → slack-connector-DQIFPdBF.js}

@@ -1,6 +1,8 @@
-import { t as FunnelConnectorAdapter } from "./connector-adapter-qwXLjQId.js";
-import { t as resolveConnectorToken } from "./resolve-connector-token-CczqG_Ig.js";
-import { t as FunnelConnectorListener } from "./connector-listener-CpHBecCj.js";
+import { t as slackConnectorSchema } from "./slack-connector-schema-C1zEf4TG.js";
+import { t as FunnelConnectorAdapter } from "./connector-adapter-DU9Rvyec.js";
+import { t as FunnelConnectorListener } from "./connector-listener-DR3aKOuK.js";
+import { t as errorMessageOf } from "./error-message-of-Byi4y0Uf.js";
+import { n as resolveConnectorToken, t as slotFields } from "./slot-fields-CMoRpwuy.js";
 import { z } from "zod";
 import { WebClient } from "@slack/web-api";
 import { App, LogLevel, SocketModeReceiver } from "@slack/bolt";
@@ -316,7 +318,7 @@ var FunnelSlackListener = class extends FunnelConnectorListener {
 		try {
 			authResult = await app.client.auth.test({ token: botToken });
 		} catch (error) {
-			this.recordConnection("auth-failed", messageOf(error));
+			this.recordConnection("auth-failed", errorMessageOf(error));
 			throw error;
 		}
 		const processor = new FunnelSlackEventProcessor({
@@ -361,7 +363,7 @@ var FunnelSlackListener = class extends FunnelConnectorListener {
 			} catch {}
 		});
 		app.error(async (error) => {
-			const message = messageOf(error);
+			const message = errorMessageOf(error);
 			this.recordConnection("error", message);
 			this.logger?.error("Slack error", { error: message });
 		});
@@ -369,7 +371,7 @@ var FunnelSlackListener = class extends FunnelConnectorListener {
 		try {
 			await app.start();
 		} catch (error) {
-			this.recordConnection("error", messageOf(error));
+			this.recordConnection("error", errorMessageOf(error));
 			throw error;
 		}
 		this.app = app;
@@ -382,8 +384,8 @@ var FunnelSlackListener = class extends FunnelConnectorListener {
 			await this.app.stop();
 			this.recordConnection("disconnected", "");
 		} catch (error) {
-			this.recordConnection("error", messageOf(error));
-			this.logger?.error("Slack stop error", { error: messageOf(error) });
+			this.recordConnection("error", errorMessageOf(error));
+			this.logger?.error("Slack stop error", { error: errorMessageOf(error) });
 		} finally {
 			this.app = null;
 			this.connected = false;
@@ -422,8 +424,61 @@ var FunnelSlackListener = class extends FunnelConnectorListener {
 		});
 	}
 };
-const messageOf = (error) => {
-	return error instanceof Error ? error.message : String(error);
-};
 //#endregion
-export { FunnelSlackEventProcessor as n, FunnelSlackAdapter as r, FunnelSlackListener as t };
+//#region lib/engine/connectors/slack-connector.ts
+/**
+* Slack connector descriptor. Pass `slackConnector()` to
+* `new Funnel({ connectors: [...] })` to enable the type. Host launch hooks are
+* closed over here, so they need no Funnel-level option plumbing.
+*/
+const slackConnector = (options = {}) => ({
+	type: "slack",
+	toolExposed: true,
+	createListener(config, deps) {
+		return new FunnelSlackListener({
+			config: slackConnectorSchema.parse(config),
+			channelId: deps.channelId,
+			logger: deps.logger,
+			diagnosticLog: deps.diagnosticLog,
+			onAppCreated: options.onAppCreated,
+			preprocessEvent: options.preprocessEvent
+		});
+	},
+	createAdapter(config) {
+		return new FunnelSlackAdapter({ config: slackConnectorSchema.parse(config) });
+	},
+	secretTokens(config) {
+		const parsed = slackConnectorSchema.parse(config);
+		return [parsed.botToken, parsed.appToken].filter((token) => token !== void 0);
+	},
+	buildConfig(input, context) {
+		return slackConnectorSchema.parse({
+			id: context.id,
+			type: "slack",
+			name: input.name,
+			...typeof input.botToken === "string" ? { botToken: input.botToken } : {},
+			...typeof input.appToken === "string" ? { appToken: input.appToken } : {},
+			...typeof input.botTokenEnv === "string" ? { botTokenEnv: input.botTokenEnv } : {},
+			...typeof input.appTokenEnv === "string" ? { appTokenEnv: input.appTokenEnv } : {},
+			minify: typeof input.minify === "boolean" ? input.minify : true,
+			createdAt: context.now,
+			updatedAt: context.now
+		});
+	},
+	applyUpdate(config, fields, context) {
+		const current = slackConnectorSchema.parse(config);
+		return slackConnectorSchema.parse({
+			id: current.id,
+			name: current.name,
+			type: "slack",
+			minify: current.minify,
+			createdAt: current.createdAt,
+			updatedAt: context.now,
+			...slotFields("botToken", "botTokenEnv", fields, current),
+			...slotFields("appToken", "appTokenEnv", fields, current)
+		});
+	},
+	operations: {}
+});
+//#endregion
+export { FunnelSlackAdapter as i, FunnelSlackListener as n, FunnelSlackEventProcessor as r, slackConnector as t };

package/dist/slot-fields-CMoRpwuy.js

@@ -0,0 +1,45 @@
+//#region lib/engine/connectors/resolve-connector-token.ts
+/**
+* Resolves a connector token from either a literal value or the name of an env
+* var. A connector config carries one or the other per slot (see
+* slack-connector-schema): literals are inlined into settings.json, references
+* keep the secret in `process.env` and out of settings.json.
+*
+* Errors loudly when neither yields a value — a misconfigured connector should
+* fail at listener start, not connect with an empty token and silently never
+* receive events.
+*/
+const resolveConnectorToken = (props) => {
+	if (props.literal !== void 0 && props.literal !== "") return props.literal;
+	if (props.envVar !== void 0 && props.envVar !== "") {
+		const fromEnv = props.env[props.envVar];
+		if (fromEnv !== void 0 && fromEnv !== "") return fromEnv;
+		throw new Error(`${props.label} references env var "${props.envVar}" but it is not set in the environment`);
+	}
+	throw new Error(`${props.label} has neither a literal token nor an env var reference`);
+};
+//#endregion
+//#region lib/engine/connectors/slot-fields.ts
+/**
+* Resolves one token slot (e.g. botToken/botTokenEnv) for a connector update.
+* The literal and the env-ref form are mutually exclusive: if `fields` supplies
+* either, that form wins and the other key is omitted entirely; if it supplies
+* neither, the connector's current slot is carried over unchanged. Returns a
+* partial object spread into the rebuilt connector, so an omitted key is truly
+* absent rather than set to undefined — switching a slot from literal to ref
+* drops the stale literal instead of leaving both behind.
+*/
+const slotFields = (literalKey, envKey, fields, current) => {
+	const literal = fields[literalKey];
+	if (typeof literal === "string") return { [literalKey]: literal };
+	const envVar = fields[envKey];
+	if (typeof envVar === "string") return { [envKey]: envVar };
+	const result = {};
+	const currentLiteral = current[literalKey];
+	const currentEnv = current[envKey];
+	if (typeof currentLiteral === "string") result[literalKey] = currentLiteral;
+	if (typeof currentEnv === "string") result[envKey] = currentEnv;
+	return result;
+};
+//#endregion
+export { resolveConnectorToken as n, slotFields as t };

package/dist/{yaml-render-cZu6CxkE.js → yaml-render-qW34NlYz.js}

@@ -1,6 +1,6 @@
-import { n as NodeFunnelProcessRunner } from "./gh-connector-schema-ClPLSYD9.js";
-import { t as NodeFunnelFileSystem } from "./node-file-system-BcrmWN9I.js";
-import { m as NodeFunnelIdGenerator, r as FUNNEL_DIR, s as resolveFunnelPort } from "./gateway-base-url-DxVjjDoW.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-Blr8pAir.js";
+import { t as NodeFunnelProcessRunner } from "./node-process-runner-DxTvycoK.js";
+import { n as FUNNEL_DIR, o as resolveFunnelPort, p as NodeFunnelIdGenerator } from "./settings-store-CUKSeTXC.js";
 import { join } from "node:path";
 import { stringify } from "yaml";
 //#region lib/engine/claude/claude.ts
@@ -280,7 +280,7 @@ var FunnelMcp = class {
 	}
 };
 //#endregion
-//#region lib/cli/yaml-render.ts
+//#region lib/engine/yaml/yaml-render.ts
 /**
 * Render any value as a valid YAML document for CLI output.
 *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interactive-inc/claude-funnel",
-  "version": "0.59.1",
+  "version": "0.60.0",
   "description": "Hub CLI that routes external events (Slack / GitHub / Discord) to Claude Code agents through subscription channels over MCP.",
   "keywords": [
     "bun",

package/dist/connector-adapter-DGacCppE.d.ts

@@ -1,25 +0,0 @@
-//#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
-export { FunnelConnectorAdapter as n, JsonValue as r, CallInput as t };

package/dist/discord-connector-schema-CQyfDkLD.d.ts

@@ -1,39 +0,0 @@
-import { z } from "zod";
-
-//#region lib/engine/http/http-client.d.ts
-type HttpRequest = {
-  method: string;
-  url: string;
-  headers?: Record<string, string>;
-  body?: string;
-};
-type HttpResponse = {
-  status: number;
-  ok: boolean;
-  text(): Promise<string>;
-  json(): Promise<unknown>;
-};
-declare abstract class FunnelHttpClient {
-  abstract fetch(request: HttpRequest): Promise<HttpResponse>;
-}
-//#endregion
-//#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
-export { HttpResponse as a, HttpRequest as i, discordConnectorSchema as n, FunnelHttpClient as r, DiscordConnectorConfig as t };

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

@@ -1,14 +0,0 @@
-import { z } from "zod";
-
-//#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
-export { ghConnectorSchema as n, GhConnectorConfig as t };