@interactive-inc/claude-funnel 0.60.1 → 0.64.0

package/dist/slot-fields-D-pvMgTK.js

@@ -0,0 +1,249 @@
+import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
+import { t as FunnelConnectorListener } from "./connector-listener-mPGZYa8e.js";
+import { t as FunnelConnectorDiagnosticsRecorder } from "./connector-diagnostics-recorder-COtNEmUp.js";
+import { Flume, createFlumeDefaultDeps } from "@interactive-inc/flume";
+//#region lib/engine/connectors/flume-deps.ts
+/**
+* Builds the merged runtime deps Flume listeners pass to a source. Spreads the
+* default IO over any partial test override and returns `undefined` when no
+* override exists so Flume gets to use its own internal default and there is
+* one less degree of freedom to debug.
+*/
+const resolveFlumeDeps = (override) => {
+	if (!override || Object.keys(override).length === 0) return void 0;
+	return {
+		...createFlumeDefaultDeps(),
+		...override
+	};
+};
+/**
+* Bridges a `FunnelLogger` into Flume's structured log stream. Returns
+* `undefined` when no logger is wired so Flume's option stays cleanly absent
+* instead of carrying a no-op handler.
+*
+* Forwards everything Flume produces: `detail` (reconnect counters, HTTP codes,
+* parse offsets) is merged into the logger meta, and on errors the full stack
+* is preserved — the leaf message alone is rarely enough to pinpoint a socket
+* close or parse failure. Debug entries are dropped because FunnelLogger has no
+* debug level and routing them to info would drown the operator log in
+* heartbeats.
+*/
+const flumeLogHandler = (logger) => {
+	if (!logger) return void 0;
+	return (log) => {
+		if (log.level === "debug") return;
+		const line = `${log.source}/${log.action}: ${log.message}`;
+		const meta = buildMeta(log);
+		if (log.level === "error") {
+			logger.error(line, meta);
+			return;
+		}
+		if (log.level === "warn") {
+			logger.warn(line, meta);
+			return;
+		}
+		logger.info(line, meta);
+	};
+};
+const buildMeta = (log) => {
+	const meta = { ...log.detail ?? {} };
+	if (log.error) {
+		meta.error = log.error.message;
+		if (log.error.stack) meta.stack = log.error.stack;
+		if (log.error.name && log.error.name !== "Error") meta.errorName = log.error.name;
+	}
+	return Object.keys(meta).length > 0 ? meta : void 0;
+};
+//#endregion
+//#region lib/engine/connectors/flume-source-listener.ts
+/**
+* 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.
+*/
+var FunnelFlumeSourceListener = class extends FunnelConnectorListener {
+	logger;
+	diagnostics;
+	type;
+	running = null;
+	connected = false;
+	/**
+	* 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).
+	*/
+	reconnecting = false;
+	/**
+	* 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.
+	*/
+	deliveryChain = Promise.resolve();
+	constructor(props) {
+		super();
+		this.type = props.type;
+		this.logger = props.logger;
+		this.diagnostics = new FunnelConnectorDiagnosticsRecorder({
+			type: props.type,
+			connectorId: props.connectorId,
+			channelId: props.channelId,
+			log: props.diagnosticLog
+		});
+	}
+	/**
+	* 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
+	*/
+	async runStart(options) {
+		const reconnectOption = options.reconnect ?? true;
+		const flumeReconnect = reconnectOption === false ? void 0 : reconnectOption === true ? {} : reconnectOption;
+		const handleItem = (item) => {
+			if (item.kind === "event") {
+				this.deliveryChain = this.deliveryChain.catch(() => {}).then(() => Promise.resolve(options.onEvent(item.event)));
+				return;
+			}
+			const log = item.log;
+			const statusEvent = readStatusLog(log);
+			if (statusEvent) this.handleStatus(statusEvent);
+			options.onLog?.(log);
+		};
+		const flumeOptions = {
+			sources: [options.source],
+			onEvent: handleItem
+		};
+		if (options.deps) flumeOptions.deps = options.deps;
+		if (options.signal) flumeOptions.signal = options.signal;
+		if (flumeReconnect) flumeOptions.reconnect = flumeReconnect;
+		const result = await new Flume(flumeOptions).open();
+		if (result instanceof Error) {
+			this.diagnostics.recordConnection("error", errorMessageOf(result));
+			throw result;
+		}
+		this.running = result;
+	}
+	async stop() {
+		if (!this.running) return;
+		try {
+			await this.running.close();
+			this.diagnostics.recordConnection("disconnected", "");
+		} catch (error) {
+			this.diagnostics.recordConnection("error", errorMessageOf(error));
+			this.logger?.error(`${this.type} stop error`, { error: errorMessageOf(error) });
+		} finally {
+			this.running = null;
+			this.connected = false;
+			this.reconnecting = false;
+			this.deliveryChain = Promise.resolve();
+			this.onStop();
+			this.diagnostics.recordConnection("stopped", "");
+		}
+	}
+	isAlive() {
+		if (this.running === null) return false;
+		return this.connected || this.reconnecting;
+	}
+	/**
+	* 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.
+	*/
+	handleStatus(event) {
+		if (event.status === "connected") {
+			this.connected = true;
+			this.reconnecting = false;
+			this.diagnostics.recordConnection("connected", event.detail ?? "");
+			return;
+		}
+		if (event.status === "disconnected") {
+			this.connected = false;
+			this.reconnecting = false;
+			this.diagnostics.recordConnection("disconnected", event.detail ?? "");
+			return;
+		}
+		if (event.status === "reconnecting") {
+			this.connected = false;
+			this.reconnecting = true;
+		}
+	}
+	/**
+	* 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.
+	*/
+	onStop() {}
+};
+const STATUS_VALUES = [
+	"disconnected",
+	"connecting",
+	"connected",
+	"reconnecting"
+];
+const isFlumeStatus = (value) => typeof value === "string" && STATUS_VALUES.includes(value);
+/**
+* Reconstructs the old `FlumeStatusEvent` shape from a `status` log entry.
+* Returns `null` for anything else so the firehose pump is a single check.
+* Flume 0.9 emits these as `log.action === "status"` with a structured
+* `detail: { from, to, reason }` payload (see flume's FlumeStatusEmitter).
+*/
+const readStatusLog = (log) => {
+	if (log.action !== "status") return null;
+	const detail = log.detail;
+	if (!detail) return null;
+	const to = detail.to;
+	if (!isFlumeStatus(to)) return null;
+	const reason = typeof detail.reason === "string" ? detail.reason : null;
+	return {
+		source: log.source,
+		status: to,
+		detail: reason
+	};
+};
+//#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 { resolveFlumeDeps as i, FunnelFlumeSourceListener as n, flumeLogHandler as r, slotFields as t };