@interactive-inc/claude-funnel 0.8.1 → 0.10.0

package/dist/engine/settings/settings-schema.d.ts

@@ -1,132 +0,0 @@
-import { z } from "zod";
-/**
- * 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.
- */
-export declare const channelDeliveryModeSchema: z.ZodEnum<{
-    fanout: "fanout";
-    exclusive: "exclusive";
-}>;
-export type ChannelDeliveryMode = z.infer<typeof channelDeliveryModeSchema>;
-export 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.ZodString;
-        appToken: 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<"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.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>;
-export type ChannelConfig = z.infer<typeof channelConfigSchema>;
-export declare const profileConfigSchema: z.ZodObject<{
-    name: z.ZodString;
-    path: z.ZodString;
-    subAgent: z.ZodString;
-    channelId: z.ZodString;
-}, z.core.$strip>;
-export type ProfileConfig = z.infer<typeof profileConfigSchema>;
-export declare const SETTINGS_VERSION = 1;
-export 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.ZodString;
-            appToken: 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<"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.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<{
-        name: z.ZodString;
-        path: z.ZodString;
-        subAgent: z.ZodString;
-        channelId: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type Settings = z.infer<typeof settingsSchema>;

package/dist/engine/settings/settings-store.d.ts

@@ -1,18 +0,0 @@
-import { FunnelFileSystem } from "../fs/file-system";
-import { FunnelSettingsReader } from "./settings-reader";
-import type { Settings } from "./settings-schema";
-export declare const FUNNEL_DIR: string;
-export declare const SETTINGS_PATH: string;
-type Deps = {
-    path?: string;
-    fs?: FunnelFileSystem;
-};
-export declare class FunnelSettingsStore extends FunnelSettingsReader {
-    private readonly path;
-    private readonly fs;
-    constructor(deps?: Deps);
-    read(): Settings;
-    private looksLikeLegacy;
-    write(settings: Settings): void;
-}
-export {};

package/dist/engine/time/clock.d.ts

@@ -1,9 +0,0 @@
-/**
- * Time boundary. Default NodeFunnelClock returns `new Date()`; MemoryFunnelClock
- * is settable and `advance(ms)`-able for deterministic schedule / timeout tests.
- */
-export declare abstract class FunnelClock {
-    abstract now(): Date;
-    millis(): number;
-    iso(): string;
-}

package/dist/engine/time/memory-clock.d.ts

@@ -1,12 +0,0 @@
-import { FunnelClock } from "./clock";
-type Props = {
-    start?: Date;
-};
-export declare class MemoryFunnelClock extends FunnelClock {
-    private current;
-    constructor(props?: Props);
-    now(): Date;
-    set(date: Date): void;
-    advance(ms: number): void;
-}
-export {};

package/dist/engine/time/node-clock.d.ts

@@ -1,4 +0,0 @@
-import { FunnelClock } from "./clock";
-export declare class NodeFunnelClock extends FunnelClock {
-    now(): Date;
-}

package/dist/funnel.d.ts

@@ -1,95 +0,0 @@
-import { FunnelConnectorFactory } from "./connectors/connector-factory";
-import { FunnelChannels } from "./engine/channels/channels";
-import { FunnelClaude } from "./engine/claude/claude";
-import type { FunnelFileSystem } from "./engine/fs/file-system";
-import type { FunnelIdGenerator } from "./engine/id/id-generator";
-import { FunnelLogger } from "./engine/logger/logger";
-import { FunnelMcp } from "./engine/mcp/mcp";
-import { FunnelProcessRunner } from "./engine/process/process-runner";
-import { FunnelProfiles } from "./engine/profiles/profiles";
-import { FunnelSettingsReader } from "./engine/settings/settings-reader";
-import type { FunnelClock } from "./engine/time/clock";
-import { FunnelGateway } from "./gateway/gateway";
-import { FunnelGatewayServer } from "./gateway/gateway-server";
-import { FunnelGatewayToken } from "./gateway/gateway-token";
-import { FunnelListenersClient } from "./gateway/listeners-client";
-type Props = {
-    /** Settings persistence (channels with nested connectors / profiles). Defaults to a FunnelSettingsStore rooted at `dir`. */
-    store?: FunnelSettingsReader;
-    /** Filesystem boundary. Replace with MemoryFunnelFileSystem to sandbox all disk I/O. */
-    fs?: FunnelFileSystem;
-    /** Process runner used by gateway / claude / gh listener. Replace with MemoryFunnelProcessRunner for tests. */
-    process?: FunnelProcessRunner;
-    /** Logger flowed into every facet. Replace with MemoryFunnelLogger or NoopFunnelLogger to silence/inspect. */
-    logger?: FunnelLogger;
-    /** Clock used by schedule listener, gh poll watermarks, and gateway timeouts. */
-    clock?: FunnelClock;
-    /** ID generator for channel and connector ids. Use MemoryFunnelIdGenerator for deterministic tests. */
-    idGenerator?: FunnelIdGenerator;
-    /** Funnel home directory (settings.json + per-channel/per-connector dirs). Defaults to ~/.funnel. */
-    dir?: string;
-    /** Temp / runtime directory (gateway logs and PID adjacent files). Defaults to /tmp/funnel. */
-    tmpDir?: string;
-};
-/**
- * Facade exposing every funnel facet as a getter.
- *
- * The same `Funnel` is used by the CLI, the TUI, and as a programmable library.
- * All side-effecting boundaries (filesystem, process, logger, clock, id, paths) are
- * injectable via `Props` — passing memory implementations gives a fully sandboxed
- * Funnel that touches no real disk, processes, or wall-clock time.
- *
- * Connectors live nested inside their owning channel (channels[].connectors[]),
- * so connector CRUD is reached via `funnel.channels.addConnector(...)` etc.
- *
- * @example
- * ```ts
- * const funnel = new Funnel({})
- * const channel = funnel.channels.add({ name: "inbox" })
- * funnel.channels.addConnector("inbox", { type: "slack", name: "ops", botToken, appToken })
- * await funnel.gatewayServer({ port: 9742 }).start()
- * ```
- */
-export declare class Funnel {
-    private readonly props;
-    constructor(props?: Props);
-    /** Settings reader. If not injected, a FunnelSettingsStore rooted at `dir` is created. */
-    get store(): FunnelSettingsReader;
-    /** Process runner boundary. Defaults to NodeFunnelProcessRunner. */
-    get process(): FunnelProcessRunner;
-    /** Logger boundary. Defaults to NodeFunnelLogger. */
-    get logger(): FunnelLogger;
-    /** Pure factory that constructs per-type listeners and adapters from connector configs. */
-    get factory(): FunnelConnectorFactory;
-    /** Channel CRUD + nested connector CRUD + schedule entries + listener/adapter dispatch. */
-    get channels(): FunnelChannels;
-    /** Launch profiles (named presets for `fnl claude`: path + sub-agent + channel id). */
-    get profiles(): FunnelProfiles;
-    /** funnel MCP installer (writes/removes `.mcp.json` entries in target repos). */
-    get mcp(): FunnelMcp;
-    /** Launch Claude Code with a channel injected via env, MCP installed, gateway ensured. */
-    get claude(): FunnelClaude;
-    /** Gateway daemon controller (PID-file, start/stop the separate `bun daemon.ts` process). */
-    get gateway(): FunnelGateway;
-    /** Read / generate the daemon's gateway token (mode 0600 file under `dir`). */
-    get gatewayToken(): FunnelGatewayToken;
-    /**
-     * HTTP client for listener operations on the running gateway daemon.
-     * Returns `{ state: "offline" }` when the daemon is offline so hot-reload
-     * paths stay write-only without parsing strings.
-     */
-    get listeners(): FunnelListenersClient;
-    /**
-     * In-process gateway server. Unlike `gateway.start()` (which spawns a daemon),
-     * this returns a class that runs `Bun.serve` + listeners inside the current process —
-     * useful for tests, embedding, or custom hosts.
-     */
-    gatewayServer(options?: {
-        port?: number;
-        logDir?: string;
-        killCompetingSlack?: boolean;
-        /** Override the auth token. Defaults to the persisted gateway.token. Pass "" to disable auth (tests). */
-        token?: string;
-    }): FunnelGatewayServer;
-}
-export {};

package/dist/gateway/auth-middleware.d.ts

@@ -1,14 +0,0 @@
-import type { MiddlewareHandler } from "hono";
-import type { Env } from "./factory";
-type Deps = {
-    expected: string;
-};
-/**
- * Verifies `Authorization: Bearer <token>` against the daemon's gateway token.
- * Mounted on the routes that mutate listener state or expose detailed status.
- * `/health` is intentionally left unauthenticated so the daemon manager can
- * probe liveness without needing the token.
- */
-export declare const requireBearerToken: (deps: Deps) => MiddlewareHandler<Env>;
-export declare const constantTimeEqual: (a: string, b: string) => boolean;
-export {};

package/dist/gateway/broadcaster.d.ts

@@ -1,122 +0,0 @@
-import type { ServerWebSocket } from "bun";
-import { FunnelLogger } from "../engine/logger/logger";
-type ClientData = {
-    /** Stable channel id (uuid) that the WS client subscribed to. */
-    channel: string;
-    /** Human-facing channel name resolved at upgrade time, kept for log readability. */
-    channelName?: string | null;
-    /** Connector names belonging to that channel; used by tap-all replay filtering. */
-    connectors: string[];
-    tapAll?: boolean;
-    /** Routing mode resolved from channel config at upgrade time. Defaults to fanout. */
-    delivery?: "fanout" | "exclusive";
-};
-export type BroadcastEvent = {
-    content: string;
-    meta?: Record<string, string>;
-};
-export type ReplayableEvent = BroadcastEvent & {
-    offset: number;
-};
-export type BroadcastSubscriber = (event: ReplayableEvent) => void;
-/**
- * Optional persistent replay source. Wired in by the gateway-server with
- * `FunnelEventStore` (SQLite-backed) so reconnects across daemon restarts
- * can recover events older than the in-memory buffer via an indexed
- * `seq > since` range scan.
- */
-type ReplaySource = {
-    loadSince(since: number): ReplayableEvent[];
-};
-type Deps = {
-    logger?: FunnelLogger;
-    maxBufferedBytes?: number;
-    now?: () => number;
-    /** Number of recent events kept in the in-memory replay buffer. */
-    replayBufferSize?: number;
-    /** Hard byte cap on replay buffer payloads. Older events are evicted FIFO until under this cap. */
-    replayBufferMaxBytes?: number;
-    /** Persistent replay source consulted when the in-memory buffer cannot satisfy `since`. */
-    persistentReplay?: ReplaySource;
-};
-type BroadcasterMetrics = {
-    clients: number;
-    subscribers: number;
-    eventsBroadcast: number;
-    droppedSlowClients: number;
-    lastBroadcastAt: string | null;
-    /** Latest emitted offset. Clients can `?since=<offset>` to ask for events strictly after this point. */
-    latestOffset: number;
-    /** Oldest offset still held in the replay buffer. Older values cannot be replayed and trigger a full resync. */
-    oldestReplayableOffset: number | null;
-};
-/**
- * In-process pub/sub for connector events.
- *
- * Two outbound paths:
- *   - WS clients connected via the gateway's `/ws` endpoint, scoped per channel
- *   - In-process subscribers registered via `subscribe()` (programmable API)
- *
- * Backpressure: if a WS client's `bufferedAmount` exceeds `maxBufferedBytes`
- * (default 1 MiB), the client is closed with code 1009 and dropped from the
- * registry to keep one slow consumer from blocking the daemon.
- *
- * Replay: every emitted event gets a strictly increasing `offset`. The latest
- * `replayBufferSize` events are kept in memory; reconnecting WS clients can
- * pass `?since=<offset>` and the broadcaster resends matching events before
- * resuming the live stream. The in-memory ring covers short reconnects;
- * older history is served from the SQLite event store wired in as
- * `persistentReplay`.
- */
-export declare class FunnelBroadcaster {
-    private readonly clients;
-    private readonly subscribers;
-    private readonly logger;
-    private readonly maxBufferedBytes;
-    private readonly now;
-    private readonly replayBufferSize;
-    private readonly replayBufferMaxBytes;
-    private readonly replayBuffer;
-    private readonly persistentReplay;
-    private readonly exclusiveCursor;
-    private replayBufferBytes;
-    private eventsBroadcast;
-    private droppedSlowClients;
-    private lastBroadcastAt;
-    private latestOffset;
-    constructor(deps?: Deps);
-    getMetrics(): BroadcasterMetrics;
-    /**
-     * Returns events with offset > since, filtered by the connector subscription
-     * rules of `data`. Used at WS upgrade time when the client passes `?since=<offset>`.
-     *
-     * Two-tier lookup:
-     *   1. The in-memory ring buffer (covers short reconnects, last `replayBufferSize` events).
-     *   2. If `since` predates the oldest in-memory entry and a persistent replay source
-     *      is wired in (SQLite), the gap is filled from disk. This covers reconnects across
-     *      daemon restarts where the in-memory buffer was lost.
-     *
-     * Result is sorted ascending by offset and de-duplicated against the in-memory buffer.
-     */
-    replaySince(since: number, data: ClientData): ReplayableEvent[];
-    private matchesClient;
-    /**
-     * Returns the list of WS clients that should receive `event`. Tap=all clients always
-     * receive (passive observation). For each per-channel group:
-     *   - fanout → every matching client receives
-     *   - exclusive → exactly one client receives, picked round-robin per channel
-     */
-    private pickRecipients;
-    addClient(ws: ServerWebSocket<unknown>, data: ClientData): void;
-    removeClient(ws: ServerWebSocket<unknown>): void;
-    getClientCount(): number;
-    listChannels(): {
-        channel: string;
-        connectors: string[];
-    }[];
-    subscribe(handler: BroadcastSubscriber): () => void;
-    broadcast(content: string, meta?: Record<string, string>): ReplayableEvent;
-    /** Forward-seed the offset counter (used at startup from the persisted event store). */
-    seedLatestOffset(offset: number): void;
-}
-export {};

package/dist/gateway/daemon.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};

package/dist/gateway/factory.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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 {};