@interactive-inc/claude-funnel 0.66.0 → 0.68.0

package/dist/connector-descriptor-D4XtEsH8.d.ts

@@ -0,0 +1,215 @@
+import { n as FunnelClock, t as FunnelLogger } from "./logger-mMZvblTx.js";
+import { n as FunnelFileSystem } from "./file-system-BNtl997T.js";
+import { o as ConnectorDiagnosticLog } from "./diagnostic-log-BsAg5qZK.js";
+import { z } from "zod";
+//#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>;
+/**
+ * Long-lived event source for one connector.
+ *
+ * `start()` opens the underlying connection (Slack Socket Mode, Discord
+ * Gateway, GH polling, schedule tick) and pushes events through `notify`.
+ * `stop()` releases the resources so the supervisor can recreate the listener
+ * with new config without restarting the whole gateway. `isAlive()` lets the
+ * supervisor periodically health-check and auto-restart dead listeners; the
+ * default optimistic implementation is fine for poll/tick-based listeners
+ * that self-heal.
+ */
+declare abstract class FunnelConnectorListener {
+  abstract start(notify: NotifyFn): Promise<void>;
+  abstract stop(): Promise<void>;
+  isAlive(): boolean;
+}
+//#endregion
+//#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/connector-descriptor.d.ts
+/** Boundaries a listener needs, supplied by the registry at build time. */
+type ConnectorListenerDeps = {
+  channelId: string;
+  fs: FunnelFileSystem;
+  process: FunnelProcessRunner;
+  /** HTTP client for self-detection (Slack auth.test), reactions, and other listener-side REST calls. */
+  http: FunnelHttpClient;
+  /** Wall clock — listeners that own a timer (schedule) read it from here so tests can inject a fake. */
+  clock: FunnelClock;
+  logger?: FunnelLogger;
+  diagnosticLog?: ConnectorDiagnosticLog;
+  /**
+   * Optional shutdown signal forwarded to flume-backed listeners. When the
+   * host aborts the signal, the listener's Flume tears down its WebSocket /
+   * fetch loop without waiting for the supervisor's `stop()`. Hosts that want
+   * a clean SIGTERM story wire `controller.signal` here and call
+   * `controller.abort()` in their shutdown handler.
+   */
+  signal?: AbortSignal;
+  /** 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;
+  /** HTTP client for outbound calls. Used by the Slack adapter, future REST adapters. */
+  http: FunnelHttpClient;
+  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 (e.g. 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 { RunResult as C, RunOptions as S, baseConnectorConfigSchema as _, ConnectorOperation as a, FunnelProcessRunner as b, FunnelHttpClient as c, FunnelConnectorListener as d, NotifyFn as f, BaseConnectorConfig as g, JsonValue as h, ConnectorListenerDeps as i, HttpRequest as l, FunnelConnectorAdapter as m, ConnectorBuildContext as n, ConnectorOperationContext as o, CallInput as p, ConnectorDescriptor as r, ConnectorUpdateContext as s, ConnectorAdapterDeps as t, HttpResponse as u, AttachOptions as v, ProcessSnapshot as x, DetachOptions as y };

package/dist/{connector-diagnostics-recorder-COtNEmUp.js → connector-diagnostics-recorder-BmOijU1p.js}

@@ -5,6 +5,7 @@
 * fields. When no log is wired every call is a silent no-op.
 */
 var FunnelConnectorDiagnosticsRecorder = class {
+	props;
 	constructor(props) {
 		this.props = props;
 		Object.freeze(this);

package/dist/connectors/discord.d.ts

@@ -1,12 +1,13 @@
-import { t as FunnelLogger } from "../logger-Bc_Ooypb.js";
-import { M as CallInput, N as FunnelConnectorAdapter, c as FunnelHttpClient, g as ConnectorDiagnosticLog, j as NotifyFn, r as ConnectorDescriptor } from "../connector-descriptor-CmyHlEiT.js";
-import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-D1dyxhXk.js";
-import { t as FunnelFlumeSourceListener } from "../flume-source-listener-FzR5lGpL.js";
+import { t as FunnelLogger } from "../logger-mMZvblTx.js";
+import { c as FunnelHttpClient, f as NotifyFn, m as FunnelConnectorAdapter, p as CallInput, r as ConnectorDescriptor } from "../connector-descriptor-D4XtEsH8.js";
+import { o as ConnectorDiagnosticLog } from "../diagnostic-log-BsAg5qZK.js";
+import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-BaBZYHxK.js";
+import { t as FunnelFlumeSourceListener } from "../flume-source-listener-Ba8_1Mg-.js";
 import { FlumeRuntimeDeps } from "@interactive-inc/flume";
-
 //#region lib/engine/connectors/discord-adapter.d.ts
 type Deps$1 = {
-  config: DiscordConnectorConfig; /** Environment used to resolve a `botTokenEnv` reference. Defaults to process.env. */
+  config: DiscordConnectorConfig;
+  /** Environment used to resolve a `botTokenEnv` reference. Defaults to process.env. */
   env?: NodeJS.ProcessEnv;
   http?: FunnelHttpClient;
 };
@@ -79,8 +80,10 @@ type Deps = {
   env?: NodeJS.ProcessEnv;
   logger?: FunnelLogger;
   diagnosticLog?: ConnectorDiagnosticLog;
-  flumeDeps?: Partial<FlumeRuntimeDeps>; /** Shutdown signal forwarded to the underlying Flume. */
-  signal?: AbortSignal; /** See `DiscordConnectorOptions.eventTypes`. */
+  flumeDeps?: Partial<FlumeRuntimeDeps>;
+  /** Shutdown signal forwarded to the underlying Flume. */
+  signal?: AbortSignal;
+  /** See `DiscordConnectorOptions.eventTypes`. */
   eventTypes?: ReadonlyArray<string> | "all";
 };
 /**

package/dist/connectors/discord.js

@@ -1,3 +1,3 @@
-import { t as discordConnectorSchema } from "../discord-connector-schema-B4YpWpR3.js";
-import { i as FunnelDiscordAdapter, n as FunnelFlumeDiscordListener, r as FunnelDiscordEventProcessor, t as discordConnector } from "../discord-connector-DXARcO6w.js";
+import { t as discordConnectorSchema } from "../discord-connector-schema-saAGuPmJ.js";
+import { i as FunnelDiscordAdapter, n as FunnelFlumeDiscordListener, r as FunnelDiscordEventProcessor, t as discordConnector } from "../discord-connector-CAcWifJn.js";
 export { FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelFlumeDiscordListener, discordConnector, discordConnectorSchema };

package/dist/connectors/gh.d.ts

@@ -1,9 +1,9 @@
-import { t as FunnelLogger } from "../logger-Bc_Ooypb.js";
-import { M as CallInput, N as FunnelConnectorAdapter, g as ConnectorDiagnosticLog, j as NotifyFn, r as ConnectorDescriptor, z as FunnelProcessRunner } from "../connector-descriptor-CmyHlEiT.js";
-import { t as FunnelFlumeSourceListener } from "../flume-source-listener-FzR5lGpL.js";
-import { n as ghConnectorSchema, t as GhConnectorConfig } from "../gh-connector-schema-BCHEqpUg.js";
+import { t as FunnelLogger } from "../logger-mMZvblTx.js";
+import { b as FunnelProcessRunner, f as NotifyFn, m as FunnelConnectorAdapter, p as CallInput, r as ConnectorDescriptor } from "../connector-descriptor-D4XtEsH8.js";
+import { o as ConnectorDiagnosticLog } from "../diagnostic-log-BsAg5qZK.js";
+import { t as FunnelFlumeSourceListener } from "../flume-source-listener-Ba8_1Mg-.js";
+import { n as ghConnectorSchema, t as GhConnectorConfig } from "../gh-connector-schema-BrNsCl1T.js";
 import { FlumeRuntimeDeps } from "@interactive-inc/flume";
-
 //#region lib/engine/connectors/gh-adapter.d.ts
 type Deps$1 = {
   process?: FunnelProcessRunner;
@@ -34,7 +34,8 @@ type Deps = {
   process?: FunnelProcessRunner;
   logger?: FunnelLogger;
   diagnosticLog?: ConnectorDiagnosticLog;
-  flumeDeps?: Partial<FlumeRuntimeDeps>; /** Shutdown signal forwarded to the underlying Flume. */
+  flumeDeps?: Partial<FlumeRuntimeDeps>;
+  /** Shutdown signal forwarded to the underlying Flume. */
   signal?: AbortSignal;
 };
 /**

package/dist/connectors/gh.js

@@ -1,3 +1,3 @@
-import { t as ghConnectorSchema } from "../gh-connector-schema-CAqIhzGr.js";
-import { n as FunnelFlumeGhListener, r as FunnelGhAdapter, t as ghConnector } from "../gh-connector-BUGCOEWS.js";
+import { t as ghConnectorSchema } from "../gh-connector-schema-DmZTrzUu.js";
+import { n as FunnelFlumeGhListener, r as FunnelGhAdapter, t as ghConnector } from "../gh-connector-DMwI6zJA.js";
 export { FunnelFlumeGhListener, FunnelGhAdapter, ghConnector, ghConnectorSchema };

package/dist/connectors/schedule.d.ts

@@ -1,18 +1,15 @@
-import { t as FunnelLogger } from "../logger-Bc_Ooypb.js";
-import { n as FunnelFileSystem } from "../file-system-DHgbuTFb.js";
-import { A as FunnelConnectorListener, g as ConnectorDiagnosticLog, j as NotifyFn, r as ConnectorDescriptor } from "../connector-descriptor-CmyHlEiT.js";
-import { a as scheduleConnectorSchema, i as scheduleCatchupPolicySchema, n as ScheduleConnectorConfig, o as scheduleEntrySchema, r as ScheduleEntry, t as ScheduleCatchupPolicy } from "../schedule-connector-schema-D7ZEKvit.js";
-
+import { t as FunnelLogger } from "../logger-mMZvblTx.js";
+import { n as FunnelFileSystem } from "../file-system-BNtl997T.js";
+import { d as FunnelConnectorListener, f as NotifyFn, r as ConnectorDescriptor } from "../connector-descriptor-D4XtEsH8.js";
+import { o as ConnectorDiagnosticLog } from "../diagnostic-log-BsAg5qZK.js";
+import { a as ScheduleEntry, c as cronScheduleEntrySchema, d as scheduleConnectorSchema, f as scheduleEntryInputSchema, i as ScheduleConnectorConfig, l as onceScheduleEntrySchema, n as OnceScheduleEntry, o as ScheduleEntryInput, p as scheduleEntrySchema, r as ScheduleCatchupPolicy, s as cronExpressionSchema, t as CronScheduleEntry, u as scheduleCatchupPolicySchema } from "../schedule-connector-schema-Tq5kJul-.js";
 //#region lib/engine/connectors/match-cron.d.ts
+/** Throws with a user-facing reason when `expr` is not a supported cron expression. */
+declare const validateCronExpression: (expr: string) => void;
 /**
- * Returns true when `date` (local time) satisfies a 5-field cron expression.
- *
- * Two deliberate deviations from Vixie cron, called out so schedules are not
- * written expecting the other behavior:
- *   - Day-of-month and day-of-week are ANDed, not ORed. Vixie cron fires when
- *     EITHER matches once both are restricted; here every field must match.
- *   - Day-of-week is 0-6 (Sunday=0). `7` for Sunday is NOT accepted (it throws
- *     as out-of-range); use `0`.
+ * Returns true when `date` (local time) satisfies a standard 5-field cron
+ * expression. Sunday accepts both 0 and 7. When day-of-month and day-of-week
+ * are both restricted, either field matching is sufficient (Vixie cron).
  */
 declare const matchCron: (expr: string, date: Date) => boolean;
 //#endregion
@@ -39,9 +36,11 @@ declare class FunnelScheduleStateStore {
 type ScheduleOnFired = (entry: ScheduleEntry, firedAt: Date) => void | Promise<void>;
 type Deps = {
   config: ScheduleConnectorConfig;
-  lastFiredStore: FunnelScheduleStateStore; /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
+  lastFiredStore: FunnelScheduleStateStore;
+  /** Funnel channel uuid this connector lives under; stamped onto diagnostic-log rows. */
   channelId?: string;
-  logger?: FunnelLogger; /** Diagnostic log of fired entries and lifecycle. No-op when absent. */
+  logger?: FunnelLogger;
+  /** Diagnostic log of fired entries and lifecycle. No-op when absent. */
   diagnosticLog?: ConnectorDiagnosticLog;
   now?: () => Date;
   /**
@@ -68,16 +67,21 @@ declare class FunnelScheduleListener extends FunnelConnectorListener {
   isAlive(): boolean;
   tick(notify: NotifyFn): Promise<void>;
   private fireEntry;
+  private fireOnceEntry;
+  private fireCronEntry;
+  private seedSearchWatermark;
   private notifyOne;
   private findMostRecentMatch;
   private findAllMatches;
   private logInvalidCron;
   private truncateToMinute;
+  private pruneRemovedEntries;
 }
 //#endregion
 //#region lib/engine/connectors/schedule-connector.d.ts
 type ScheduleConnectorOptions = {
-  /** Invoked after a schedule entry fires successfully — e.g. to drop one-shot entries. */onFired?: ScheduleOnFired;
+  /** Invoked after a schedule entry fires successfully — e.g. to drop one-shot entries. */
+  onFired?: ScheduleOnFired;
 };
 /**
  * Schedule connector descriptor. Pass `scheduleConnector()` to
@@ -88,4 +92,4 @@ type ScheduleConnectorOptions = {
  */
 declare const scheduleConnector: (options?: ScheduleConnectorOptions) => ConnectorDescriptor;
 //#endregion
-export { FunnelScheduleListener, FunnelScheduleStateStore, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleConnectorOptions, ScheduleEntry, ScheduleOnFired, matchCron, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntrySchema };
+export { CronScheduleEntry, FunnelScheduleListener, FunnelScheduleStateStore, OnceScheduleEntry, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleConnectorOptions, ScheduleEntry, ScheduleEntryInput, ScheduleOnFired, cronExpressionSchema, cronScheduleEntrySchema, matchCron, onceScheduleEntrySchema, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntryInputSchema, scheduleEntrySchema, validateCronExpression };

package/dist/connectors/schedule.js

@@ -1,3 +1,3 @@
-import { n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "../schedule-connector-schema-DKEPZnVv.js";
-import { i as matchCron, n as FunnelScheduleListener, r as FunnelScheduleStateStore, t as scheduleConnector } from "../schedule-connector-9k3gOIgl.js";
-export { FunnelScheduleListener, FunnelScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntrySchema };
+import { a as scheduleConnectorSchema, c as matchCron, i as scheduleCatchupPolicySchema, l as validateCronExpression, n as cronScheduleEntrySchema, o as scheduleEntryInputSchema, r as onceScheduleEntrySchema, s as scheduleEntrySchema, t as cronExpressionSchema } from "../schedule-connector-schema-CNV8PgWX.js";
+import { n as FunnelScheduleListener, r as FunnelScheduleStateStore, t as scheduleConnector } from "../schedule-connector-BXUOYgwZ.js";
+export { FunnelScheduleListener, FunnelScheduleStateStore, cronExpressionSchema, cronScheduleEntrySchema, matchCron, onceScheduleEntrySchema, scheduleCatchupPolicySchema, scheduleConnector, scheduleConnectorSchema, scheduleEntryInputSchema, scheduleEntrySchema, validateCronExpression };

package/dist/connectors/slack.d.ts

@@ -1,13 +1,14 @@
-import { t as FunnelLogger } from "../logger-Bc_Ooypb.js";
-import { M as CallInput, N as FunnelConnectorAdapter, c as FunnelHttpClient, g as ConnectorDiagnosticLog, j as NotifyFn, r as ConnectorDescriptor } from "../connector-descriptor-CmyHlEiT.js";
-import { t as FunnelFlumeSourceListener } from "../flume-source-listener-FzR5lGpL.js";
-import { a as SlackRawEvent, c as SlackMessageEvent, d as slackConnectorSchema, i as SlackProcessedSkip, l as SlackReactionEvent, n as SlackProcessed, o as SlackSkipReason, r as SlackProcessedEmit, s as SlackEvent, t as FunnelSlackEventProcessor, u as SlackConnectorConfig } from "../slack-event-processor-BDTr62cN.js";
+import { t as FunnelLogger } from "../logger-mMZvblTx.js";
+import { c as FunnelHttpClient, f as NotifyFn, m as FunnelConnectorAdapter, p as CallInput, r as ConnectorDescriptor } from "../connector-descriptor-D4XtEsH8.js";
+import { o as ConnectorDiagnosticLog } from "../diagnostic-log-BsAg5qZK.js";
+import { t as FunnelFlumeSourceListener } from "../flume-source-listener-Ba8_1Mg-.js";
+import { a as SlackRawEvent, c as SlackMessageEvent, d as slackConnectorSchema, i as SlackProcessedSkip, l as SlackReactionEvent, n as SlackProcessed, o as SlackSkipReason, r as SlackProcessedEmit, s as SlackEvent, t as FunnelSlackEventProcessor, u as SlackConnectorConfig } from "../slack-event-processor-DmAlq4cV.js";
 import { FlumeRuntimeDeps } from "@interactive-inc/flume";
-
 //#region lib/engine/connectors/slack-adapter.d.ts
 type Deps$1 = {
   config: SlackConnectorConfig;
-  env?: NodeJS.ProcessEnv; /** HTTP client injection — defaults to `NodeFunnelHttpClient`. Tests inject `MemoryFunnelHttpClient`. */
+  env?: NodeJS.ProcessEnv;
+  /** HTTP client injection — defaults to `NodeFunnelHttpClient`. Tests inject `MemoryFunnelHttpClient`. */
   http?: FunnelHttpClient;
 };
 /**
@@ -73,10 +74,14 @@ type Deps = {
   env?: NodeJS.ProcessEnv;
   logger?: FunnelLogger;
   diagnosticLog?: ConnectorDiagnosticLog;
-  flumeDeps?: Partial<FlumeRuntimeDeps>; /** HTTP client for `auth.test` and `reactions.add`. Defaults to NodeFunnelHttpClient. */
-  http?: FunnelHttpClient; /** Shutdown signal forwarded to the underlying Flume. */
-  signal?: AbortSignal; /** See `SlackPreprocessEvent`. Default: identity (no preprocessing). */
-  preprocessEvent?: SlackPreprocessEvent; /** See `SlackInteractiveHandler`. Default: drop interactive envelopes silently. */
+  flumeDeps?: Partial<FlumeRuntimeDeps>;
+  /** HTTP client for `auth.test` and `reactions.add`. Defaults to NodeFunnelHttpClient. */
+  http?: FunnelHttpClient;
+  /** Shutdown signal forwarded to the underlying Flume. */
+  signal?: AbortSignal;
+  /** See `SlackPreprocessEvent`. Default: identity (no preprocessing). */
+  preprocessEvent?: SlackPreprocessEvent;
+  /** See `SlackInteractiveHandler`. Default: drop interactive envelopes silently. */
   onInteractive?: SlackInteractiveHandler;
 };
 /**

package/dist/connectors/slack.js

@@ -1,4 +1,4 @@
-import { t as slackConnectorSchema } from "../slack-connector-schema-Dem8to4P.js";
-import { t as FunnelSlackEventProcessor } from "../slack-event-processor-xFDG3US0.js";
-import { n as FunnelFlumeSlackListener, r as FunnelSlackAdapter, t as slackConnector } from "../slack-connector-CxpWagbT.js";
+import { t as slackConnectorSchema } from "../slack-connector-schema-EGVuuqSX.js";
+import { t as FunnelSlackEventProcessor } from "../slack-event-processor-Cs_YuI3w.js";
+import { n as FunnelFlumeSlackListener, r as FunnelSlackAdapter, t as slackConnector } from "../slack-connector-CC3V2VXQ.js";
 export { FunnelFlumeSlackListener, FunnelSlackAdapter, FunnelSlackEventProcessor, slackConnector, slackConnectorSchema };

package/dist/diagnostic-event-CxMM5Bl2.js

@@ -0,0 +1,78 @@
+//#region lib/services/diagnostics/diagnostic-event.ts
+const stringOrNull = (value) => typeof value === "string" && value.length > 0 ? value : null;
+const numberOrNull = (value) => typeof value === "number" ? value : null;
+const stringOr = (value, fallback) => typeof value === "string" ? value : fallback;
+const isStringKeyedObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const parsePayloadObject = (payload) => {
+	if (payload === null) return null;
+	try {
+		const parsed = JSON.parse(payload);
+		if (isStringKeyedObject(parsed)) return parsed;
+	} catch {
+		return null;
+	}
+	return null;
+};
+const truncate = (text, max) => text.length <= max ? text : `${text.slice(0, max)}…`;
+const previewOf = (payload) => {
+	if (typeof payload !== "string" || payload.length === 0) return null;
+	const parsed = parsePayloadObject(payload);
+	if (parsed !== null && "text" in parsed) return truncate(String(parsed.text), 60);
+	return truncate(payload, 60);
+};
+const toDiagnosticEvent = (row) => {
+	const payload = stringOrNull(row.payload);
+	return {
+		seq: numberOrNull(row.seq),
+		ts: numberOrNull(row.ts),
+		type: stringOr(row.type, "?"),
+		outcome: stringOr(row.outcome, "?"),
+		eventId: stringOrNull(row.event_id),
+		payload,
+		payloadParsed: parsePayloadObject(payload),
+		preview: previewOf(row.payload)
+	};
+};
+const toDiagnosticConnectionError = (row) => ({
+	seq: numberOrNull(row.seq),
+	ts: numberOrNull(row.ts),
+	type: stringOr(row.type, "?"),
+	status: stringOr(row.status, "?"),
+	detail: stringOrNull(row.detail)
+});
+const diagnosticEventOfProcessed = (event) => ({
+	seq: event.seq,
+	ts: event.ts,
+	type: event.type,
+	outcome: event.outcome,
+	eventId: event.eventId,
+	payload: stringOrNull(event.payload),
+	payloadParsed: parsePayloadObject(stringOrNull(event.payload)),
+	preview: previewOf(event.payload)
+});
+const diagnosticEventOfRaw = (event) => ({
+	seq: event.seq,
+	ts: event.ts,
+	type: event.type,
+	outcome: "",
+	eventId: event.eventId,
+	payload: stringOrNull(event.payload),
+	payloadParsed: parsePayloadObject(stringOrNull(event.payload)),
+	preview: previewOf(event.payload)
+});
+const diagnosticConnectionEventOf = (event) => ({
+	seq: event.seq,
+	ts: event.ts,
+	type: event.type,
+	status: event.status,
+	detail: stringOrNull(event.detail)
+});
+const queryRows = (reader, sql, params) => {
+	try {
+		return reader.query(sql, params);
+	} finally {
+		reader.close();
+	}
+};
+//#endregion
+export { queryRows as a, previewOf as i, diagnosticEventOfProcessed as n, toDiagnosticConnectionError as o, diagnosticEventOfRaw as r, toDiagnosticEvent as s, diagnosticConnectionEventOf as t };