@interactive-inc/claude-funnel 0.49.0 → 0.51.0

package/dist/settings-reader-BSU6JyvM.d.ts

@@ -0,0 +1,167 @@
+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.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"slack">;
+    botToken: z.ZodOptional<z.ZodString>;
+    appToken: z.ZodOptional<z.ZodString>;
+    botTokenEnv: z.ZodOptional<z.ZodString>;
+    appTokenEnv: z.ZodOptional<z.ZodString>;
+    minify: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, 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>, 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>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"schedule">;
+    entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      cron: z.ZodString;
+      prompt: z.ZodString;
+      enabled: z.ZodDefault<z.ZodBoolean>;
+      catchupPolicy: z.ZodDefault<z.ZodEnum<{
+        latest: "latest";
+        all: "all";
+        skip: "skip";
+      }>>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>], "type">>>;
+}, 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.ZodDiscriminatedUnion<[z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodLiteral<"slack">;
+      botToken: z.ZodOptional<z.ZodString>;
+      appToken: z.ZodOptional<z.ZodString>;
+      botTokenEnv: z.ZodOptional<z.ZodString>;
+      appTokenEnv: z.ZodOptional<z.ZodString>;
+      minify: z.ZodDefault<z.ZodBoolean>;
+      createdAt: z.ZodOptional<z.ZodString>;
+      updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, 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>, 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>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodLiteral<"schedule">;
+      entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        cron: z.ZodString;
+        prompt: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        catchupPolicy: z.ZodDefault<z.ZodEnum<{
+          latest: "latest";
+          all: "all";
+          skip: "skip";
+        }>>;
+      }, z.core.$strip>>>;
+      createdAt: z.ZodOptional<z.ZodString>;
+      updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>>;
+  }, 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
+//#region lib/engine/id/id-generator.d.ts
+/**
+ * ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
+ * MemoryFunnelIdGenerator emits `<prefix>-1, <prefix>-2, ...` for deterministic tests.
+ */
+declare abstract class FunnelIdGenerator {
+  abstract generate(): string;
+}
+//#endregion
+//#region lib/engine/settings/settings-reader.d.ts
+declare abstract class FunnelSettingsReader {
+  abstract read(): Settings;
+  abstract write(settings: Settings): void;
+}
+//#endregion
+export { ProfileConfig as a, channelConfigSchema as c, settingsSchema as d, ChannelDeliveryMode as i, channelDeliveryModeSchema as l, FunnelIdGenerator as n, SETTINGS_VERSION as o, ChannelConfig as r, Settings as s, FunnelSettingsReader as t, profileConfigSchema as u };

package/dist/settings-reader-DPqrpV7s.js

@@ -0,0 +1,11 @@
+//#region lib/engine/id/id-generator.ts
+/**
+* ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
+* MemoryFunnelIdGenerator emits `<prefix>-1, <prefix>-2, ...` for deterministic tests.
+*/
+var FunnelIdGenerator = class {};
+//#endregion
+//#region lib/engine/settings/settings-reader.ts
+var FunnelSettingsReader = class {};
+//#endregion
+export { FunnelIdGenerator as n, FunnelSettingsReader as t };

package/dist/settings-store-D2XSXTyt.js

@@ -0,0 +1,186 @@
+import { t as ghConnectorSchema } from "./gh-connector-schema-o3Q1-ojL.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-CBDyGdOI.js";
+import { n as scheduleConnectorSchema } from "./schedule-connector-schema-iCI61gzU.js";
+import { t as slackConnectorSchema } from "./slack-connector-schema-BCNWluHM.js";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { homedir } from "node:os";
+//#region lib/engine/id/node-id-generator.ts
+var NodeFunnelIdGenerator = class extends FunnelIdGenerator {
+	generate() {
+		return crypto.randomUUID();
+	}
+};
+//#endregion
+//#region lib/connectors/connector-config-schema.ts
+const connectorConfigSchema = z.discriminatedUnion("type", [
+	slackConnectorSchema,
+	ghConnectorSchema,
+	discordConnectorSchema,
+	scheduleConnectorSchema
+]);
+//#endregion
+//#region lib/engine/settings/settings-schema.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.
+*/
+const channelDeliveryModeSchema = z.enum(["fanout", "exclusive"]);
+const channelConfigSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	delivery: channelDeliveryModeSchema.default("fanout"),
+	connectors: z.array(connectorConfigSchema).default([])
+});
+const profileConfigSchema = z.object({
+	/** Stable identity (uuid). The primary key everything internal resolves to;
+	*  survives renames. CLI surfaces still address profiles by `name`. */
+	id: z.string(),
+	/** Human-facing label used only at the CLI/TUI surface (`--profile <name>`).
+	*  Renameable; never used as a storage key. */
+	name: z.string(),
+	path: z.string(),
+	channelId: z.string(),
+	/** Args prepended to the claude argv on every launch through this profile. */
+	options: z.array(z.string()).default([]),
+	/** Env vars layered under the launched claude process. process.env wins on collision. */
+	env: z.record(z.string(), z.string()).default({}),
+	/**
+	* When true (the default), funnel resumes this profile's previous claude
+	* session via `--session-id`/`--resume`. The id lives in `sessionId` below,
+	* scoped to this profile so an unrelated session in the same repo can't bleed
+	* in. Set to false for profiles that should always start fresh.
+	*/
+	resume: z.boolean().default(true),
+	/**
+	* Execution state, not config: the claude session id this profile last
+	* launched. Written by the launcher, read on the next resume. Absent until
+	* the first launch; kept inside the profile (rather than a separate file) so
+	* the session belongs to the profile by identity and the transport layer
+	* (channels) never has to know profiles exist.
+	*/
+	sessionId: z.string().optional()
+});
+const SETTINGS_VERSION = 1;
+const settingsSchema = z.object({
+	/** Schema version. New files always write the current version; older files without one are read as v1. */
+	version: z.literal(1).default(1),
+	channels: z.array(channelConfigSchema).default([]),
+	profiles: z.array(profileConfigSchema).default([])
+});
+//#endregion
+//#region lib/engine/settings/settings-store.ts
+/**
+* Resolves the funnel home dir. Defaults to `~/.funnel`, overridable via
+* `FUNNEL_DIR` so a funnel.json-scoped launch can point everything (settings,
+* gateway pid/token, claude pids) at a repo-local `<repo>/.funnel` and never
+* touch the global home. Read at call time, not module load, so a daemon
+* spawned with the env set resolves the override.
+*/
+function resolveFunnelDir() {
+	const override = process.env.FUNNEL_DIR;
+	if (override && override.length > 0) return override;
+	return join(homedir(), ".funnel");
+}
+const DEFAULT_GATEWAY_PORT = 9742;
+/**
+* Resolves the gateway port. Defaults to 9742 — the port a programmatically
+* hosted gateway (`new Funnel().gatewayServer()`) uses. The `funnel` CLI entry
+* sets `FUNNEL_PORT` to a distinct default so a CLI launch never collides with
+* an embedding app's gateway on 9742. Read at call time so a daemon spawned
+* with the env set resolves the override.
+*/
+function resolveFunnelPort() {
+	return Number(process.env.FUNNEL_PORT) || 9742;
+}
+const FUNNEL_DIR = join(homedir(), ".funnel");
+const SETTINGS_PATH = join(FUNNEL_DIR, "settings.json");
+const defaultFs = new NodeFunnelFileSystem();
+const defaultIdGenerator = new NodeFunnelIdGenerator();
+var FunnelSettingsStore = class extends FunnelSettingsReader {
+	path;
+	fs;
+	idGenerator;
+	constructor(deps = {}) {
+		super();
+		this.path = deps.path ?? SETTINGS_PATH;
+		this.fs = deps.fs ?? defaultFs;
+		this.idGenerator = deps.idGenerator ?? defaultIdGenerator;
+		Object.freeze(this);
+	}
+	read() {
+		if (!this.fs.existsSync(this.path)) return {
+			version: 1,
+			channels: [],
+			profiles: []
+		};
+		const content = this.fs.readFileSync(this.path);
+		const parsed = JSON.parse(content);
+		if (this.looksLikeLegacy(parsed)) throw new Error(`legacy settings.json detected at ${this.path}. The schema changed (channel.connectors are now nested objects with ids; profile fields renamed). Migration is intentionally not provided. Back up and remove the old file:\n  mv ${this.path} ${this.path}.bak`);
+		if (parsed && typeof parsed === "object" && "version" in parsed && parsed.version !== 1) throw new Error(`unsupported settings.json version (${this.path}): expected 1, got ${String(parsed.version)}`);
+		const minted = this.backfillProfileIds(parsed);
+		const result = settingsSchema.safeParse(parsed);
+		if (!result.success) throw new Error(`invalid settings.json (${this.path}): ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`);
+		if (minted) this.write(result.data);
+		return result.data;
+	}
+	looksLikeLegacy(parsed) {
+		if (!parsed || typeof parsed !== "object") return false;
+		const obj = parsed;
+		if (Array.isArray(obj.channels)) for (const channel of obj.channels) {
+			if (!channel || typeof channel !== "object") continue;
+			const ch = channel;
+			if (Array.isArray(ch.connectors) && ch.connectors.some((x) => typeof x === "string")) return true;
+			if (!("id" in ch) && "name" in ch) return true;
+		}
+		if (Array.isArray(obj.connectors)) return true;
+		if (Array.isArray(obj.repositories)) return true;
+		if (Array.isArray(obj.profiles)) for (const profile of obj.profiles) {
+			if (!profile || typeof profile !== "object") continue;
+			const p = profile;
+			if ("repository" in p || "envFiles" in p || "channel" in p && !("channelId" in p)) return true;
+		}
+		return false;
+	}
+	/**
+	* Non-destructive migration for profiles written before `id` existed. Mints a
+	* uuid for each profile lacking one and returns whether anything was minted, so
+	* `read` can persist it immediately — a profile id must be STABLE across reads,
+	* otherwise `setSessionId` (a second read) sees a different id and can't match
+	* the one the launch used. Mutates `parsed` in place (freshly JSON-parsed).
+	*/
+	backfillProfileIds(parsed) {
+		if (!parsed || typeof parsed !== "object") return false;
+		const obj = parsed;
+		if (!Array.isArray(obj.profiles)) return false;
+		let minted = false;
+		for (const profile of obj.profiles) {
+			if (!profile || typeof profile !== "object") continue;
+			const p = profile;
+			if (typeof p.id !== "string") {
+				p.id = this.idGenerator.generate();
+				minted = true;
+			}
+		}
+		return minted;
+	}
+	write(settings) {
+		this.fs.mkdirSync(dirname(this.path), { recursive: true });
+		const versioned = {
+			...settings,
+			version: 1
+		};
+		this.fs.writeSecretFileSync(this.path, `${JSON.stringify(versioned, null, 2)}\n`);
+	}
+};
+//#endregion
+export { resolveFunnelDir as a, channelConfigSchema as c, settingsSchema as d, connectorConfigSchema 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-connector-schema-BCNWluHM.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+//#region lib/connectors/slack-connector-schema.ts
+/**
+* A slack connector resolves its tokens one of two ways, set at sync time:
+*
+*   - literal: `botToken` / `appToken` hold the real `xoxb-`/`xapp-` secret
+*     (set by a `fnl channels` command or a TTY prompt at launch).
+*   - by reference: `botTokenEnv` / `appTokenEnv` hold the *name* of an env var.
+*     The secret never lands in settings.json; the listener resolves it from
+*     `process.env` at start. This form is only set through the engine API
+*     (`new Funnel(...)`) — funnel.json and the `fnl` CLI produce literals.
+*
+* Both are optional at the schema level (a discriminated-union member can't
+* carry a cross-field refine); the listener requires exactly one resolved
+* token per slot and errors loudly otherwise.
+*/
+const slackConnectorSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.literal("slack"),
+	botToken: z.string().startsWith("xoxb-").optional(),
+	appToken: z.string().startsWith("xapp-").optional(),
+	/** Name of the env var holding the bot token, resolved at listener start. */
+	botTokenEnv: z.string().optional(),
+	/** Name of the env var holding the app token, resolved at listener start. */
+	appTokenEnv: z.string().optional(),
+	minify: z.boolean().default(true),
+	createdAt: z.string().datetime().optional(),
+	updatedAt: z.string().datetime().optional()
+});
+//#endregion
+export { slackConnectorSchema as t };

package/dist/{slack-listener-9UdAn_ui.d.ts → slack-listener-Bv5xI9gC.d.ts}

@@ -1,36 +1,7 @@
-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 { z } from "zod";
 import { App } from "@slack/bolt";
 
-//#region lib/connectors/slack-connector-schema.d.ts
-/**
- * A slack connector resolves its tokens one of two ways, set at sync time:
- *
- *   - literal: `botToken` / `appToken` hold the real `xoxb-`/`xapp-` secret
- *     (set by a `fnl channels` command or a TTY prompt at launch).
- *   - by reference: `botTokenEnv` / `appTokenEnv` hold the *name* of an env var.
- *     The secret never lands in settings.json; the listener resolves it from
- *     `process.env` at start. This form is only set through the engine API
- *     (`new Funnel(...)`) — funnel.json and the `fnl` CLI produce literals.
- *
- * Both are optional at the schema level (a discriminated-union member can't
- * carry a cross-field refine); the listener requires exactly one resolved
- * token per slot and errors loudly otherwise.
- */
-declare const slackConnectorSchema: z.ZodObject<{
-  id: z.ZodString;
-  name: z.ZodString;
-  type: z.ZodLiteral<"slack">;
-  botToken: z.ZodOptional<z.ZodString>;
-  appToken: z.ZodOptional<z.ZodString>;
-  botTokenEnv: z.ZodOptional<z.ZodString>;
-  appTokenEnv: z.ZodOptional<z.ZodString>;
-  minify: z.ZodDefault<z.ZodBoolean>;
-  createdAt: z.ZodOptional<z.ZodString>;
-  updatedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>;
-//#endregion
 //#region lib/connectors/slack-event-processor.d.ts
 type SlackRawEvent = Record<string, unknown>;
 /**
@@ -70,6 +41,35 @@ declare class FunnelSlackEventProcessor {
   process(event: SlackRawEvent): SlackProcessed;
 }
 //#endregion
+//#region lib/connectors/slack-connector-schema.d.ts
+/**
+ * A slack connector resolves its tokens one of two ways, set at sync time:
+ *
+ *   - literal: `botToken` / `appToken` hold the real `xoxb-`/`xapp-` secret
+ *     (set by a `fnl channels` command or a TTY prompt at launch).
+ *   - by reference: `botTokenEnv` / `appTokenEnv` hold the *name* of an env var.
+ *     The secret never lands in settings.json; the listener resolves it from
+ *     `process.env` at start. This form is only set through the engine API
+ *     (`new Funnel(...)`) — funnel.json and the `fnl` CLI produce literals.
+ *
+ * Both are optional at the schema level (a discriminated-union member can't
+ * carry a cross-field refine); the listener requires exactly one resolved
+ * token per slot and errors loudly otherwise.
+ */
+declare const slackConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"slack">;
+  botToken: z.ZodOptional<z.ZodString>;
+  appToken: z.ZodOptional<z.ZodString>;
+  botTokenEnv: z.ZodOptional<z.ZodString>;
+  appTokenEnv: z.ZodOptional<z.ZodString>;
+  minify: z.ZodDefault<z.ZodBoolean>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>;
+//#endregion
 //#region lib/connectors/slack-listener.d.ts
 type SlackOnAppCreated = (app: App) => void | Promise<void>;
 type SlackPreprocessEvent = (event: SlackRawEvent) => SlackRawEvent | null;
@@ -108,4 +108,4 @@ declare class FunnelSlackListener extends FunnelConnectorListener {
   private recordConnection;
 }
 //#endregion
-export { SlackProcessed as a, SlackRawEvent as c, slackConnectorSchema as d, FunnelSlackEventProcessor as i, SlackSkipReason as l, SlackOnAppCreated as n, SlackProcessedEmit as o, SlackPreprocessEvent as r, SlackProcessedSkip as s, FunnelSlackListener as t, SlackConnectorConfig as u };
+export { slackConnectorSchema as a, SlackProcessedEmit as c, SlackSkipReason as d, SlackConnectorConfig as i, SlackProcessedSkip as l, SlackOnAppCreated as n, FunnelSlackEventProcessor as o, SlackPreprocessEvent as r, SlackProcessed as s, FunnelSlackListener as t, SlackRawEvent as u };

package/dist/{slack-connector-schema-DDbSGPZn.js → slack-listener-ClQuHhEF.js}

@@ -1,6 +1,6 @@
 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 { z } from "zod";
 import { WebClient } from "@slack/web-api";
 import { App, LogLevel } from "@slack/bolt";
@@ -364,34 +364,4 @@ const messageOf = (error) => {
 	return error instanceof Error ? error.message : String(error);
 };
 //#endregion
-//#region lib/connectors/slack-connector-schema.ts
-/**
-* A slack connector resolves its tokens one of two ways, set at sync time:
-*
-*   - literal: `botToken` / `appToken` hold the real `xoxb-`/`xapp-` secret
-*     (set by a `fnl channels` command or a TTY prompt at launch).
-*   - by reference: `botTokenEnv` / `appTokenEnv` hold the *name* of an env var.
-*     The secret never lands in settings.json; the listener resolves it from
-*     `process.env` at start. This form is only set through the engine API
-*     (`new Funnel(...)`) — funnel.json and the `fnl` CLI produce literals.
-*
-* Both are optional at the schema level (a discriminated-union member can't
-* carry a cross-field refine); the listener requires exactly one resolved
-* token per slot and errors loudly otherwise.
-*/
-const slackConnectorSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	type: z.literal("slack"),
-	botToken: z.string().startsWith("xoxb-").optional(),
-	appToken: z.string().startsWith("xapp-").optional(),
-	/** Name of the env var holding the bot token, resolved at listener start. */
-	botTokenEnv: z.string().optional(),
-	/** Name of the env var holding the app token, resolved at listener start. */
-	appTokenEnv: z.string().optional(),
-	minify: z.boolean().default(true),
-	createdAt: z.string().datetime().optional(),
-	updatedAt: z.string().datetime().optional()
-});
-//#endregion
-export { FunnelSlackAdapter as i, FunnelSlackListener as n, FunnelSlackEventProcessor as r, slackConnectorSchema as t };
+export { FunnelSlackEventProcessor as n, FunnelSlackAdapter as r, FunnelSlackListener as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interactive-inc/claude-funnel",
-  "version": "0.49.0",
+  "version": "0.51.0",
   "description": "Hub CLI that routes external events (Slack / GitHub / Discord) to Claude Code agents through subscription channels over MCP.",
   "keywords": [
     "bun",
@@ -42,6 +42,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./claude": {
+      "types": "./dist/claude.d.ts",
+      "import": "./dist/claude.js",
+      "default": "./dist/claude.js"
+    },
     "./gateway": {
       "types": "./dist/gateway.d.ts",
       "import": "./dist/gateway.js",