@interactive-inc/claude-funnel 0.8.0 → 0.8.1

package/dist/gateway/factory.d.ts

@@ -0,0 +1,7 @@
+import type { GatewayRouteDeps } from "./routes/route-deps";
+export type Env = {
+    Variables: {
+        deps: GatewayRouteDeps;
+    };
+};
+export declare const factory: import("hono/factory").Factory<Env, string>;

package/dist/gateway/funnel-event-store.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import type { ReplayableEvent } from "./broadcaster";
+/**
+ * Replayable event payload persisted by the gateway. Domain events the
+ * broadcaster emits to WS clients land here so reconnects across daemon
+ * restarts can be served from disk. System events (gateway start, channel
+ * connected, etc.) are routed to `FunnelLogger` instead — they never go
+ * through this store, which keeps the seq space clean for replay.
+ */
+export declare const funnelEventSchema: z.ZodObject<{
+    type: z.ZodString;
+    content: z.ZodString;
+    channel_id: z.ZodNullable<z.ZodString>;
+    connector_id: z.ZodNullable<z.ZodString>;
+    meta: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type FunnelEvent = z.infer<typeof funnelEventSchema>;
+type Props = {
+    /** SQLite database file path. Created on first write. ":memory:" for tests. */
+    path: string;
+    /** Override for tests. Defaults to `Date.now`. */
+    now?: () => number;
+    /** Optional row cap. Pruned on every insert. */
+    maxRows?: number;
+    /** Optional age cap in ms. Pruned on every insert. */
+    maxAgeMs?: number;
+};
+/**
+ * SQLite-backed event store. One indexed table holds every broadcaster
+ * event with `channel_id` and `connector_id` as dedicated columns, so
+ * per-channel and per-connector replay is an indexed range scan.
+ *
+ * Concurrency: `seq` is `INTEGER PRIMARY KEY`, so SQLite assigns it
+ * atomically. The broadcaster owns its own offset counter at runtime
+ * (seeded from `findMaxOffset()` at startup); each broadcaster event
+ * flows in here via `record()` with that pre-assigned offset, which the
+ * sink stores via `write()` — PK uniqueness catches double-emit bugs.
+ *
+ * System events (gateway lifecycle, channel connect/disconnect, etc.) do
+ * NOT go through this store. They are diagnostic only and live in
+ * `FunnelLogger`'s file so the seq space here stays exclusive to
+ * broadcaster traffic. This is what makes the broadcaster's seq seeding
+ * (`getMaxSeq()` at startup) correct without per-event coordination.
+ */
+export declare class FunnelEventStore {
+    private readonly sink;
+    private readonly now;
+    constructor(props: Props);
+    /**
+     * Persist a broadcaster-driven event with its assigned offset. Caller
+     * (the gateway-server) supplies the offset from `broadcaster.broadcast()`
+     * so this store and the broadcaster's in-memory ring stay aligned.
+     */
+    record(props: {
+        content: string;
+        channelId: string | null;
+        connectorId: string | null;
+        meta: Record<string, string> | null;
+        offset: number;
+    }): void;
+    /**
+     * Returns events with offset > since. Filtering by channel/connector is
+     * the broadcaster's responsibility (it knows the client's subscription),
+     * so this returns the full slice and lets the caller filter.
+     */
+    loadSince(since: number): ReplayableEvent[];
+    /**
+     * Returns events for one channel (and optionally one connector). Used
+     * by the gateway logs CLI for scoped queries. Channel/connector filters
+     * are indexed columns, so this is an indexed range scan.
+     */
+    loadForChannel(props: {
+        channelId: string;
+        connectorId?: string;
+        sinceSeq?: number;
+        limit?: number;
+    }): ReplayableEvent[];
+    findMaxOffset(): number;
+    close(): void;
+}
+export {};

package/dist/gateway/gateway-server.d.ts

@@ -0,0 +1,94 @@
+import type { Server } from "bun";
+import type { FunnelChannels } from "../engine/channels/channels";
+import { FunnelBroadcaster } from "./broadcaster";
+import { FunnelEventStore } from "./funnel-event-store";
+import { FunnelListenerSupervisor } from "./listener-supervisor";
+import { FunnelLogger } from "../engine/logger/logger";
+import type { FunnelProcessRunner } from "../engine/process/process-runner";
+import type { FunnelSettingsReader } from "../engine/settings/settings-reader";
+import type { FunnelClock } from "../engine/time/clock";
+type Deps = {
+    channels: FunnelChannels;
+    settings: FunnelSettingsReader;
+    port?: number;
+    /** Directory holding the SQLite event store. The DB file lives at `<logDir>/events.db`. */
+    logDir?: string;
+    process?: FunnelProcessRunner;
+    clock?: FunnelClock;
+    logger?: FunnelLogger;
+    selfPid?: number;
+    killCompetingSlack?: boolean;
+    /** Bearer token required for `/listeners*`, `/status`, and `/ws`. Empty string disables auth (tests only). */
+    token?: string;
+};
+type WsData = {
+    /** Stable channel id (uuid) the client subscribed to. "" for tap-all clients. */
+    channel: string;
+    /** Resolved channel name (for log readability). null for tap-all or unknown. */
+    channelName: string | null;
+    /** Connector names belonging to that channel; used by tap-all replay filtering. */
+    connectors: string[];
+    tapAll?: boolean;
+    /** Routing mode for this channel; resolved at upgrade time from settings. */
+    delivery: "fanout" | "exclusive";
+    /** Replay any events with offset strictly greater than this on open, then resume the live stream. */
+    since?: number;
+};
+/**
+ * In-process gateway: runs `Bun.serve` (HTTP + WebSocket /ws), boots connector
+ * listeners through `FunnelListenerSupervisor`, fans events out via
+ * `FunnelBroadcaster`, and persists them via `FunnelEventStore` (SQLite).
+ * System events (gateway lifecycle, connect/disconnect) flow to `FunnelLogger`
+ * instead — keeping the SQLite seq space exclusive to broadcaster traffic so
+ * the broadcaster's offset counter and `getMaxSeq()` stay aligned without
+ * per-event coordination. Exposes `/listeners` HTTP for runtime
+ * start/stop/restart of individual connectors.
+ */
+export declare class FunnelGatewayServer {
+    private readonly channels;
+    private readonly settings;
+    private readonly port;
+    private readonly logDir;
+    private readonly process?;
+    private readonly logger;
+    private readonly selfPid;
+    private readonly killCompetingSlack;
+    private readonly token;
+    private readonly broadcaster;
+    private readonly eventStore;
+    private readonly supervisor;
+    private readonly nowMs;
+    private startedAt;
+    private server;
+    constructor(deps: Deps);
+    start(): Promise<Server<WsData>>;
+    stop(): Promise<void>;
+    getStatus(): {
+        clients: number;
+        channels: {
+            channel: string;
+            connectors: string[];
+        }[];
+    };
+    getBroadcaster(): FunnelBroadcaster;
+    getSupervisor(): FunnelListenerSupervisor;
+    getEventStore(): FunnelEventStore;
+    private handleFetch;
+    private handleWsOpen;
+    private handleWsClose;
+    private logServerStarted;
+    private buildApp;
+    /**
+     * Reads the bearer token from the WebSocket upgrade request. Accepts:
+     *   - `Sec-WebSocket-Protocol: funnel.token.<value>` (preferred — header, never logged in URLs)
+     *   - `Authorization: Bearer <value>` (also header-based)
+     * Returns true on a constant-time match against the daemon token.
+     */
+    private tokenMatchesUpgrade;
+    private resolveChannel;
+    private bootListeners;
+    private notify;
+    private lookupChannelId;
+    private lookupConnectorId;
+}
+export {};

package/dist/gateway/gateway-token.d.ts

@@ -0,0 +1,33 @@
+import { FunnelFileSystem } from "../engine/fs/file-system";
+type Deps = {
+    fs?: FunnelFileSystem;
+    dir?: string;
+    generate?: () => string;
+};
+/**
+ * Reads / generates the gateway daemon token used to authenticate
+ * `/listeners*`, `/status`, and `/ws` connections.
+ *
+ * Token file: `<dir>/gateway.token` (default `~/.funnel/gateway.token`),
+ * written with mode 0600. Clients on the same machine as the daemon read
+ * the file directly; the token never leaves the user's home directory.
+ */
+export declare class FunnelGatewayToken {
+    private readonly fs;
+    private readonly path;
+    private readonly generate;
+    constructor(deps?: Deps);
+    read(): string | null;
+    /**
+     * Returns the existing token or, if missing, generates one and writes it with mode 0600.
+     *
+     * NOTE: not atomic — two concurrent `ensure()` calls (e.g., `fnl gateway start` racing
+     * itself before the PID lock is acquired) could each generate independent tokens. The
+     * gateway PID file makes this practically a non-issue; if you need stronger guarantees,
+     * take a file lock around this call externally.
+     */
+    ensure(): string;
+    getPath(): string;
+}
+export declare const DEFAULT_GATEWAY_TOKEN_PATH: string;
+export {};

package/dist/gateway/gateway.d.ts

@@ -0,0 +1,58 @@
+import { FunnelFileSystem } from "../engine/fs/file-system";
+import { FunnelProcessRunner } from "../engine/process/process-runner";
+import { FunnelClock } from "../engine/time/clock";
+type Deps = {
+    process?: FunnelProcessRunner;
+    fs?: FunnelFileSystem;
+    clock?: FunnelClock;
+    dir?: string;
+    tmpDir?: string;
+    port?: number;
+    sleep?: (ms: number) => Promise<void>;
+};
+/**
+ * Manages the gateway daemon as a separate process via PID file.
+ * Use `start()` to spawn `bun daemon.ts` in the background and `stop()` to
+ * terminate it. For an in-process gateway, use `Funnel.gatewayServer` instead.
+ */
+export declare class FunnelGateway {
+    private readonly process;
+    private readonly fs;
+    private readonly clock;
+    private readonly pidFile;
+    private readonly logDir;
+    private readonly gatewayLog;
+    private readonly tmpDir;
+    private readonly port;
+    private readonly sleep;
+    constructor(deps?: Deps);
+    isRunning(): boolean;
+    getStatus(): {
+        running: boolean;
+        pid: number | null;
+        port: number;
+    };
+    start(options?: {
+        caffeinate?: boolean;
+    }): Promise<boolean>;
+    buildStartCommand(gatewayScript: string, options?: {
+        caffeinate?: boolean;
+    }): string;
+    stop(): Promise<boolean>;
+    restart(options?: {
+        onlyIfRunning?: boolean;
+        caffeinate?: boolean;
+    }): Promise<{
+        ok: boolean;
+        wasRunning: boolean;
+        stopped: boolean;
+        started: boolean;
+    }>;
+    getLogDir(): string;
+    getGatewayLog(): string;
+    getPort(): number;
+    private readPid;
+    private removePid;
+    private isProcessAlive;
+}
+export {};

package/dist/gateway/kill-competing-slack-gateways.d.ts

@@ -0,0 +1,9 @@
+import { FunnelLogger } from "../engine/logger/logger";
+import { FunnelProcessRunner } from "../engine/process/process-runner";
+type Props = {
+    selfPid: number;
+    process?: FunnelProcessRunner;
+    logger?: FunnelLogger;
+};
+export declare const killCompetingSlackGateways: (props: Props) => Promise<number[]>;
+export {};

package/dist/gateway/listener-supervisor.d.ts

@@ -0,0 +1,85 @@
+import type { ConnectorConfig } from "../connectors/connector-config-schema";
+import type { FunnelConnectorListener } from "../connectors/connector-listener";
+import type { ChannelConnectorView } from "../engine/channels/channels";
+import { FunnelLogger } from "../engine/logger/logger";
+type ConnectorRegistry = {
+    listAllConnectors(): ChannelConnectorView[];
+    createListener(channelName: string, connectorName: string): {
+        config: ConnectorConfig;
+        channelId: string;
+        listener: FunnelConnectorListener;
+    } | null;
+};
+type SupervisorNotify = (channelName: string, connectorName: string, content: string, meta?: Record<string, string>) => Promise<void>;
+type Deps = {
+    channels: ConnectorRegistry;
+    notify: SupervisorNotify;
+    logger?: FunnelLogger;
+    healthCheckIntervalMs?: number;
+    maxBackoffMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+};
+type ListenerEntryStatus = {
+    channelName: string;
+    channelId: string;
+    name: string;
+    type: ConnectorConfig["type"];
+    alive: boolean;
+    events: number;
+    errors: number;
+    failureCount: number;
+    lastEventAt: string | null;
+};
+/**
+ * Owns the running listener instances and their lifecycle.
+ *
+ * Lives in the gateway process and is the only place that calls
+ * `listener.start()` / `listener.stop()`. Each entry is keyed by
+ * `${channelName}/${connectorName}` so the same connector name can exist in
+ * multiple channels without colliding.
+ *
+ * Periodically polls each running listener's `isAlive()` and auto-restarts
+ * dead listeners with exponential backoff (1s, 2s, 4s, ... capped). Resets
+ * the backoff counter on successful restart.
+ */
+export declare class FunnelListenerSupervisor {
+    private readonly channels;
+    private readonly notify;
+    private readonly logger;
+    private readonly running;
+    private readonly failureCounts;
+    private readonly stats;
+    private readonly healthCheckIntervalMs;
+    private readonly maxBackoffMs;
+    private readonly sleep;
+    private readonly now;
+    private healthCheckTimer;
+    private healthCheckInFlight;
+    constructor(deps: Deps);
+    static keyOf(channelName: string, connectorName: string): string;
+    isRunning(channelName: string, connectorName: string): boolean;
+    list(): ListenerEntryStatus[];
+    start(channelName: string, connectorName: string): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    stop(channelName: string, connectorName: string): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    restart(channelName: string, connectorName: string): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    startAll(): Promise<void>;
+    stopAll(): Promise<void>;
+    private ensureStats;
+    private recordEvent;
+    private recordError;
+    private startHealthCheck;
+    private stopHealthCheck;
+    private runHealthCheck;
+    private recoverDead;
+}
+export {};

package/dist/gateway/listeners-client.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+type Deps = {
+    port: number;
+    isDaemonRunning: () => boolean;
+    /** Returns the daemon's gateway token, or null if unavailable. Sent as `Authorization: Bearer`. */
+    getToken?: () => string | null;
+};
+declare const listenerEntrySchema: z.ZodObject<{
+    channelName: z.ZodString;
+    channelId: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    alive: z.ZodBoolean;
+}, z.core.$strip>;
+export type ListenerEntry = z.infer<typeof listenerEntrySchema>;
+export type ListenerOpResult = {
+    state: "ok";
+} | {
+    state: "offline";
+} | {
+    state: "error";
+    reason: string;
+};
+export type ListListenersResult = {
+    state: "ok";
+    listeners: ListenerEntry[];
+} | {
+    state: "offline";
+} | {
+    state: "error";
+    reason: string;
+};
+/**
+ * HTTP client for listener operations on a running gateway daemon.
+ *
+ * Returns `{ state: "offline" }` when the daemon isn't running so callers
+ * (CLI hot-reload paths) can treat that as a no-op without parsing strings.
+ * Pair this with `FunnelGateway` (process control) for the full picture.
+ */
+export declare class FunnelListenersClient {
+    private readonly port;
+    private readonly isDaemonRunning;
+    private readonly getToken;
+    constructor(deps: Deps);
+    list(): Promise<ListListenersResult>;
+    start(channelName: string, connectorName: string): Promise<ListenerOpResult>;
+    stop(channelName: string, connectorName: string): Promise<ListenerOpResult>;
+    restart(channelName: string, connectorName: string): Promise<ListenerOpResult>;
+    private path;
+    private authHeaders;
+    private call;
+}
+export {};

package/dist/gateway/resolve-daemon-script.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Locate the daemon entry script. Works in both dev (running from source)
+ * and built mode (bundled into dist/bin.js with daemon at dist/gateway/daemon.js).
+ *
+ * The candidates cover:
+ *  1. dev: this helper lives at lib/gateway/, so daemon.ts is its sibling
+ *  2. built sibling: dist/gateway/daemon.js if the helper itself ends up at dist/gateway/
+ *  3. bundled: when this helper is inlined into dist/bin.js, import.meta.dir is dist/,
+ *     and daemon.js lives at dist/gateway/daemon.js
+ */
+export declare const resolveDaemonScript: () => string;

package/dist/gateway/routes/channels.connectors.call.d.ts

@@ -0,0 +1,41 @@
+/**
+ * POST /channels/:channel/connectors/:connector/call
+ *
+ * Generic adapter call. Used by the funnel MCP server (running in the Claude
+ * Code process) to send replies/reactions/etc. without spawning a CLI
+ * subprocess. Mirrors the CLI's `funnel channels <c> connectors <conn> request
+ * --method=...` but with a structured JSON body and no shell.
+ */
+export declare const channelsConnectorsCallHandler: [import("hono/types").H<import("hono").Env, string, {
+    in: {
+        param: {
+            channel: string;
+            connector: string;
+        };
+    };
+    out: {
+        param: {
+            channel: string;
+            connector: string;
+        };
+    };
+}, import("hono").TypedResponse<{
+    ok: boolean;
+    reason: string;
+}, 400, "json">>, import("hono/types").H<import("../factory").Env, string, {
+    in: {
+        param: {
+            channel: string;
+            connector: string;
+        };
+    };
+    out: {
+        param: {
+            channel: string;
+            connector: string;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    ok: true;
+    result: import("hono/utils/types").JSONValue;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];

package/dist/gateway/routes/health.d.ts

@@ -0,0 +1,17 @@
+/** GET /health — liveness + listener registry snapshot. */
+export declare const healthHandler: [import("hono/types").H<import("../factory").Env, string, {}, Response & import("hono").TypedResponse<{
+    ok: true;
+    pid: number;
+    clients: number;
+    listeners: {
+        channelName: string;
+        channelId: string;
+        name: string;
+        type: import("../..").ConnectorConfig["type"];
+        alive: boolean;
+        events: number;
+        errors: number;
+        failureCount: number;
+        lastEventAt: string | null;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>];