@interactive-inc/claude-funnel 0.60.1 → 0.64.0

package/dist/discord-connector-DIFkYBbi.js

@@ -0,0 +1,250 @@
+import { t as NodeFunnelHttpClient } from "./node-http-client-u00atiKx.js";
+import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
+import { t as discordConnectorSchema } from "./discord-connector-schema-B4YpWpR3.js";
+import { t as FunnelConnectorAdapter } from "./connector-adapter-Dvs8N7ew.js";
+import { t as resolveConnectorToken } from "./resolve-connector-token-DxDG9mhf.js";
+import { i as resolveFlumeDeps, n as FunnelFlumeSourceListener, r as flumeLogHandler, t as slotFields } from "./slot-fields-D-pvMgTK.js";
+import { FlumeDiscordGatewayIntents, FlumeDiscordSource } from "@interactive-inc/flume/discord";
+//#region lib/engine/connectors/discord-adapter.ts
+const DISCORD_API_BASE = "https://discord.com/api/v10";
+const defaultHttp = new NodeFunnelHttpClient();
+var FunnelDiscordAdapter = class extends FunnelConnectorAdapter {
+	token;
+	http;
+	constructor(deps) {
+		super();
+		this.token = resolveConnectorToken({
+			literal: deps.config.botToken,
+			envVar: deps.config.botTokenEnv,
+			env: deps.env ?? process.env,
+			label: `${deps.config.name}.botToken`
+		});
+		this.http = deps.http ?? defaultHttp;
+		Object.freeze(this);
+	}
+	async call(input) {
+		const method = (input.method || "GET").toUpperCase();
+		const path = input.path.startsWith("/") ? input.path : `/${input.path}`;
+		const body = input.body;
+		const hasBody = body !== null && typeof body === "object" && method !== "GET" && Object.keys(body).length > 0;
+		const res = await this.http.fetch({
+			method,
+			url: `${DISCORD_API_BASE}${path}`,
+			headers: {
+				Authorization: `Bot ${this.token}`,
+				"Content-Type": "application/json"
+			},
+			body: hasBody ? JSON.stringify(input.body) : void 0
+		});
+		if (!res.ok) throw new Error(`Discord API failed (${res.status}): ${await res.text()}`);
+		if (res.status === 204) return null;
+		return await res.json();
+	}
+};
+//#endregion
+//#region lib/engine/connectors/discord-event-processor.ts
+var FunnelDiscordEventProcessor = class {
+	ownUserId;
+	constructor(props) {
+		this.ownUserId = props.ownUserId;
+	}
+	process(message) {
+		if (message.authorIsBot) return { skip: true };
+		const mentioned = this.ownUserId ? message.mentionedUserIds.includes(this.ownUserId) : false;
+		return {
+			skip: false,
+			content: JSON.stringify(message.raw),
+			meta: {
+				event_type: "discord",
+				channel_id: message.channelId,
+				user_id: message.authorId,
+				mentioned: String(mentioned),
+				guild_id: message.guildId ?? ""
+			}
+		};
+	}
+};
+//#endregion
+//#region lib/engine/connectors/discord-flume-listener.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const readString = (record, key) => {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
+};
+/**
+* Discord listener backed by `@interactive-inc/flume`'s `FlumeDiscordSource`
+* (raw Gateway WebSocket + Zod). The processor layer
+* (`FunnelDiscordEventProcessor`) is the application layer — self-skip,
+* mention detection, meta shaping. Self-detection requires the bot's own
+* user id, which Discord does not surface until READY; we read it from the
+* READY payload on the first dispatch and build the processor then. Events
+* seen before READY are impossible by protocol, so no event is lost.
+*/
+var FunnelFlumeDiscordListener = class extends FunnelFlumeSourceListener {
+	config;
+	env;
+	flumeDeps;
+	signal;
+	processor = null;
+	constructor(deps) {
+		super({
+			type: "discord",
+			connectorId: deps.config.id,
+			channelId: deps.channelId ?? null,
+			logger: deps.logger,
+			diagnosticLog: deps.diagnosticLog
+		});
+		this.config = deps.config;
+		this.env = deps.env ?? process.env;
+		this.flumeDeps = deps.flumeDeps ?? {};
+		this.signal = deps.signal;
+	}
+	async start(notify) {
+		this.diagnostics.recordConnection("started", "");
+		let token;
+		try {
+			token = resolveConnectorToken({
+				literal: this.config.botToken,
+				envVar: this.config.botTokenEnv,
+				env: this.env,
+				label: `${this.config.name}.botToken`
+			});
+		} catch (error) {
+			this.diagnostics.recordConnection("auth-failed", errorMessageOf(error));
+			throw error;
+		}
+		const source = new FlumeDiscordSource({
+			token,
+			intents: FlumeDiscordGatewayIntents.Guilds | FlumeDiscordGatewayIntents.GuildMessages | FlumeDiscordGatewayIntents.MessageContent | FlumeDiscordGatewayIntents.DirectMessages
+		});
+		await this.runStart({
+			source,
+			onLog: flumeLogHandler(this.logger),
+			deps: resolveFlumeDeps(this.flumeDeps),
+			signal: this.signal,
+			onEvent: (event) => {
+				if (event.source !== "discord") return Promise.resolve();
+				return this.handleEvent(event, notify);
+			}
+		});
+	}
+	onStop() {
+		this.processor = null;
+	}
+	async handleEvent(event, notify) {
+		if (event.type === "READY") {
+			this.adoptReady(event.data);
+			return;
+		}
+		if (!this.processor) {
+			const skipId = crypto.randomUUID();
+			this.diagnostics.recordRaw(skipId, JSON.stringify(event.data));
+			this.diagnostics.recordProcessed(skipId, "skip:pre-ready", "");
+			return;
+		}
+		const data = event.data;
+		const author = isRecord(data.author) ? data.author : null;
+		const authorIsBot = author !== null && author.bot === true;
+		const authorId = event.meta.user_id ?? "";
+		const channelId = event.meta.channel_id ?? "";
+		const guildId = event.meta.guild_id ?? null;
+		const mentions = Array.isArray(data.mentions) ? data.mentions.map((m) => isRecord(m) ? readString(m, "id") ?? "" : "").filter((id) => id !== "") : [];
+		const eventId = crypto.randomUUID();
+		const rawJson = JSON.stringify(data);
+		this.diagnostics.recordRaw(eventId, rawJson);
+		const result = this.processor.process({
+			authorId,
+			authorIsBot,
+			channelId,
+			guildId,
+			mentionedUserIds: mentions,
+			raw: data
+		});
+		if (result.skip) {
+			this.diagnostics.recordProcessed(eventId, "skip:bot", rawJson);
+			this.logger?.info("discord skip", { reason: "bot author" });
+			return;
+		}
+		await this.deliver(notify, eventId, rawJson, result.content, result.meta);
+	}
+	adoptReady(data) {
+		const fromUser = isRecord(data.user) ? readString(data.user, "id") : void 0;
+		const fromTop = readString(data, "user_id");
+		const ownUserId = fromUser ?? fromTop ?? "";
+		if (!ownUserId) {
+			const skipId = crypto.randomUUID();
+			this.diagnostics.recordRaw(skipId, JSON.stringify(data));
+			this.diagnostics.recordProcessed(skipId, "skip:ready-missing-user-id", "");
+			this.diagnostics.recordConnection("error", "discord READY payload had neither user.id nor user_id; processor not initialized");
+			this.logger?.error("discord READY missing user id", { connector: this.config.name });
+			return;
+		}
+		this.processor = new FunnelDiscordEventProcessor({ ownUserId });
+	}
+	async deliver(notify, eventId, rawJson, content, meta) {
+		try {
+			await notify(content, meta);
+		} catch (error) {
+			this.diagnostics.recordProcessed(eventId, "emitted:delivery-failed", content || rawJson);
+			this.logger?.error("discord notify error", { error: errorMessageOf(error) });
+			return;
+		}
+		this.diagnostics.recordProcessed(eventId, "emitted", content);
+	}
+};
+//#endregion
+//#region lib/engine/connectors/discord-connector.ts
+/**
+* Discord connector descriptor. Pass `discordConnector()` to
+* `new Funnel({ connectors: [...] })` to enable the type.
+*
+* The listener is backed by `@interactive-inc/flume`'s `FlumeDiscordSource`
+* (raw Gateway WebSocket).
+*/
+const discordConnector = () => ({
+	type: "discord",
+	toolExposed: true,
+	createListener(config, deps) {
+		return new FunnelFlumeDiscordListener({
+			config: discordConnectorSchema.parse(config),
+			channelId: deps.channelId,
+			logger: deps.logger,
+			diagnosticLog: deps.diagnosticLog,
+			signal: deps.signal
+		});
+	},
+	createAdapter(config, deps) {
+		return new FunnelDiscordAdapter({
+			config: discordConnectorSchema.parse(config),
+			http: deps.http
+		});
+	},
+	secretTokens(config) {
+		return [discordConnectorSchema.parse(config).botToken].filter((token) => token !== void 0);
+	},
+	buildConfig(input, context) {
+		return discordConnectorSchema.parse({
+			id: context.id,
+			type: "discord",
+			name: input.name,
+			...typeof input.botToken === "string" ? { botToken: input.botToken } : {},
+			...typeof input.botTokenEnv === "string" ? { botTokenEnv: input.botTokenEnv } : {},
+			createdAt: context.now,
+			updatedAt: context.now
+		});
+	},
+	applyUpdate(config, fields, context) {
+		const current = discordConnectorSchema.parse(config);
+		return discordConnectorSchema.parse({
+			id: current.id,
+			name: current.name,
+			type: "discord",
+			createdAt: current.createdAt,
+			updatedAt: context.now,
+			...slotFields("botToken", "botTokenEnv", fields, current)
+		});
+	},
+	operations: {}
+});
+//#endregion
+export { FunnelDiscordAdapter as i, FunnelFlumeDiscordListener as n, FunnelDiscordEventProcessor as r, discordConnector as t };

package/dist/discord-connector-schema-D-bOVAKt.d.ts

@@ -0,0 +1,22 @@
+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
+export { discordConnectorSchema as n, DiscordConnectorConfig as t };

package/dist/docs.js

@@ -1,2 +1,2 @@
-import { t as FunnelDocs } from "./funnel-docs-BxXZ9Ksx.js";
+import { t as FunnelDocs } from "./funnel-docs-C-ge0MuB.js";
 export { FunnelDocs };

package/dist/doctor.d.ts

@@ -1,2 +1,2 @@
-import { n as DoctorReport, r as FunnelDoctor, t as DoctorFixMode } from "./funnel-doctor-CZf_0Luq.js";
+import { n as DoctorReport, r as FunnelDoctor, t as DoctorFixMode } from "./funnel-doctor-CnRQi4kM.js";
 export { DoctorFixMode, DoctorReport, FunnelDoctor };

package/dist/doctor.js

@@ -1,2 +1,2 @@
-import { t as FunnelDoctor } from "./funnel-doctor-DiJCjHsg.js";
+import { t as FunnelDoctor } from "./funnel-doctor-XrI2GBH8.js";
 export { FunnelDoctor };

package/dist/{file-process-guard-C_PLxfUX.d.ts → file-process-guard-tVcgckH6.d.ts}

@@ -1,7 +1,7 @@
-import { t as ChannelConfig } from "./settings-schema-D1xcOqRu.js";
-import { n as FunnelIdGenerator } from "./settings-reader-BIFB_j2f.js";
-import { B as FunnelLogger, I as FunnelProcessRunner } from "./connector-descriptor-6SXJoszo.js";
-import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
+import { t as ChannelConfig } from "./settings-schema-BL_c2Udm.js";
+import { n as FunnelIdGenerator } from "./settings-reader-BNxjsxCB.js";
+import { B as FunnelProcessRunner, W as FunnelLogger } from "./connector-descriptor-BFIhyTfa.js";
+import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
 
 //#region lib/engine/claude/channel-resolver.d.ts
 type ChannelResolver = {
@@ -136,7 +136,7 @@ type Deps = {
   process?: FunnelProcessRunner;
   dir?: string;
 };
-declare class FileProcessGuard implements ProcessGuard {
+declare class FunnelFileProcessGuard implements ProcessGuard {
   private readonly fs;
   private readonly process;
   private readonly pidDir;
@@ -148,4 +148,4 @@ declare class FileProcessGuard implements ProcessGuard {
   private readRecord;
 }
 //#endregion
-export { ProcessGuard as a, ChannelResolver as c, SessionStore as i, FunnelClaude as n, McpInstaller as o, LaunchOptions as r, GatewayController as s, FileProcessGuard as t };
+export { ProcessGuard as a, ChannelResolver as c, SessionStore as i, FunnelClaude as n, McpInstaller as o, LaunchOptions as r, GatewayController as s, FunnelFileProcessGuard as t };

package/dist/{file-system-o51IsM0W.d.ts → file-system-VhwwXZbm.d.ts}

@@ -21,6 +21,14 @@ declare abstract class FunnelFileSystem {
   }): void;
   abstract readdirSync(path: string): string[];
   abstract statSync(path: string): FileStat;
+  /**
+   * Run `fn` while holding an exclusive lock on `lockPath`. The lock file is
+   * created atomically (`O_EXCL`) so two processes cannot both enter. A stale
+   * lock whose owning pid is no longer alive is forcibly broken (this is what
+   * keeps a SIGKILL'd CLI command from wedging the lock forever). The Memory
+   * impl is a no-op because tests are single-threaded.
+   */
+  abstract withFileLock<T>(lockPath: string, fn: () => T): T;
 }
 //#endregion
 export { FunnelFileSystem as n, FileStat as t };

package/dist/flume-source-listener-BNyAII7N.d.ts

@@ -0,0 +1,133 @@
+import { W as FunnelLogger, _ as ConnectorDiagnosticLog, g as ConnectorConnectionStatus, j as FunnelConnectorListener } from "./connector-descriptor-BFIhyTfa.js";
+import { FlumeEventHandler, FlumeLogHandler, FlumeReconnectOptions, FlumeRunning, FlumeRuntimeDeps, FlumeSource, FlumeStatus } from "@interactive-inc/flume";
+
+//#region lib/engine/connectors/connector-diagnostics-recorder.d.ts
+type Props$1 = {
+  type: string;
+  connectorId: string | null;
+  channelId: string | null;
+  log: ConnectorDiagnosticLog | undefined;
+};
+/**
+ * Wraps a `ConnectorDiagnosticLog` with the per-listener axes (`type` /
+ * `connectorId` / `channelId`) so call sites only pass the row-specific
+ * fields. When no log is wired every call is a silent no-op.
+ */
+declare class FunnelConnectorDiagnosticsRecorder {
+  private readonly props;
+  constructor(props: Props$1);
+  recordRaw(eventId: string, payload: string): void;
+  recordProcessed(eventId: string, outcome: string, payload: string): void;
+  recordConnection(status: ConnectorConnectionStatus, detail: string): void;
+}
+//#endregion
+//#region lib/engine/connectors/flume-source-listener.d.ts
+type Props = {
+  /** Funnel connector type ("slack" / "discord" / "gh") — stamped onto diagnostic rows. */type: string;
+  connectorId: string;
+  channelId: string | null;
+  logger?: FunnelLogger;
+  diagnosticLog?: ConnectorDiagnosticLog;
+};
+type RunStartOptions = {
+  source: FlumeSource; /** Typed event handler — receives the source's events only (logs are routed separately). */
+  onEvent: FlumeEventHandler; /** Optional log handler for everything the firehose emits (including status transitions). */
+  onLog?: FlumeLogHandler;
+  deps?: FlumeRuntimeDeps;
+  /**
+   * Optional AbortSignal forwarded to the underlying Flume. When aborted, the
+   * Flume auto-closes every source and resolves to `FlumeClosed`. Use this to
+   * propagate a host-level shutdown (SIGTERM, supervisor stop, parent timeout)
+   * down to the WebSocket layer without racing through `stop()`.
+   */
+  signal?: AbortSignal;
+  /**
+   * Reconnect policy override forwarded to the Flume. The base class enables
+   * reconnect with Flume's defaults (infinite attempts, 1s base / 30s max
+   * exponential backoff with jitter) so a wifi drop or upstream socket close
+   * is auto-recovered. Subclasses can pass a stricter `{ maxAttempts, ... }`
+   * or `false` to opt out of reconnect entirely. Defaults to `true`.
+   */
+  reconnect?: boolean | FlumeReconnectOptions;
+};
+/**
+ * Status event reconstructed from the firehose `status` log entry. Funnel
+ * keeps its own shape because Flume 0.9 collapsed the dedicated `onStatus`
+ * callback into the unified `onEvent` firehose — state transitions now arrive
+ * as `log.action === "status"` entries with `detail: { from, to, reason }`.
+ */
+type StatusEvent = {
+  source: string;
+  status: FlumeStatus;
+  detail: string | null;
+};
+/**
+ * Shared lifecycle for any listener whose transport is a `FlumeSource`. Owns
+ * the per-listener `Flume` instance + the `FlumeRunning` handle returned by
+ * `open()`, the connected/alive bit, the `FlumeStatus ↔
+ * ConnectorConnectionStatus` mapping, and the close sequence — every Flume
+ * subclass plugs in only its own token resolution, source construction, and
+ * event dispatch around this skeleton.
+ *
+ * Flume 0.9 collapsed every observation channel into one firehose: events
+ * and all logs arrive through `onEvent` as a discriminated union
+ * (`{ kind: "event" } | { kind: "log" }`). This base class splits that back
+ * into the funnel-shaped trio (typed event handler, log forward, status
+ * mapping) so subclasses keep their per-protocol code unchanged.
+ */
+declare abstract class FunnelFlumeSourceListener extends FunnelConnectorListener {
+  protected readonly logger: FunnelLogger | undefined;
+  protected readonly diagnostics: FunnelConnectorDiagnosticsRecorder;
+  protected readonly type: string;
+  protected running: FlumeRunning | null;
+  protected connected: boolean;
+  /**
+   * Flipped on by Flume's `reconnecting` status, off when the new socket
+   * lands on `connected` or the source gives up with `disconnected`. Used by
+   * `isAlive()` to treat a brief reconnect window as "still alive" so the
+   * supervisor does not preempt Flume's in-progress recovery with a heavier
+   * stop+start cycle (which would discard auth.test results and rebuild
+   * every per-listener state).
+   */
+  protected reconnecting: boolean;
+  /**
+   * Promise chain that serializes typed-event delivery. Flume's emitItem
+   * fire-and-forgets the onEvent callback (see flume.ts emitItem:
+   * `Promise.resolve(onEvent(item)).catch(() => {})`), so awaiting onEvent
+   * inside the handler does NOT pause flume's source queue — multiple event
+   * deliveries would race their microtask chains. Chaining each new event
+   * onto the previous promise's `.then(...)` guarantees per-listener
+   * end-to-end FIFO regardless of whether the notify path is sync or async.
+   */
+  private deliveryChain;
+  constructor(props: Props);
+  /**
+   * Assemble a single-source Flume, open it, and store the `FlumeRunning`
+   * handle. Records `error` on any `Error` returned by `flume.open()` and
+   * rethrows so the supervisor sees the failure.
+   *
+   * The firehose handler routes:
+   *   - `kind: "event"`   → subclass's typed `onEvent`
+   *   - `kind: "log"` with `action === "status"` → `handleStatus()`
+   *   - `kind: "log"` (any)                     → optional `onLog` handler
+   */
+  protected runStart(options: RunStartOptions): Promise<void>;
+  stop(): Promise<void>;
+  isAlive(): boolean;
+  /**
+   * Maps Flume's transport status to the connection table. `reconnecting`
+   * deliberately produces no row — Flume drives many transient reconnects per
+   * minute on a flaky network, and the row would drown the more meaningful
+   * `connected`/`disconnected` pair. The `reconnecting` flag still flips so
+   * `isAlive()` can surface it to the supervisor.
+   */
+  protected handleStatus(event: StatusEvent): void;
+  /**
+   * Hook for subclass-specific cleanup that has to run inside the stop()
+   * finally block (after the running handle is cleared, before the `stopped`
+   * row is recorded). Default is no-op.
+   */
+  protected onStop(): void;
+}
+//#endregion
+export { FunnelFlumeSourceListener as t };