@interactive-inc/claude-funnel 0.8.1 → 0.10.1

package/lib/engine/settings/settings-reader.ts

@@ -1,6 +0,0 @@
-import type { Settings } from "@/engine/settings/settings-schema"
-
-export abstract class FunnelSettingsReader {
-  abstract read(): Settings
-  abstract write(settings: Settings): void
-}

package/lib/engine/settings/settings-schema.ts

@@ -1,46 +0,0 @@
-import { z } from "zod"
-import { connectorConfigSchema } from "@/connectors/connector-config-schema"
-
-/**
- * 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 const channelDeliveryModeSchema = z.enum(["fanout", "exclusive"])
-
-export type ChannelDeliveryMode = z.infer<typeof channelDeliveryModeSchema>
-
-export const channelConfigSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  delivery: channelDeliveryModeSchema.default("fanout"),
-  connectors: z.array(connectorConfigSchema).default([]),
-})
-
-export type ChannelConfig = z.infer<typeof channelConfigSchema>
-
-export const profileConfigSchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  subAgent: z.string(),
-  channelId: z.string(),
-})
-
-export type ProfileConfig = z.infer<typeof profileConfigSchema>
-
-export const SETTINGS_VERSION = 1
-
-export const settingsSchema = z.object({
-  /** Schema version. New files always write the current version; older files without one are read as v1. */
-  version: z.literal(SETTINGS_VERSION).default(SETTINGS_VERSION),
-  channels: z.array(channelConfigSchema).default([]),
-  profiles: z.array(profileConfigSchema).default([]),
-})
-
-export type Settings = z.infer<typeof settingsSchema>

package/lib/engine/settings/settings-store.ts

@@ -1,110 +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 { FunnelSettingsReader } from "@/engine/settings/settings-reader"
-import { SETTINGS_VERSION, settingsSchema } from "@/engine/settings/settings-schema"
-import type { Settings } from "@/engine/settings/settings-schema"
-
-export const FUNNEL_DIR = join(homedir(), ".funnel")
-export const SETTINGS_PATH = join(FUNNEL_DIR, "settings.json")
-
-type Deps = {
-  path?: string
-  fs?: FunnelFileSystem
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-
-export class FunnelSettingsStore extends FunnelSettingsReader {
-  private readonly path: string
-  private readonly fs: FunnelFileSystem
-
-  constructor(deps: Deps = {}) {
-    super()
-    this.path = deps.path ?? SETTINGS_PATH
-    this.fs = deps.fs ?? defaultFs
-    Object.freeze(this)
-  }
-
-  read(): Settings {
-    if (!this.fs.existsSync(this.path)) {
-      return {
-        version: SETTINGS_VERSION,
-        channels: [],
-        profiles: [],
-      }
-    }
-
-    const content = this.fs.readFileSync(this.path)
-    const parsed: unknown = JSON.parse(content)
-
-    if (this.looksLikeLegacy(parsed)) {
-      throw new Error(
-        `legacy settings.json detected at ${this.path}. The schema changed (channel.connectors are now nested objects with ids; profile fields renamed). Migration is intentionally not provided. Back up and remove the old file:\n  mv ${this.path} ${this.path}.bak`,
-      )
-    }
-
-    if (
-      parsed &&
-      typeof parsed === "object" &&
-      "version" in parsed &&
-      parsed.version !== SETTINGS_VERSION
-    ) {
-      throw new Error(
-        `unsupported settings.json version (${this.path}): expected ${SETTINGS_VERSION}, got ${String(parsed.version)}`,
-      )
-    }
-
-    const result = settingsSchema.safeParse(parsed)
-
-    if (!result.success) {
-      throw new Error(
-        `invalid settings.json (${this.path}): ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`,
-      )
-    }
-
-    return result.data
-  }
-
-  private looksLikeLegacy(parsed: unknown): boolean {
-    if (!parsed || typeof parsed !== "object") return false
-
-    const obj = parsed as Record<string, unknown>
-
-    if (Array.isArray(obj.channels)) {
-      for (const channel of obj.channels) {
-        if (!channel || typeof channel !== "object") continue
-        const ch = channel as Record<string, unknown>
-
-        if (Array.isArray(ch.connectors) && ch.connectors.some((x) => typeof x === "string")) {
-          return true
-        }
-
-        if (!("id" in ch) && "name" in ch) return true
-      }
-    }
-
-    if (Array.isArray(obj.connectors)) return true
-    if (Array.isArray(obj.repositories)) return true
-
-    if (Array.isArray(obj.profiles)) {
-      for (const profile of obj.profiles) {
-        if (!profile || typeof profile !== "object") continue
-        const p = profile as Record<string, unknown>
-
-        if ("repository" in p || "envFiles" in p || ("channel" in p && !("channelId" in p))) {
-          return true
-        }
-      }
-    }
-
-    return false
-  }
-
-  write(settings: Settings): void {
-    this.fs.mkdirSync(dirname(this.path), { recursive: true })
-    const versioned: Settings = { ...settings, version: SETTINGS_VERSION }
-    this.fs.writeFileSync(this.path, `${JSON.stringify(versioned, null, 2)}\n`)
-  }
-}

package/lib/engine/time/clock.ts

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

package/lib/engine/time/memory-clock.ts

@@ -1,26 +0,0 @@
-import { FunnelClock } from "@/engine/time/clock"
-
-type Props = {
-  start?: Date
-}
-
-export class MemoryFunnelClock extends FunnelClock {
-  private current: Date
-
-  constructor(props: Props = {}) {
-    super()
-    this.current = props.start ?? new Date(0)
-  }
-
-  now(): Date {
-    return new Date(this.current.getTime())
-  }
-
-  set(date: Date): void {
-    this.current = date
-  }
-
-  advance(ms: number): void {
-    this.current = new Date(this.current.getTime() + ms)
-  }
-}

package/lib/engine/time/node-clock.ts

@@ -1,7 +0,0 @@
-import { FunnelClock } from "@/engine/time/clock"
-
-export class NodeFunnelClock extends FunnelClock {
-  now(): Date {
-    return new Date()
-  }
-}

package/lib/funnel.ts

@@ -1,187 +0,0 @@
-import { join } from "node:path"
-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 { NodeFunnelLogger } from "@/engine/logger/node-logger"
-import { FunnelMcp } from "@/engine/mcp/mcp"
-import { FunnelProcessRunner } from "@/engine/process/process-runner"
-import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
-import { FunnelProfiles } from "@/engine/profiles/profiles"
-import { FunnelSettingsReader } from "@/engine/settings/settings-reader"
-import { FUNNEL_DIR, FunnelSettingsStore } from "@/engine/settings/settings-store"
-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 class Funnel {
-  constructor(private readonly props: Props = {}) {
-    Object.freeze(this)
-  }
-
-  /** Settings reader. If not injected, a FunnelSettingsStore rooted at `dir` is created. */
-  get store(): FunnelSettingsReader {
-    return (
-      this.props.store ??
-      new FunnelSettingsStore({
-        path: join(this.props.dir ?? FUNNEL_DIR, "settings.json"),
-        fs: this.props.fs,
-      })
-    )
-  }
-
-  /** Process runner boundary. Defaults to NodeFunnelProcessRunner. */
-  get process(): FunnelProcessRunner {
-    return this.props.process ?? new NodeFunnelProcessRunner()
-  }
-
-  /** Logger boundary. Defaults to NodeFunnelLogger. */
-  get logger(): FunnelLogger {
-    return this.props.logger ?? new NodeFunnelLogger()
-  }
-
-  /** Pure factory that constructs per-type listeners and adapters from connector configs. */
-  get factory(): FunnelConnectorFactory {
-    return new FunnelConnectorFactory({
-      fs: this.props.fs,
-      process: this.props.process,
-      logger: this.props.logger,
-      dir: this.props.dir,
-    })
-  }
-
-  /** Channel CRUD + nested connector CRUD + schedule entries + listener/adapter dispatch. */
-  get channels(): FunnelChannels {
-    return new FunnelChannels({
-      store: this.store,
-      factory: this.factory,
-      profileChecker: this.profiles,
-      clock: this.props.clock,
-      idGenerator: this.props.idGenerator,
-    })
-  }
-
-  /** Launch profiles (named presets for `fnl claude`: path + sub-agent + channel id). */
-  get profiles(): FunnelProfiles {
-    return new FunnelProfiles({ store: this.store })
-  }
-
-  /** funnel MCP installer (writes/removes `.mcp.json` entries in target repos). */
-  get mcp(): FunnelMcp {
-    return new FunnelMcp({ fs: this.props.fs })
-  }
-
-  /** Launch Claude Code with a channel injected via env, MCP installed, gateway ensured. */
-  get claude(): FunnelClaude {
-    return new FunnelClaude({
-      channels: this.channels,
-      mcp: this.mcp,
-      gateway: this.gateway,
-      fs: this.props.fs,
-      process: this.props.process,
-      logger: this.props.logger,
-      dir: this.props.dir,
-    })
-  }
-
-  /** Gateway daemon controller (PID-file, start/stop the separate `bun daemon.ts` process). */
-  get gateway(): FunnelGateway {
-    return new FunnelGateway({
-      fs: this.props.fs,
-      process: this.props.process,
-      clock: this.props.clock,
-      dir: this.props.dir,
-      tmpDir: this.props.tmpDir,
-    })
-  }
-
-  /** Read / generate the daemon's gateway token (mode 0600 file under `dir`). */
-  get gatewayToken(): FunnelGatewayToken {
-    return new FunnelGatewayToken({ fs: this.props.fs, dir: this.props.dir })
-  }
-
-  /**
-   * 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 {
-    const gateway = this.gateway
-    const token = this.gatewayToken
-
-    return new FunnelListenersClient({
-      port: gateway.getPort(),
-      isDaemonRunning: () => gateway.isRunning(),
-      getToken: () => token.read(),
-    })
-  }
-
-  /**
-   * 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 {
-    return new FunnelGatewayServer({
-      channels: this.channels,
-      settings: this.store,
-      port: options.port,
-      logDir: options.logDir,
-      process: this.props.process,
-      clock: this.props.clock,
-      logger: this.props.logger,
-      killCompetingSlack: options.killCompetingSlack,
-      token: options.token ?? this.gatewayToken.ensure(),
-    })
-  }
-}

package/lib/gateway/auth-middleware.ts

@@ -1,44 +0,0 @@
-import { timingSafeEqual } from "node:crypto"
-import type { MiddlewareHandler } from "hono"
-import type { Env } from "@/gateway/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 const requireBearerToken = (deps: Deps): MiddlewareHandler<Env> => {
-  return async (c, next) => {
-    const header = c.req.header("authorization") ?? ""
-    const match = header.match(/^Bearer\s+(.+)$/i)
-    const presented = match?.[1] ?? ""
-
-    if (!constantTimeEqual(presented, deps.expected)) {
-      return c.text("unauthorized", 401)
-    }
-
-    return await next()
-  }
-}
-
-export const constantTimeEqual = (a: string, b: string): boolean => {
-  const bufA = Buffer.from(a, "utf-8")
-  const bufB = Buffer.from(b, "utf-8")
-  const maxLen = Math.max(bufA.length, bufB.length, 1)
-  const padA = Buffer.alloc(maxLen)
-  const padB = Buffer.alloc(maxLen)
-
-  bufA.copy(padA)
-  bufB.copy(padB)
-
-  // timingSafeEqual on equal-length padded buffers, then AND with length match
-  // so a length-only probe still requires the full comparison time.
-  const equal = timingSafeEqual(padA, padB)
-
-  return equal && bufA.length === bufB.length
-}