@interactive-inc/claude-funnel 0.7.1 → 0.8.0

package/lib/index.ts

@@ -1,92 +1,50 @@
-#!/usr/bin/env bun
-import pkg from "../package.json" with { type: "json" }
-import { createConnectorStores } from "@/modules/connectors/funnel-connector-stores"
-import { migrateLegacyConnectors } from "@/modules/connectors/migrate-legacy-connectors"
-import { startChannelServer } from "@/modules/mcp/channel-server"
-import { toRequest } from "@/modules/router/to-request"
-import { launchTui } from "@/modules/tui/tui"
-import { app } from "@/routes"
-
-process.title = "funnel"
-
-migrateLegacyConnectors({ stores: createConnectorStores() })
-
-const HELP = `funnel — Open Claude Funnel
-
-usage: funnel [command]
-
-commands:
-  (none)                launch TUI
-  claude                launch Claude Code (default profile or --profile)
-  connectors            manage external connections (Slack, etc.)
-  channels              manage subscription boxes
-  profiles              manage launch profiles
-  request               send an outbound API call via a connector
-  repos                 manage repositories (extra)
-  gateway               manage the gateway
-  status                show overall connection status
-  update                update funnel to the latest version
-  mcp                   run as an MCP server (invoked from .mcp.json)
-
-options:
-  --help, -h            show help
-  --version, -v         show version
-
-more: funnel <command> --help`
-
-const args = process.argv.slice(2)
-
-if (args.length === 0) {
-  await launchTui()
-  process.exit(0)
-}
-
-if (args[0] === "--version" || args[0] === "-v") {
-  process.stdout.write(`${pkg.version}\n`)
-  process.exit(0)
-}
-
-if (args[0] === "mcp") {
-  await startChannelServer()
-} else {
-  const { method, url } = toRequest(args)
-
-  const parsed = new URL(url)
-
-  if (parsed.searchParams.has("help")) {
-    if (parsed.pathname === "/") {
-      process.stdout.write(`${HELP}\n`)
-      process.exit(0)
-    }
-
-    let res = await app.request(url, { method })
-
-    if (!res.ok && method !== "GET") {
-      res = await app.request(url, { method: "GET" })
-    }
-
-    if (!res.ok) {
-      const group = parsed.pathname.split("/").filter(Boolean)[0]
-
-      if (group) {
-        res = await app.request(`http://localhost/${group}?help=true`, { method: "GET" })
-      }
-    }
-
-    const text = res.ok ? await res.text() : HELP
-    process.stdout.write(`${text}\n`)
-    process.exit(0)
-  }
-
-  const res = await app.request(url, { method })
-
-  if (!res.ok) {
-    const text = await res.text()
-    if (text) process.stderr.write(`${text}\n`)
-    process.exit(1)
-  }
-
-  const body = await res.text()
-
-  if (body) process.stdout.write(`${body}\n`)
-}
+// 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/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/schedule-connector-schema"
+
+// Gateway
+export * from "@/gateway/gateway"
+export * from "@/gateway/gateway-server"
+export * from "@/gateway/broadcaster"
+export * from "@/gateway/funnel-event-store"
+export * from "@/gateway/listener-supervisor"
+export * from "@/gateway/listeners-client"

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

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

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

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

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

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

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

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

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