@interactive-inc/claude-funnel 0.4.1 → 0.8.0

package/lib/gateway/resolve-daemon-script.ts

@@ -0,0 +1,26 @@
+import { existsSync } from "node:fs"
+import { resolve } from "node:path"
+
+/**
+ * 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 const resolveDaemonScript = (): string => {
+  const candidates = [
+    resolve(import.meta.dir, "./daemon.ts"),
+    resolve(import.meta.dir, "./daemon.js"),
+    resolve(import.meta.dir, "./gateway/daemon.js"),
+  ]
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate
+  }
+
+  throw new Error(`daemon script not found (looked in ${candidates.join(", ")})`)
+}

package/lib/gateway/routes/channels.connectors.call.ts

@@ -0,0 +1,39 @@
+import { HTTPException } from "hono/http-exception"
+import { z } from "zod"
+import { factory } from "@/gateway/factory"
+import { zParam } from "@/gateway/routes/validator"
+
+const bodySchema = z.object({
+  method: z.string().min(1),
+  path: z.string().min(1),
+  body: z.unknown().optional(),
+})
+
+/**
+ * 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 const channelsConnectorsCallHandler = factory.createHandlers(
+  zParam(z.object({ channel: z.string().min(1), connector: z.string().min(1) })),
+  async (c) => {
+    const param = c.req.valid("param")
+    const raw = await c.req.json().catch(() => null)
+    const parsed = bodySchema.safeParse(raw)
+
+    if (!parsed.success) {
+      throw new HTTPException(400, { message: parsed.error.issues[0]?.message ?? "invalid body" })
+    }
+
+    const result = await c.var.deps.channels.call(param.channel, param.connector, {
+      method: parsed.data.method,
+      path: parsed.data.path,
+      body: parsed.data.body ?? {},
+    })
+
+    return c.json({ ok: true, result })
+  },
+)

package/lib/gateway/routes/health.ts

@@ -0,0 +1,13 @@
+import { factory } from "@/gateway/factory"
+
+/** GET /health — liveness + listener registry snapshot. */
+export const healthHandler = factory.createHandlers((c) => {
+  const deps = c.var.deps
+
+  return c.json({
+    ok: true,
+    pid: deps.selfPid,
+    clients: deps.broadcaster.getClientCount(),
+    listeners: deps.supervisor.list(),
+  })
+})

package/lib/gateway/routes/index.ts

@@ -0,0 +1,24 @@
+import { factory } from "@/gateway/factory"
+import { channelsConnectorsCallHandler } from "@/gateway/routes/channels.connectors.call"
+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)

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

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

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

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

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

@@ -0,0 +1,11 @@
+import type { FunnelChannels } from "@/engine/channels/channels"
+import type { FunnelBroadcaster } from "@/gateway/broadcaster"
+import type { FunnelListenerSupervisor } from "@/gateway/listener-supervisor"
+
+export type GatewayRouteDeps = {
+  selfPid: number
+  broadcaster: FunnelBroadcaster
+  supervisor: FunnelListenerSupervisor
+  channels: FunnelChannels
+  uptimeMs: () => number
+}

package/lib/gateway/routes/status.ts

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

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