@interactive-inc/claude-funnel 0.10.0 → 0.10.1

package/lib/gateway/gateway-server.ts

@@ -1,426 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs"
-import { join } from "node:path"
-import { type Server, type ServerWebSocket } from "bun"
-import type { Hono } from "hono"
-import type { FunnelChannels } from "@/engine/channels/channels"
-import { constantTimeEqual, requireBearerToken } from "@/gateway/auth-middleware"
-import { type Env, factory } from "@/gateway/factory"
-import { FunnelBroadcaster } from "@/gateway/broadcaster"
-import { FunnelEventStore } from "@/gateway/funnel-event-store"
-import { FunnelListenerSupervisor } from "@/gateway/listener-supervisor"
-import { killCompetingSlackGateways } from "@/gateway/kill-competing-slack-gateways"
-import { gatewayRoutes } from "@/gateway/routes"
-import { FunnelLogger } from "@/engine/logger/logger"
-import { NodeFunnelLogger } from "@/engine/logger/node-logger"
-import type { FunnelProcessRunner } from "@/engine/process/process-runner"
-import type { FunnelSettingsReader } from "@/engine/settings/settings-reader"
-import type { FunnelClock } from "@/engine/time/clock"
-
-const DEFAULT_PORT = 9742
-const DEFAULT_LOG_DIR = "/tmp/funnel/events"
-const DB_FILENAME = "events.db"
-
-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
-}
-
-const defaultLogger = new NodeFunnelLogger()
-
-/**
- * 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 class FunnelGatewayServer {
-  private readonly channels: FunnelChannels
-  private readonly settings: FunnelSettingsReader
-  private readonly port: number
-  private readonly logDir: string
-  private readonly process?: FunnelProcessRunner
-  private readonly logger: FunnelLogger
-  private readonly selfPid: number
-  private readonly killCompetingSlack: boolean
-  private readonly token: string
-  private readonly broadcaster: FunnelBroadcaster
-  private readonly eventStore: FunnelEventStore
-  private readonly supervisor: FunnelListenerSupervisor
-  private readonly nowMs: () => number
-  private startedAt: number | null = null
-  private server: Server<WsData> | null = null
-
-  constructor(deps: Deps) {
-    this.channels = deps.channels
-    this.settings = deps.settings
-    this.port = deps.port ?? DEFAULT_PORT
-    this.logDir = deps.logDir ?? DEFAULT_LOG_DIR
-    this.process = deps.process
-    this.logger = deps.logger ?? defaultLogger
-    this.selfPid = deps.selfPid ?? globalThis.process.pid
-    this.killCompetingSlack = deps.killCompetingSlack ?? true
-    this.token = deps.token ?? ""
-    const clock = deps.clock
-    this.nowMs = clock ? () => clock.millis() : () => Date.now()
-    if (!existsSync(this.logDir)) mkdirSync(this.logDir, { recursive: true })
-    this.eventStore = new FunnelEventStore({
-      path: join(this.logDir, DB_FILENAME),
-      now: this.nowMs,
-    })
-    this.broadcaster = new FunnelBroadcaster({
-      logger: this.logger,
-      now: this.nowMs,
-      persistentReplay: this.eventStore,
-    })
-    this.broadcaster.seedLatestOffset(this.eventStore.findMaxOffset())
-    this.supervisor = new FunnelListenerSupervisor({
-      channels: this.channels,
-      logger: this.logger,
-      notify: async (channelName, connectorName, content, meta) => {
-        this.emit({ channel: channelName, connector: connectorName, content, meta })
-      },
-      now: this.nowMs,
-    })
-  }
-
-  async start(): Promise<Server<WsData>> {
-    if (this.server) return this.server
-
-    const app = this.buildApp()
-
-    this.startedAt = this.nowMs()
-    this.server = Bun.serve<WsData>({
-      port: this.port,
-      development: false,
-      fetch: (request, server) => this.handleFetch(request, server, app),
-      websocket: {
-        open: (ws) => this.handleWsOpen(ws),
-        close: (ws) => this.handleWsClose(ws),
-        message() {
-          // required by Bun's websocket interface; no client → gateway messages today
-        },
-      },
-    })
-
-    this.logServerStarted()
-    await this.bootListeners()
-
-    return this.server
-  }
-
-  async stop(): Promise<void> {
-    await this.supervisor.stopAll()
-
-    if (this.server) {
-      this.server.stop()
-      this.server = null
-    }
-  }
-
-  getStatus(): { clients: number; channels: { channel: string; connectors: string[] }[] } {
-    return {
-      clients: this.broadcaster.getClientCount(),
-      channels: this.broadcaster.listChannels(),
-    }
-  }
-
-  getBroadcaster(): FunnelBroadcaster {
-    return this.broadcaster
-  }
-
-  getSupervisor(): FunnelListenerSupervisor {
-    return this.supervisor
-  }
-
-  getEventStore(): FunnelEventStore {
-    return this.eventStore
-  }
-
-  private handleFetch(
-    request: Request,
-    server: Server<WsData>,
-    app: Hono<Env>,
-  ): Response | Promise<Response> | undefined {
-    const url = new URL(request.url)
-
-    if (url.pathname === "/ws" && request.headers.get("upgrade") === "websocket") {
-      if (this.token && !this.tokenMatchesUpgrade(request)) {
-        return new Response("unauthorized", { status: 401 })
-      }
-
-      const tapAll = url.searchParams.get("tap") === "all"
-      const requestedChannel = tapAll ? "" : (url.searchParams.get("channel") ?? "")
-      const channel = !tapAll && requestedChannel ? this.resolveChannel(requestedChannel) : null
-      const channelId = tapAll ? "" : (channel?.id ?? requestedChannel)
-      const channelName = tapAll ? null : (channel?.name ?? null)
-      const connectors = channel?.connectors ?? []
-      const delivery = channel?.delivery ?? "fanout"
-      const sinceRaw = url.searchParams.get("since")
-      const sinceParsed = sinceRaw === null ? Number.NaN : Number.parseInt(sinceRaw, 10)
-      const since = Number.isFinite(sinceParsed) && sinceParsed >= 0 ? sinceParsed : undefined
-      const upgraded = server.upgrade(request, {
-        data: {
-          channel: channelId,
-          channelName,
-          connectors,
-          tapAll,
-          delivery,
-          since,
-        },
-      })
-
-      if (upgraded) return undefined
-
-      return new Response("WebSocket upgrade failed", { status: 400 })
-    }
-
-    return app.fetch(request)
-  }
-
-  private handleWsOpen(ws: ServerWebSocket<WsData>): void {
-    if (typeof ws.data.since === "number") {
-      const replay = this.broadcaster.replaySince(ws.data.since, ws.data)
-
-      for (const event of replay) ws.send(JSON.stringify(event))
-    }
-
-    this.broadcaster.addClient(ws, ws.data)
-
-    if (ws.data.channelName) {
-      const meta: Record<string, string> = {
-        event_type: "system",
-        action: "channel_connect",
-        channel: ws.data.channelName,
-        channelId: ws.data.channel,
-        connectors: ws.data.connectors.join(","),
-        total: String(this.broadcaster.getClientCount()),
-      }
-
-      this.logger.info("channel connected", meta)
-    } else {
-      this.logger.info("tap-all client connected", {
-        event_type: "system",
-        action: "tap_connect",
-        total: String(this.broadcaster.getClientCount()),
-      })
-    }
-  }
-
-  private handleWsClose(ws: ServerWebSocket<WsData>): void {
-    this.broadcaster.removeClient(ws)
-
-    if (ws.data.channelName) {
-      this.logger.info("channel disconnected", {
-        event_type: "system",
-        action: "channel_disconnect",
-        channel: ws.data.channelName,
-        channelId: ws.data.channel,
-        total: String(this.broadcaster.getClientCount()),
-      })
-    } else {
-      this.logger.info("tap-all client disconnected", {
-        event_type: "system",
-        action: "tap_disconnect",
-        total: String(this.broadcaster.getClientCount()),
-      })
-    }
-  }
-
-  private logServerStarted(): void {
-    this.logger.info("gateway started", {
-      event_type: "system",
-      action: "gateway_start",
-      port: String(this.port),
-      pid: String(this.selfPid),
-    })
-
-    this.logger.info("funnel gateway listening", {
-      url: `http://localhost:${this.port}`,
-      websocket: `ws://localhost:${this.port}/ws`,
-      health: `http://localhost:${this.port}/health`,
-    })
-  }
-
-  private buildApp(): Hono<Env> {
-    const base = factory.createApp()
-
-    base.use((c, next) => {
-      c.set("deps", {
-        selfPid: this.selfPid,
-        broadcaster: this.broadcaster,
-        supervisor: this.supervisor,
-        channels: this.channels,
-        uptimeMs: () => (this.startedAt ? this.nowMs() - this.startedAt : 0),
-        emit: (input) => this.emit(input),
-      })
-
-      return next()
-    })
-
-    if (this.token) {
-      base.use("/listeners/*", requireBearerToken({ expected: this.token }))
-      base.use("/status", requireBearerToken({ expected: this.token }))
-      base.use("/channels/*", requireBearerToken({ expected: this.token }))
-    }
-
-    return base.route("/", gatewayRoutes)
-  }
-
-  /**
-   * 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(request: Request): boolean {
-    const protocols = (request.headers.get("sec-websocket-protocol") ?? "")
-      .split(",")
-      .map((p) => p.trim())
-      .filter((p) => p.length > 0)
-
-    for (const proto of protocols) {
-      if (
-        proto.startsWith("funnel.token.") &&
-        constantTimeEqual(proto.slice("funnel.token.".length), this.token)
-      ) {
-        return true
-      }
-    }
-
-    const auth = request.headers.get("authorization") ?? ""
-    const match = auth.match(/^Bearer\s+(.+)$/i)
-
-    if (match && constantTimeEqual(match[1] ?? "", this.token)) return true
-
-    return false
-  }
-
-  private resolveChannel(
-    requested: string,
-  ): { id: string; name: string; connectors: string[]; delivery: "fanout" | "exclusive" } | null {
-    const settings = this.settings.read()
-    const channel = settings?.channels.find((c) => c.id === requested || c.name === requested)
-
-    if (!channel) return null
-
-    return {
-      id: channel.id,
-      name: channel.name,
-      connectors: channel.connectors.map((c) => c.name),
-      delivery: channel.delivery,
-    }
-  }
-
-  private async bootListeners(): Promise<void> {
-    const allConnectors = this.channels.listAllConnectors()
-
-    if (this.killCompetingSlack && allConnectors.some((c) => c.type === "slack")) {
-      const killed = await killCompetingSlackGateways({
-        selfPid: this.selfPid,
-        process: this.process,
-        logger: this.logger,
-      })
-
-      if (killed.length > 0) {
-        this.logger.info("killed competing Slack gateway processes", {
-          event_type: "system",
-          action: "kill_competing",
-          pids: killed.join(","),
-        })
-      }
-    }
-
-    await this.supervisor.startAll()
-
-    for (const entry of this.supervisor.list()) {
-      this.logger.info(`${entry.type} listener started: ${entry.name}`, {
-        event_type: "system",
-        action: `${entry.type}_connect`,
-        channel: entry.channelName,
-        connector: entry.name,
-      })
-    }
-
-    this.logger.info(`event store: ${join(this.logDir, DB_FILENAME)}`)
-    this.logger.info("funnel gateway running")
-  }
-
-  /**
-   * Broadcast `content` to subscribers of `channel`, persisting the event in
-   * the SQLite store and stamping `meta.channel{,Id}` / `meta.connector{,Id}`
-   * when they resolve. Used by both the connector-listener path (via the
-   * supervisor's `notify` callback) and the public `/channels/:channel/publish`
-   * route. Returns the assigned event offset.
-   */
-  emit(input: {
-    channel: string
-    connector?: string
-    content: string
-    meta?: Record<string, string>
-  }): { offset: number } {
-    const channelId = this.lookupChannelId(input.channel)
-    const connectorId =
-      channelId && input.connector ? this.lookupConnectorId(channelId, input.connector) : null
-    const enriched: Record<string, string> = {
-      ...input.meta,
-      channel: input.channel,
-    }
-
-    if (input.connector) enriched.connector = input.connector
-    if (channelId) enriched.channelId = channelId
-    if (connectorId) enriched.connectorId = connectorId
-
-    const event = this.broadcaster.broadcast(input.content, enriched)
-
-    this.eventStore.record({
-      content: input.content,
-      channelId: channelId ?? null,
-      connectorId: connectorId ?? null,
-      meta: enriched,
-      offset: event.offset,
-    })
-
-    return { offset: event.offset }
-  }
-
-  private lookupChannelId(channelName: string): string | null {
-    const channel = this.settings.read().channels.find((c) => c.name === channelName)
-
-    return channel?.id ?? null
-  }
-
-  private lookupConnectorId(channelId: string, connectorName: string): string | null {
-    const channel = this.settings.read().channels.find((c) => c.id === channelId)
-    const connector = channel?.connectors.find((c) => c.name === connectorName)
-
-    return connector?.id ?? null
-  }
-}

package/lib/gateway/gateway-token.ts

@@ -1,79 +0,0 @@
-import { homedir } from "node:os"
-import { dirname, join } from "node:path"
-import { FunnelFileSystem } from "@/engine/fs/file-system"
-import { NodeFunnelFileSystem } from "@/engine/fs/node-file-system"
-import { FUNNEL_DIR } from "@/engine/settings/settings-store"
-
-const TOKEN_FILE_NAME = "gateway.token"
-const TOKEN_BYTES = 32
-
-type Deps = {
-  fs?: FunnelFileSystem
-  dir?: string
-  generate?: () => string
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-
-const defaultGenerate = (): string => {
-  const buf = new Uint8Array(TOKEN_BYTES)
-  crypto.getRandomValues(buf)
-
-  return [...buf].map((b) => b.toString(16).padStart(2, "0")).join("")
-}
-
-/**
- * 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 class FunnelGatewayToken {
-  private readonly fs: FunnelFileSystem
-  private readonly path: string
-  private readonly generate: () => string
-
-  constructor(deps: Deps = {}) {
-    this.fs = deps.fs ?? defaultFs
-    this.path = join(deps.dir ?? FUNNEL_DIR, TOKEN_FILE_NAME)
-    this.generate = deps.generate ?? defaultGenerate
-    Object.freeze(this)
-  }
-
-  read(): string | null {
-    if (!this.fs.existsSync(this.path)) return null
-
-    const value = this.fs.readFileSync(this.path).trim()
-
-    return value.length > 0 ? value : 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 {
-    const existing = this.read()
-
-    if (existing) return existing
-
-    const token = this.generate()
-
-    this.fs.mkdirSync(dirname(this.path), { recursive: true })
-    this.fs.writeSecretFileSync(this.path, `${token}\n`)
-
-    return token
-  }
-
-  getPath(): string {
-    return this.path
-  }
-}
-
-export const DEFAULT_GATEWAY_TOKEN_PATH = join(homedir(), ".funnel", TOKEN_FILE_NAME)

package/lib/gateway/gateway.ts

@@ -1,209 +0,0 @@
-import { join } from "node:path"
-import { FunnelFileSystem } from "@/engine/fs/file-system"
-import { resolveDaemonScript } from "@/gateway/resolve-daemon-script"
-import { NodeFunnelFileSystem } from "@/engine/fs/node-file-system"
-import { FunnelProcessRunner } from "@/engine/process/process-runner"
-import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
-import { FUNNEL_DIR } from "@/engine/settings/settings-store"
-import { FunnelClock } from "@/engine/time/clock"
-import { NodeFunnelClock } from "@/engine/time/node-clock"
-
-const DEFAULT_PORT = 9742
-const DEFAULT_TMP_DIR = "/tmp/funnel"
-const STARTUP_TIMEOUT_MS = 5000
-const SIGTERM_TIMEOUT_MS = 2000
-const POLL_INTERVAL_MS = 100
-const SIGKILL_GRACE_MS = 200
-
-type Deps = {
-  process?: FunnelProcessRunner
-  fs?: FunnelFileSystem
-  clock?: FunnelClock
-  dir?: string
-  tmpDir?: string
-  port?: number
-  sleep?: (ms: number) => Promise<void>
-}
-
-const defaultProcess = new NodeFunnelProcessRunner()
-const defaultFs = new NodeFunnelFileSystem()
-const defaultClock = new NodeFunnelClock()
-const defaultSleep = (ms: number): Promise<void> =>
-  new Promise((r) => {
-    setTimeout(r, ms)
-  })
-
-/**
- * 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 class FunnelGateway {
-  private readonly process: FunnelProcessRunner
-  private readonly fs: FunnelFileSystem
-  private readonly clock: FunnelClock
-  private readonly pidFile: string
-  private readonly logDir: string
-  private readonly gatewayLog: string
-  private readonly tmpDir: string
-  private readonly port: number
-  private readonly sleep: (ms: number) => Promise<void>
-
-  constructor(deps: Deps = {}) {
-    this.process = deps.process ?? defaultProcess
-    this.fs = deps.fs ?? defaultFs
-    this.clock = deps.clock ?? defaultClock
-    const baseDir = deps.dir ?? FUNNEL_DIR
-    this.tmpDir = deps.tmpDir ?? DEFAULT_TMP_DIR
-    this.pidFile = join(baseDir, "gateway.pid")
-    this.logDir = join(this.tmpDir, "events")
-    this.gatewayLog = join(this.tmpDir, "gateway.log")
-    this.port = deps.port ?? DEFAULT_PORT
-    this.sleep = deps.sleep ?? defaultSleep
-    Object.freeze(this)
-  }
-
-  isRunning(): boolean {
-    const pid = this.readPid()
-
-    if (!pid) return false
-
-    return this.isProcessAlive(pid)
-  }
-
-  getStatus(): { running: boolean; pid: number | null; port: number } {
-    const pid = this.readPid()
-    const running = pid !== null && this.isProcessAlive(pid)
-
-    return { running, pid: running ? pid : null, port: this.port }
-  }
-
-  async start(options: { caffeinate?: boolean } = {}): Promise<boolean> {
-    if (this.isRunning()) return true
-
-    this.fs.mkdirSync(this.tmpDir, { recursive: true })
-
-    const gatewayScript = resolveDaemonScript()
-    const command = this.buildStartCommand(gatewayScript, options)
-
-    this.process.detach(["bash", "-c", command])
-
-    const deadline = Date.now() + STARTUP_TIMEOUT_MS
-
-    while (Date.now() < deadline) {
-      if (this.isRunning()) return true
-      await this.sleep(POLL_INTERVAL_MS)
-    }
-
-    return this.isRunning()
-  }
-
-  buildStartCommand(gatewayScript: string, options: { caffeinate?: boolean } = {}): string {
-    const useCaffeinate = options.caffeinate !== false && globalThis.process.platform === "darwin"
-    const prefix = useCaffeinate ? "caffeinate -i " : ""
-
-    return `nohup ${prefix}bun ${gatewayScript} >> ${this.gatewayLog} 2>&1 &`
-  }
-
-  async stop(): Promise<boolean> {
-    const pid = this.readPid()
-
-    if (!pid) return true
-
-    if (!this.isProcessAlive(pid)) {
-      this.removePid()
-      return true
-    }
-
-    try {
-      this.process.kill(pid, "SIGTERM")
-    } catch {
-      return false
-    }
-
-    const deadline = this.clock.millis() + SIGTERM_TIMEOUT_MS
-
-    while (this.clock.millis() < deadline) {
-      if (!this.isProcessAlive(pid)) {
-        this.removePid()
-        return true
-      }
-
-      await this.sleep(POLL_INTERVAL_MS)
-    }
-
-    try {
-      this.process.kill(pid, "SIGKILL")
-    } catch {
-      // ignore
-    }
-
-    await this.sleep(SIGKILL_GRACE_MS)
-    this.removePid()
-
-    return !this.isProcessAlive(pid)
-  }
-
-  async restart(
-    options: { onlyIfRunning?: boolean; caffeinate?: boolean } = {},
-  ): Promise<{ ok: boolean; wasRunning: boolean; stopped: boolean; started: boolean }> {
-    const wasRunning = this.isRunning()
-
-    if (options.onlyIfRunning && !wasRunning) {
-      return { ok: true, wasRunning: false, stopped: false, started: false }
-    }
-
-    const stopped = wasRunning ? await this.stop() : true
-
-    if (!stopped) {
-      return { ok: false, wasRunning, stopped: false, started: false }
-    }
-
-    const started = await this.start({ caffeinate: options.caffeinate })
-
-    return { ok: started, wasRunning, stopped, started }
-  }
-
-  getLogDir(): string {
-    return this.logDir
-  }
-
-  getGatewayLog(): string {
-    return this.gatewayLog
-  }
-
-  getPort(): number {
-    return this.port
-  }
-
-  private readPid(): number | null {
-    if (!this.fs.existsSync(this.pidFile)) return null
-
-    try {
-      const content = this.fs.readFileSync(this.pidFile).trim()
-      const pid = Number(content)
-
-      if (!pid || pid <= 0) return null
-
-      return pid
-    } catch {
-      return null
-    }
-  }
-
-  private removePid(): void {
-    this.fs.unlink(this.pidFile)
-  }
-
-  private isProcessAlive(pid: number): boolean {
-    const result = this.process.runSync(["ps", "-p", String(pid), "-o", "state="])
-
-    if (result.exitCode !== 0) return false
-
-    const state = result.stdout.trim()
-
-    if (!state) return false
-
-    return !state.startsWith("Z")
-  }
-}