@interactive-inc/claude-funnel 0.10.0 → 0.10.1

package/lib/engine/profiles/profiles.ts

@@ -1,126 +0,0 @@
-import { FunnelSettingsReader } from "@/engine/settings/settings-reader"
-import type { ProfileConfig } from "@/engine/settings/settings-schema"
-
-type Deps = {
-  store: FunnelSettingsReader
-}
-
-/**
- * Named launch presets for `fnl claude`. Each profile bundles a working
- * directory, a sub-agent name, and the channel id its Claude instance will
- * subscribe to. Implements ProfileChannelChecker so FunnelChannels can refuse
- * to remove a channel that is still referenced.
- *
- * The first entry in the persisted array is treated as the default profile;
- * `asDefault` reorders the array to put a named profile first.
- *
- * `channelId` always stores the channel's stable id (uuid). CLI surfaces
- * resolve channel name → id before calling `add`/`update` here.
- */
-export class FunnelProfiles {
-  private readonly store: FunnelSettingsReader
-
-  constructor(deps: Deps) {
-    this.store = deps.store
-    Object.freeze(this)
-  }
-
-  list(): ProfileConfig[] {
-    return this.store.read().profiles
-  }
-
-  get(name: string): ProfileConfig | null {
-    return this.list().find((p) => p.name === name) ?? null
-  }
-
-  getDefault(): ProfileConfig | null {
-    return this.list()[0] ?? null
-  }
-
-  add(config: ProfileConfig): void {
-    const settings = this.store.read()
-
-    if (settings.profiles.some((p) => p.name === config.name)) {
-      throw new Error(`profile "${config.name}" already exists`)
-    }
-
-    if (!settings.channels.some((c) => c.id === config.channelId)) {
-      throw new Error(`channel id "${config.channelId}" not found`)
-    }
-
-    settings.profiles.push(config)
-
-    this.store.write(settings)
-  }
-
-  remove(name: string): void {
-    const settings = this.store.read()
-
-    const index = settings.profiles.findIndex((p) => p.name === name)
-
-    if (index < 0) throw new Error(`profile "${name}" not found`)
-
-    settings.profiles.splice(index, 1)
-
-    this.store.write(settings)
-  }
-
-  rename(oldName: string, newName: string): void {
-    const settings = this.store.read()
-
-    const profile = settings.profiles.find((p) => p.name === oldName)
-
-    if (!profile) throw new Error(`profile "${oldName}" not found`)
-
-    if (settings.profiles.some((p) => p.name === newName)) {
-      throw new Error(`profile "${newName}" already exists`)
-    }
-
-    profile.name = newName
-
-    this.store.write(settings)
-  }
-
-  asDefault(name: string): void {
-    const settings = this.store.read()
-
-    const index = settings.profiles.findIndex((p) => p.name === name)
-
-    if (index < 0) throw new Error(`profile "${name}" not found`)
-
-    if (index === 0) return
-
-    const [profile] = settings.profiles.splice(index, 1)
-
-    if (!profile) return
-
-    settings.profiles.unshift(profile)
-
-    this.store.write(settings)
-  }
-
-  hasChannelRef(channelId: string): boolean {
-    return this.store.read().profiles.some((p) => p.channelId === channelId)
-  }
-
-  update(name: string, fields: Partial<Omit<ProfileConfig, "name">>): void {
-    const settings = this.store.read()
-
-    const profile = settings.profiles.find((p) => p.name === name)
-
-    if (!profile) throw new Error(`profile "${name}" not found`)
-
-    if (fields.channelId !== undefined) {
-      if (!settings.channels.some((c) => c.id === fields.channelId)) {
-        throw new Error(`channel id "${fields.channelId}" not found`)
-      }
-
-      profile.channelId = fields.channelId
-    }
-
-    if (fields.path !== undefined) profile.path = fields.path
-    if (fields.subAgent !== undefined) profile.subAgent = fields.subAgent
-
-    this.store.write(settings)
-  }
-}

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

@@ -1,27 +0,0 @@
-import { FunnelSettingsReader } from "@/engine/settings/settings-reader"
-import { SETTINGS_VERSION } from "@/engine/settings/settings-schema"
-import type { Settings } from "@/engine/settings/settings-schema"
-
-export const createSettings = (partial: Partial<Settings> = {}): Settings => ({
-  version: SETTINGS_VERSION,
-  channels: [],
-  profiles: [],
-  ...partial,
-})
-
-export class MockFunnelSettingsReader extends FunnelSettingsReader {
-  private state: Settings
-
-  constructor(initial?: Partial<Settings>) {
-    super()
-    this.state = createSettings(initial)
-  }
-
-  read(): Settings {
-    return this.state
-  }
-
-  write(settings: Settings): void {
-    this.state = settings
-  }
-}

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,48 +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(),
-  /** Forwards `--brief` to claude on launch (enables the SendUserMessage tool). */
-  brief: z.boolean().optional(),
-})
-
-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,294 +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 { FunnelFileSystem } from "@/engine/fs/file-system"
-import { MemoryFunnelFileSystem } from "@/engine/fs/memory-file-system"
-import { NodeFunnelFileSystem } from "@/engine/fs/node-file-system"
-import { FunnelIdGenerator } from "@/engine/id/id-generator"
-import { MemoryFunnelIdGenerator } from "@/engine/id/memory-id-generator"
-import { NodeFunnelIdGenerator } from "@/engine/id/node-id-generator"
-import { FunnelLogger } from "@/engine/logger/logger"
-import { MemoryFunnelLogger } from "@/engine/logger/memory-logger"
-import { NodeFunnelLogger } from "@/engine/logger/node-logger"
-import { FunnelMcp } from "@/engine/mcp/mcp"
-import { FunnelProcessRunner } from "@/engine/process/process-runner"
-import { MemoryFunnelProcessRunner } from "@/engine/process/memory-process-runner"
-import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
-import { FunnelProfiles } from "@/engine/profiles/profiles"
-import { MockFunnelSettingsReader } from "@/engine/settings/mock-settings-reader"
-import { FunnelSettingsReader } from "@/engine/settings/settings-reader"
-import { FUNNEL_DIR, FunnelSettingsStore } from "@/engine/settings/settings-store"
-import { FunnelClock } from "@/engine/time/clock"
-import { MemoryFunnelClock } from "@/engine/time/memory-clock"
-import { NodeFunnelClock } from "@/engine/time/node-clock"
-import { FunnelChannelPublisher } from "@/gateway/channel-publisher"
-import { FunnelGateway } from "@/gateway/gateway"
-import { FunnelGatewayServer } from "@/gateway/gateway-server"
-import { FunnelGatewayToken } from "@/gateway/gateway-token"
-import { FunnelListenersClient } from "@/gateway/listeners-client"
-
-const DEFAULT_TMP_DIR = "/tmp/funnel"
-const SANDBOX_DIR = "/sandbox/.funnel"
-const SANDBOX_TMP_DIR = "/sandbox/tmp"
-
-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 {
-  private readonly cache = new Map<string, unknown>()
-
-  constructor(private readonly props: Props = {}) {
-    Object.freeze(this)
-  }
-
-  /**
-   * Sandboxed Funnel wired with in-memory implementations for every IO boundary.
-   * Touches no real disk, processes, wall-clock time, or UUIDs — safe for tests
-   * and ad-hoc experiments. Override individual fields by passing them in `props`.
-   */
-  static inMemory(props: Props = {}): Funnel {
-    return new Funnel({
-      store: props.store ?? new MockFunnelSettingsReader(),
-      fs: props.fs ?? new MemoryFunnelFileSystem(),
-      process: props.process ?? new MemoryFunnelProcessRunner(),
-      logger: props.logger ?? new MemoryFunnelLogger(),
-      clock: props.clock ?? new MemoryFunnelClock(),
-      idGenerator: props.idGenerator ?? new MemoryFunnelIdGenerator(),
-      dir: props.dir ?? SANDBOX_DIR,
-      tmpDir: props.tmpDir ?? SANDBOX_TMP_DIR,
-    })
-  }
-
-  private memo<T>(key: string, build: () => T): T {
-    if (this.cache.has(key)) return this.cache.get(key) as T
-
-    const value = build()
-    this.cache.set(key, value)
-
-    return value
-  }
-
-  /** Resolved on-disk paths the facade will read/write when methods are called. Pure compute, not memoized. */
-  get paths(): { dir: string; tmpDir: string; settings: string } {
-    const dir = this.props.dir ?? FUNNEL_DIR
-    const tmpDir = this.props.tmpDir ?? DEFAULT_TMP_DIR
-
-    return { dir, tmpDir, settings: join(dir, "settings.json") }
-  }
-
-  /** Filesystem boundary. Defaults to NodeFunnelFileSystem. */
-  get fs(): FunnelFileSystem {
-    return this.memo("fs", () => this.props.fs ?? new NodeFunnelFileSystem())
-  }
-
-  /** Process runner boundary. Defaults to NodeFunnelProcessRunner. */
-  get process(): FunnelProcessRunner {
-    return this.memo("process", () => this.props.process ?? new NodeFunnelProcessRunner())
-  }
-
-  /** Logger boundary. Defaults to NodeFunnelLogger. */
-  get logger(): FunnelLogger {
-    return this.memo("logger", () => this.props.logger ?? new NodeFunnelLogger())
-  }
-
-  /** Clock boundary. Defaults to NodeFunnelClock. */
-  get clock(): FunnelClock {
-    return this.memo("clock", () => this.props.clock ?? new NodeFunnelClock())
-  }
-
-  /** ID generator boundary. Defaults to NodeFunnelIdGenerator. */
-  get idGenerator(): FunnelIdGenerator {
-    return this.memo("idGenerator", () => this.props.idGenerator ?? new NodeFunnelIdGenerator())
-  }
-
-  /** Settings reader. If not injected, a FunnelSettingsStore rooted at `dir` is created. */
-  get store(): FunnelSettingsReader {
-    return this.memo(
-      "store",
-      () =>
-        this.props.store ??
-        new FunnelSettingsStore({
-          path: this.paths.settings,
-          fs: this.fs,
-        }),
-    )
-  }
-
-  /** Pure factory that constructs per-type listeners and adapters from connector configs. */
-  get factory(): FunnelConnectorFactory {
-    return this.memo(
-      "factory",
-      () =>
-        new FunnelConnectorFactory({
-          fs: this.fs,
-          process: this.process,
-          logger: this.logger,
-          dir: this.paths.dir,
-        }),
-    )
-  }
-
-  /** Channel CRUD + nested connector CRUD + schedule entries + listener/adapter dispatch. */
-  get channels(): FunnelChannels {
-    return this.memo(
-      "channels",
-      () =>
-        new FunnelChannels({
-          store: this.store,
-          factory: this.factory,
-          profileChecker: this.profiles,
-          clock: this.clock,
-          idGenerator: this.idGenerator,
-        }),
-    )
-  }
-
-  /** Launch profiles (named presets for `fnl claude`: path + sub-agent + channel id). */
-  get profiles(): FunnelProfiles {
-    return this.memo("profiles", () => new FunnelProfiles({ store: this.store }))
-  }
-
-  /** funnel MCP installer (writes/removes `.mcp.json` entries in target repos). */
-  get mcp(): FunnelMcp {
-    return this.memo("mcp", () => new FunnelMcp({ fs: this.fs }))
-  }
-
-  /** Launch Claude Code with a channel injected via env, MCP installed, gateway ensured. */
-  get claude(): FunnelClaude {
-    return this.memo(
-      "claude",
-      () =>
-        new FunnelClaude({
-          channels: this.channels,
-          mcp: this.mcp,
-          gateway: this.gateway,
-          fs: this.fs,
-          process: this.process,
-          logger: this.logger,
-          dir: this.paths.dir,
-        }),
-    )
-  }
-
-  /** Gateway daemon controller (PID-file, start/stop the separate `bun daemon.ts` process). */
-  get gateway(): FunnelGateway {
-    return this.memo(
-      "gateway",
-      () =>
-        new FunnelGateway({
-          fs: this.fs,
-          process: this.process,
-          clock: this.clock,
-          dir: this.paths.dir,
-          tmpDir: this.paths.tmpDir,
-        }),
-    )
-  }
-
-  /** Read / generate the daemon's gateway token (mode 0600 file under `dir`). */
-  get gatewayToken(): FunnelGatewayToken {
-    return this.memo(
-      "gatewayToken",
-      () => new FunnelGatewayToken({ fs: this.fs, dir: this.paths.dir }),
-    )
-  }
-
-  /**
-   * HTTP client for `POST /channels/:channel/publish` on the running gateway
-   * daemon. Use it to push arbitrary content into a channel from outside any
-   * connector. Returns `{ state: "offline" }` if the daemon isn't up.
-   */
-  get publisher(): FunnelChannelPublisher {
-    return this.memo("publisher", () => {
-      const gateway = this.gateway
-      const token = this.gatewayToken
-
-      return new FunnelChannelPublisher({
-        port: gateway.getPort(),
-        isDaemonRunning: () => gateway.isRunning(),
-        getToken: () => token.read(),
-      })
-    })
-  }
-
-  /**
-   * 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 {
-    return this.memo("listeners", () => {
-      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.process,
-      clock: this.clock,
-      logger: this.logger,
-      killCompetingSlack: options.killCompetingSlack,
-      token: options.token ?? this.gatewayToken.ensure(),
-    })
-  }
-}