@interactive-inc/claude-funnel 0.10.0 → 0.15.1

package/lib/gateway/routes/index.ts

@@ -1,26 +0,0 @@
-import { factory } from "@/gateway/factory"
-import { channelsConnectorsCallHandler } from "@/gateway/routes/channels.connectors.call"
-import { channelsPublishHandler } from "@/gateway/routes/channels.publish"
-import { healthHandler } from "@/gateway/routes/health"
-import { listenersListHandler } from "@/gateway/routes/listeners.list"
-import { listenersRestartHandler } from "@/gateway/routes/listeners.restart"
-import { listenersStartHandler } from "@/gateway/routes/listeners.start"
-import { listenersStopHandler } from "@/gateway/routes/listeners.stop"
-import { statusHandler } from "@/gateway/routes/status"
-
-/**
- * Top-level Hono app for the gateway daemon. Mounts every HTTP endpoint flat
- * (the WebSocket /ws upgrade is handled directly by `Bun.serve`). Deps come
- * from the `deps` variable set by `FunnelGatewayServer`'s middleware — same
- * shape as CLI's `c.var.funnel`.
- */
-export const gatewayRoutes = factory
-  .createApp()
-  .get("/health", ...healthHandler)
-  .get("/status", ...statusHandler)
-  .get("/listeners", ...listenersListHandler)
-  .post("/listeners/:channel/:connector/start", ...listenersStartHandler)
-  .delete("/listeners/:channel/:connector", ...listenersStopHandler)
-  .post("/listeners/:channel/:connector/restart", ...listenersRestartHandler)
-  .post("/channels/:channel/connectors/:connector/call", ...channelsConnectorsCallHandler)
-  .post("/channels/:channel/publish", ...channelsPublishHandler)

package/lib/gateway/routes/listeners.list.ts

@@ -1,6 +0,0 @@
-import { factory } from "@/gateway/factory"
-
-/** GET /listeners — running connector listeners with alive/dead status. */
-export const listenersListHandler = factory.createHandlers((c) => {
-  return c.json({ listeners: c.var.deps.supervisor.list() })
-})

package/lib/gateway/routes/listeners.restart.ts

@@ -1,15 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/gateway/factory"
-import { zParam } from "@/gateway/routes/validator"
-
-/** POST /listeners/:channel/:connector/restart — stop + start a connector listener. */
-export const listenersRestartHandler = factory.createHandlers(
-  zParam(z.object({ channel: z.string().min(1), connector: z.string().min(1) })),
-  async (c) => {
-    const param = c.req.valid("param")
-
-    const result = await c.var.deps.supervisor.restart(param.channel, param.connector)
-
-    return c.json(result, result.ok ? 200 : 400)
-  },
-)

package/lib/gateway/routes/listeners.start.ts

@@ -1,15 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/gateway/factory"
-import { zParam } from "@/gateway/routes/validator"
-
-/** POST /listeners/:channel/:connector/start — start a connector listener. */
-export const listenersStartHandler = factory.createHandlers(
-  zParam(z.object({ channel: z.string().min(1), connector: z.string().min(1) })),
-  async (c) => {
-    const param = c.req.valid("param")
-
-    const result = await c.var.deps.supervisor.start(param.channel, param.connector)
-
-    return c.json(result, result.ok ? 200 : 400)
-  },
-)

package/lib/gateway/routes/listeners.stop.ts

@@ -1,15 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/gateway/factory"
-import { zParam } from "@/gateway/routes/validator"
-
-/** DELETE /listeners/:channel/:connector — stop a connector listener. */
-export const listenersStopHandler = factory.createHandlers(
-  zParam(z.object({ channel: z.string().min(1), connector: z.string().min(1) })),
-  async (c) => {
-    const param = c.req.valid("param")
-
-    const result = await c.var.deps.supervisor.stop(param.channel, param.connector)
-
-    return c.json(result, result.ok ? 200 : 400)
-  },
-)

package/lib/gateway/routes/route-deps.ts

@@ -1,19 +0,0 @@
-import type { FunnelChannels } from "@/engine/channels/channels"
-import type { FunnelBroadcaster } from "@/gateway/broadcaster"
-import type { FunnelListenerSupervisor } from "@/gateway/listener-supervisor"
-
-export type GatewayEmitInput = {
-  channel: string
-  connector?: string
-  content: string
-  meta?: Record<string, string>
-}
-
-export type GatewayRouteDeps = {
-  selfPid: number
-  broadcaster: FunnelBroadcaster
-  supervisor: FunnelListenerSupervisor
-  channels: FunnelChannels
-  uptimeMs: () => number
-  emit: (input: GatewayEmitInput) => { offset: number }
-}

package/lib/gateway/routes/status.ts

@@ -1,15 +0,0 @@
-import { factory } from "@/gateway/factory"
-
-/** GET /status — listener registry, connected channels, and broadcaster metrics. */
-export const statusHandler = factory.createHandlers((c) => {
-  const deps = c.var.deps
-
-  return c.json({
-    ok: true,
-    pid: deps.selfPid,
-    uptimeMs: deps.uptimeMs(),
-    clients: deps.broadcaster.listChannels(),
-    listeners: deps.supervisor.list(),
-    broadcaster: deps.broadcaster.getMetrics(),
-  })
-})

package/lib/gateway/routes/validator.ts

@@ -1,17 +0,0 @@
-import { zValidator } from "@hono/zod-validator"
-import type { ZodType } from "zod"
-
-/**
- * Path-param validator for gateway routes. On failure it answers with the same
- * `{ ok: false, reason }` shape the listener routes already use, so
- * `FunnelListenersClient` can surface the message without special-casing.
- */
-export const zParam = <T extends ZodType>(schema: T) =>
-  zValidator("param", schema, (result, c) => {
-    if (result.success) return
-
-    const issue = result.error.issues[0]
-    const reason = issue ? `${issue.path.join(".")}: ${issue.message}` : "invalid request"
-
-    return c.json({ ok: false, reason }, 400)
-  })

package/lib/index.ts

@@ -1,67 +0,0 @@
-// Public API surface for the @interactive-inc/claude-funnel package.
-// Organized by layer so consumers can find what they need at a glance.
-
-// Facade
-export * from "@/funnel"
-
-// Engine — domain
-export * from "@/engine/channels/channels"
-export * from "@/engine/claude/claude"
-export * from "@/engine/mcp/mcp"
-export * from "@/engine/mcp/channel-server"
-export * from "@/engine/profiles/profiles"
-export * from "@/engine/settings/settings-reader"
-export * from "@/engine/settings/settings-store"
-export * from "@/engine/settings/mock-settings-reader"
-export * from "@/engine/settings/settings-schema"
-
-// Engine — boundaries (abstract + Node / Memory implementations)
-export * from "@/engine/fs/file-system"
-export * from "@/engine/fs/node-file-system"
-export * from "@/engine/fs/memory-file-system"
-
-export * from "@/engine/process/process-runner"
-export * from "@/engine/process/node-process-runner"
-export * from "@/engine/process/memory-process-runner"
-
-export * from "@/engine/logger/logger"
-export * from "@/engine/logger/node-logger"
-export * from "@/engine/logger/memory-logger"
-export * from "@/engine/logger/noop-logger"
-
-export * from "@/engine/time/clock"
-export * from "@/engine/time/node-clock"
-export * from "@/engine/time/memory-clock"
-
-export * from "@/engine/id/id-generator"
-export * from "@/engine/id/node-id-generator"
-export * from "@/engine/id/memory-id-generator"
-
-// Connectors
-export * from "@/connectors/connector-factory"
-export * from "@/connectors/connector-config-schema"
-export * from "@/connectors/connector-listener"
-export * from "@/connectors/discord-connector-schema"
-export * from "@/connectors/gh-connector-schema"
-export * from "@/connectors/schedule-connector-schema"
-export * from "@/connectors/slack-connector-schema"
-
-// Gateway
-export * from "@/gateway/gateway"
-export * from "@/gateway/gateway-server"
-export * from "@/gateway/gateway-token"
-export * from "@/gateway/broadcaster"
-export * from "@/gateway/channel-publisher"
-export * from "@/gateway/funnel-event-store"
-export * from "@/gateway/listener-supervisor"
-export * from "@/gateway/listeners-client"
-export * from "@/gateway/publish-schema"
-
-// CLI — embeddable Hono app + argv translator
-export * from "@/cli/factory"
-export * from "@/cli/router/to-request"
-export * from "@/cli/router/query-to-cli-args"
-export { app as cliApp, createCliApp } from "@/cli/routes"
-
-// TUI — launcher (consumers can spawn the OpenTUI dashboard with their own Funnel)
-export * from "@/tui/tui"

package/lib/logger/leuco-human-file-writer.ts

@@ -1,65 +0,0 @@
-import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync } from "node:fs"
-import { dirname } from "node:path"
-import type { LeucoHumanRecord } from "@/logger/leuco-human-record"
-import type { LeucoHumanWriter } from "@/logger/leuco-human-writer"
-
-type Props = {
-  /** Filesystem path. Parent directory is created on construct. */
-  path: string
-  /**
-   * Optional size cap in bytes. When the next write would push the file
-   * over the cap, the existing file becomes `<path>.1` (replacing any
-   * prior `.1`) and a fresh file takes its place. Single-keep rotation —
-   * a second cycle drops the previous `.1`.
-   */
-  maxBytes?: number
-}
-
-/**
- * Appends one JSON line per record to a file. Optional one-keep size
- * rotation. Designed for diagnostic logs a human tails (`tail -f file |
- * jq`); not for replay or queries — use `LeucoLoggerSqliteSink` if you
- * need indexed lookups.
- *
- * Writes are synchronous (`appendFileSync`), so each line is durable
- * before `write` returns. Throughput matches the OS file cache; for
- * high-volume logging consider buffering at the call site or using a
- * different writer.
- */
-export class LeucoHumanFileWriter implements LeucoHumanWriter {
-  private readonly path: string
-  private readonly maxBytes: number | null
-
-  constructor(props: Props) {
-    this.path = props.path
-    this.maxBytes = props.maxBytes ?? null
-    this.ensureDir()
-  }
-
-  write(record: LeucoHumanRecord): void | Error {
-    try {
-      const line = `${JSON.stringify(record)}\n`
-      this.rotateIfNeeded(Buffer.byteLength(line))
-      appendFileSync(this.path, line)
-    } catch (e) {
-      return e instanceof Error ? e : new Error(String(e))
-    }
-  }
-
-  private ensureDir(): void {
-    const dir = dirname(this.path)
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
-  }
-
-  private rotateIfNeeded(incomingBytes: number): void {
-    if (this.maxBytes === null) return
-    if (!existsSync(this.path)) return
-
-    const size = statSync(this.path).size
-    if (size + incomingBytes <= this.maxBytes) return
-
-    const backup = `${this.path}.1`
-    if (existsSync(backup)) unlinkSync(backup)
-    renameSync(this.path, backup)
-  }
-}

package/lib/logger/leuco-human-logger.ts

@@ -1,98 +0,0 @@
-import type { LeucoHumanLevel, LeucoHumanRecord } from "@/logger/leuco-human-record"
-import type { LeucoHumanWriter } from "@/logger/leuco-human-writer"
-
-type WriteErrorHandler = (error: Error, record: LeucoHumanRecord) => void
-
-type Props = {
-  /** Where records go. Use `LeucoHumanStdoutWriter`, `LeucoHumanFileWriter`, or your own. */
-  writer: LeucoHumanWriter
-  /** Minimum level to emit. Lower-rank records are dropped. Default: "info". */
-  level?: LeucoHumanLevel
-  /** Override for tests. Defaults to `Date.now`. */
-  now?: () => number
-  /** Observer for writer failures. Default: silently swallow. */
-  onWriteError?: WriteErrorHandler
-}
-
-const LEVEL_RANK: Record<LeucoHumanLevel, number> = {
-  info: 0,
-  warn: 1,
-  error: 2,
-}
-
-/**
- * Human-facing diagnostic logger. The companion to `LeucoLogger`: where
- * `LeucoLogger` is for schema-validated, replayable domain events,
- * `LeucoHumanLogger` is for free-form info/warn/error messages destined
- * for a human tailing a log or skimming during incident response.
- *
- * Keeping the two separate matters operationally:
- *   - Diagnostics typically out-volume domain events 10–1000x; mixing
- *     them in the same store would push events out under retention.
- *   - Diagnostics are unstructured by design; mixing them in would defeat
- *     the schema-first guarantee that makes domain events replayable.
- *   - Different audiences and queries (humans grep `tail -f` vs. tools
- *     query `WHERE seq > ?`).
- *
- * The writer is a port. Level gating happens here so writers receive only
- * what is worth persisting. Failure isolation matches `LeucoLogger`: a
- * writer that throws or returns Error is contained, surfaced via
- * `onWriteError`, and never blocks the caller.
- */
-export class LeucoHumanLogger {
-  private readonly writer: LeucoHumanWriter
-  private readonly minRank: number
-  private readonly now: () => number
-  private readonly onWriteError: WriteErrorHandler | null
-
-  constructor(props: Props) {
-    this.writer = props.writer
-    this.minRank = LEVEL_RANK[props.level ?? "info"]
-    this.now = props.now ?? (() => Date.now())
-    this.onWriteError = props.onWriteError ?? null
-  }
-
-  info(message: string, meta?: Record<string, unknown>): void {
-    this.emit("info", message, meta)
-  }
-
-  warn(message: string, meta?: Record<string, unknown>): void {
-    this.emit("warn", message, meta)
-  }
-
-  error(message: string, meta?: Record<string, unknown>): void {
-    this.emit("error", message, meta)
-  }
-
-  close(): void {
-    if (!this.writer.close) return
-    try {
-      this.writer.close()
-    } catch {
-      // close failures are best-effort by definition
-    }
-  }
-
-  private emit(level: LeucoHumanLevel, message: string, meta?: Record<string, unknown>): void {
-    if (LEVEL_RANK[level] < this.minRank) return
-
-    const record: LeucoHumanRecord = {
-      ts: this.now(),
-      level,
-      message,
-      meta: meta ?? null,
-    }
-
-    const error = this.callWriter(record)
-    if (error && this.onWriteError) this.onWriteError(error, record)
-  }
-
-  private callWriter(record: LeucoHumanRecord): Error | null {
-    try {
-      const outcome = this.writer.write(record)
-      return outcome instanceof Error ? outcome : null
-    } catch (e) {
-      return e instanceof Error ? e : new Error(String(e))
-    }
-  }
-}

package/lib/logger/leuco-human-record.ts

@@ -1,16 +0,0 @@
-export type LeucoHumanLevel = "info" | "warn" | "error"
-
-/**
- * One human-facing diagnostic log entry. Distinct from `LeucoLoggerRecord`
- * (which wraps a schema-validated domain event) — this is the free-form,
- * for-humans-tailing-a-log shape: a level, a message, and optional meta.
- *
- * `meta` is `null` rather than `undefined` when absent so writers can
- * persist a uniform shape (no missing-key ambiguity in JSON Lines).
- */
-export type LeucoHumanRecord = {
-  ts: number
-  level: LeucoHumanLevel
-  message: string
-  meta: Record<string, unknown> | null
-}

package/lib/logger/leuco-human-stdout-writer.ts

@@ -1,26 +0,0 @@
-import type { LeucoHumanRecord } from "@/logger/leuco-human-record"
-import type { LeucoHumanWriter } from "@/logger/leuco-human-writer"
-
-type Stream = { write(s: string): void }
-
-type Props = {
-  /** Override for tests. Defaults to `process.stdout`. */
-  out?: Stream
-}
-
-/**
- * Writes one JSON line per record to stdout. Useful as the default writer
- * for foreground daemons, dev runs, and short-lived processes where a
- * file-backed log would be overkill.
- */
-export class LeucoHumanStdoutWriter implements LeucoHumanWriter {
-  private readonly out: Stream
-
-  constructor(props: Props = {}) {
-    this.out = props.out ?? process.stdout
-  }
-
-  write(record: LeucoHumanRecord): void {
-    this.out.write(`${JSON.stringify(record)}\n`)
-  }
-}

package/lib/logger/leuco-human-writer.ts

@@ -1,14 +0,0 @@
-import type { LeucoHumanRecord } from "@/logger/leuco-human-record"
-
-/**
- * Plugin port for `LeucoHumanLogger`. Writers decide where diagnostic
- * records land — stdout, JSONL file, syslog, network, etc. — without the
- * logger having to know about persistence shape.
- *
- * `write` returns `void` on success or an `Error` the logger surfaces via
- * `onWriteError`. Throwing is also tolerated; the logger catches.
- */
-export type LeucoHumanWriter = {
-  write(record: LeucoHumanRecord): void | Error
-  close?(): void
-}

package/lib/logger/leuco-logger-memory-sink.ts

@@ -1,67 +0,0 @@
-import type { LeucoLoggerRecord } from "@/logger/leuco-logger-record"
-import type { LeucoLoggerPrimarySink, LeucoLoggerSink } from "@/logger/leuco-logger-sink"
-
-type Props = {
-  /** Hard cap on retained records. The oldest is evicted on overflow. 0 disables retention. */
-  capacity?: number
-}
-
-/**
- * In-memory ring buffer that doubles as primary or relay. As primary it
- * owns its own seq counter (single-process only — for multi-process
- * safety, use `LeucoLoggerSqliteSink` as primary and place this as a
- * relay). As relay it accepts whatever seq the primary assigned and
- * advances its own counter to match, so `getMaxSeq` stays meaningful.
- *
- * Useful as a test double, as a short-window replay buffer paired with a
- * persistent primary (covering reconnects without round-tripping disk),
- * or as a backing store for live subscribers.
- */
-export class LeucoLoggerMemorySink<E> implements LeucoLoggerPrimarySink<E>, LeucoLoggerSink<E> {
-  private readonly capacity: number
-  private readonly buffer: LeucoLoggerRecord<E>[] = []
-  private seq = 0
-
-  constructor(props: Props = {}) {
-    this.capacity = Math.max(0, props.capacity ?? 1000)
-  }
-
-  insert(input: { ts: number; event: E }): LeucoLoggerRecord<E> {
-    this.seq += 1
-    const record: LeucoLoggerRecord<E> = {
-      seq: this.seq,
-      ts: input.ts,
-      event: input.event,
-    }
-    this.append(record)
-    return record
-  }
-
-  write(record: LeucoLoggerRecord<E>): void {
-    if (record.seq > this.seq) this.seq = record.seq
-    this.append(record)
-  }
-
-  getMaxSeq(): number {
-    return this.seq
-  }
-
-  getRecords(): ReadonlyArray<LeucoLoggerRecord<E>> {
-    return this.buffer
-  }
-
-  clear(): void {
-    this.buffer.length = 0
-    this.seq = 0
-  }
-
-  private append(record: LeucoLoggerRecord<E>): void {
-    if (this.capacity === 0) return
-
-    this.buffer.push(record)
-
-    if (this.buffer.length > this.capacity) {
-      this.buffer.shift()
-    }
-  }
-}

package/lib/logger/leuco-logger-record.ts

@@ -1,13 +0,0 @@
-/**
- * Wrapper that `LeucoLogger.emit` puts around every event before handing it
- * to a sink. `seq` is monotonic across the lifetime of the underlying store —
- * sinks persist it as the primary key so replay (and broadcaster seeding
- * after restart) is an indexed range scan, not a full table walk. `ts` is
- * epoch milliseconds. `event` is the caller-defined payload validated by the
- * Zod schema passed to the bus.
- */
-export type LeucoLoggerRecord<E> = {
-  seq: number
-  ts: number
-  event: E
-}

package/lib/logger/leuco-logger-sink.ts

@@ -1,33 +0,0 @@
-import type { LeucoLoggerRecord } from "@/logger/leuco-logger-record"
-
-/**
- * Relay sink. Receives records that already have a `seq` assigned by the
- * primary and stores or forwards them — memory ring, stdout, network push,
- * a second SQLite mirror, etc. Does not generate seq itself, so any number
- * can be attached and they all observe the same monotonic stream.
- *
- * `write` returns `void` on success or an `Error` the bus surfaces via
- * `onSinkError`. Throwing is also tolerated (the bus catches), but
- * returning is preferred so the failure path is part of the type.
- */
-export type LeucoLoggerSink<E> = {
-  write(record: LeucoLoggerRecord<E>): void | Error
-  close?(): void
-}
-
-/**
- * Primary sink. Owns the canonical seq sequence for the bus. `insert` is
- * the atomic boundary — it assigns a seq strictly greater than every
- * previously assigned one, persists the record, and returns it. SQLite
- * implementations get atomicity for free by delegating to `INTEGER PRIMARY
- * KEY` so two processes sharing one database file see one monotonic
- * stream without bus-level coordination.
- *
- * `getMaxSeq` is the highest seq currently in the sink — used for
- * observability and for replay seeding by clients reading the store.
- */
-export type LeucoLoggerPrimarySink<E> = {
-  insert(input: { ts: number; event: E }): LeucoLoggerRecord<E> | Error
-  getMaxSeq(): number
-  close?(): void
-}