@interactive-inc/claude-funnel 0.7.1 → 0.8.1

package/lib/modules/connectors/funnel-slack-adapter.ts

@@ -1,31 +0,0 @@
-import { WebClient } from "@slack/web-api"
-import {
-  FunnelConnectorAdapter,
-  type CallInput,
-} from "@/modules/connectors/funnel-connector-adapter"
-import type { SlackConnectorConfig } from "@/modules/connectors/slack-connector-schema"
-
-export type SlackWebClientLike = {
-  apiCall: (method: string, options: Record<string, unknown>) => Promise<unknown>
-}
-
-type Deps = {
-  config: SlackConnectorConfig
-  client?: SlackWebClientLike
-}
-
-export class FunnelSlackAdapter extends FunnelConnectorAdapter {
-  private readonly client: SlackWebClientLike
-
-  constructor(deps: Deps) {
-    super()
-    this.client = deps.client ?? new WebClient(deps.config.botToken)
-    Object.freeze(this)
-  }
-
-  async call(input: CallInput): Promise<unknown> {
-    const body = input.body && typeof input.body === "object" ? input.body : {}
-
-    return await this.client.apiCall(input.path, body as Record<string, unknown>)
-  }
-}

package/lib/modules/connectors/funnel-slack-store.ts

@@ -1,90 +0,0 @@
-import { FunnelCallableConnectorStore } from "@/modules/connectors/funnel-callable-connector-store"
-import type { FunnelConnectorAdapter } from "@/modules/connectors/funnel-connector-adapter"
-import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
-import {
-  DEFAULT_FUNNEL_DIR,
-  FunnelJsonConnectorStore,
-} from "@/modules/connectors/funnel-json-connector-store"
-import { FunnelSlackAdapter } from "@/modules/connectors/funnel-slack-adapter"
-import { FunnelSlackListener } from "@/modules/connectors/funnel-slack-listener"
-import {
-  type SlackConnectorConfig,
-  slackConnectorSchema,
-} from "@/modules/connectors/slack-connector-schema"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import type { FunnelLogger } from "@/modules/logger/funnel-logger"
-
-type Deps = {
-  fs?: FunnelFileSystem
-  dir?: string
-  logger?: FunnelLogger
-}
-
-export type SlackUpdateFields = {
-  botToken?: string
-  appToken?: string
-}
-
-export class FunnelSlackStore extends FunnelCallableConnectorStore<SlackConnectorConfig> {
-  readonly type = "slack" as const
-  private readonly store: FunnelJsonConnectorStore<SlackConnectorConfig>
-  private readonly logger?: FunnelLogger
-
-  constructor(deps: Deps = {}) {
-    super()
-    this.store = new FunnelJsonConnectorStore<SlackConnectorConfig>({
-      type: "slack",
-      schema: slackConnectorSchema,
-      fs: deps.fs,
-      dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
-    })
-    this.logger = deps.logger
-    Object.freeze(this)
-  }
-
-  list(): SlackConnectorConfig[] {
-    return this.store.list()
-  }
-
-  get(name: string): SlackConnectorConfig | null {
-    return this.store.get(name)
-  }
-
-  has(name: string): boolean {
-    return this.store.has(name)
-  }
-
-  add(config: SlackConnectorConfig): void {
-    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
-
-    this.store.write(config)
-  }
-
-  update(name: string, fields: SlackUpdateFields): void {
-    const current = this.store.get(name)
-
-    if (!current) throw new Error(`connector "${name}" not found`)
-
-    this.store.write({
-      ...current,
-      botToken: fields.botToken ?? current.botToken,
-      appToken: fields.appToken ?? current.appToken,
-    })
-  }
-
-  remove(name: string): void {
-    this.store.remove(name)
-  }
-
-  rename(oldName: string, newName: string): void {
-    this.store.rename(oldName, newName)
-  }
-
-  createListener(config: SlackConnectorConfig): FunnelConnectorListener {
-    return new FunnelSlackListener({ config, logger: this.logger })
-  }
-
-  createAdapter(config: SlackConnectorConfig): FunnelConnectorAdapter {
-    return new FunnelSlackAdapter({ config })
-  }
-}

package/lib/modules/connectors/migrate-legacy-connectors.ts

@@ -1,81 +0,0 @@
-import { join } from "node:path"
-import { connectorConfigSchema } from "@/modules/connectors/connector-config-schema"
-import type { ConnectorStoresBundle } from "@/modules/connectors/funnel-connector-stores"
-import { DEFAULT_FUNNEL_DIR } from "@/modules/connectors/funnel-json-connector-store"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
-import { FunnelLogger } from "@/modules/logger/funnel-logger"
-import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
-
-type Props = {
-  stores: ConnectorStoresBundle
-  fs?: FunnelFileSystem
-  dir?: string
-  logger?: FunnelLogger
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-const defaultLogger = new NodeFunnelLogger()
-
-export const migrateLegacyConnectors = (props: Props): number => {
-  const fs = props.fs ?? defaultFs
-  const base = props.dir ?? DEFAULT_FUNNEL_DIR
-  const path = join(base, "settings.json")
-  const logger = props.logger ?? defaultLogger
-
-  if (!fs.existsSync(path)) return 0
-
-  const content = fs.readFileSync(path)
-  const raw = JSON.parse(content) as Record<string, unknown>
-  const legacy = raw.connectors
-
-  if (!Array.isArray(legacy) || legacy.length === 0) {
-    if (legacy !== undefined) {
-      const stripped = { ...raw }
-      delete stripped.connectors
-      fs.writeFileSync(path, `${JSON.stringify(stripped, null, 2)}\n`)
-    }
-    return 0
-  }
-
-  let migrated = 0
-
-  for (const entry of legacy) {
-    const parsed = connectorConfigSchema.safeParse(entry)
-
-    if (!parsed.success) {
-      logger.warn("skipping invalid legacy connector", {
-        error: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", "),
-      })
-      continue
-    }
-
-    const config = parsed.data
-
-    if (config.type === "slack") {
-      if (props.stores.slack.has(config.name)) continue
-      props.stores.slack.add(config)
-    } else if (config.type === "gh") {
-      if (props.stores.gh.has(config.name)) continue
-      props.stores.gh.add(config)
-    } else if (config.type === "discord") {
-      if (props.stores.discord.has(config.name)) continue
-      props.stores.discord.add(config)
-    } else {
-      if (props.stores.schedule.has(config.name)) continue
-      props.stores.schedule.add(config)
-    }
-
-    migrated++
-  }
-
-  const stripped = { ...raw }
-  delete stripped.connectors
-  fs.writeFileSync(path, `${JSON.stringify(stripped, null, 2)}\n`)
-
-  if (migrated > 0) {
-    logger.info("migrated legacy connectors from settings.json", { count: migrated })
-  }
-
-  return migrated
-}

package/lib/modules/connectors/schedule-connector-schema.ts

@@ -1,18 +0,0 @@
-import { z } from "zod"
-
-export const scheduleEntrySchema = z.object({
-  id: z.string(),
-  cron: z.string(),
-  prompt: z.string(),
-  enabled: z.boolean().default(true),
-})
-
-export type ScheduleEntry = z.infer<typeof scheduleEntrySchema>
-
-export const scheduleConnectorSchema = z.object({
-  type: z.literal("schedule"),
-  name: z.string(),
-  entries: z.array(scheduleEntrySchema).default([]),
-})
-
-export type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>

package/lib/modules/connectors/schedule-last-fired-store.ts

@@ -1,48 +0,0 @@
-import { dirname, join } from "node:path"
-import { DEFAULT_FUNNEL_DIR } from "@/modules/connectors/funnel-json-connector-store"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
-
-type Deps = {
-  connector: string
-  fs?: FunnelFileSystem
-  dir?: string
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-
-export class ScheduleLastFiredStore {
-  private readonly path: string
-  private readonly fs: FunnelFileSystem
-
-  constructor(deps: Deps) {
-    this.fs = deps.fs ?? defaultFs
-    const base = deps.dir ?? DEFAULT_FUNNEL_DIR
-    this.path = join(base, "connectors", "schedule", `${deps.connector}.state.json`)
-    Object.freeze(this)
-  }
-
-  load(): Map<string, Date> {
-    if (!this.fs.existsSync(this.path)) return new Map()
-
-    const raw = JSON.parse(this.fs.readFileSync(this.path)) as Record<string, string>
-    const map = new Map<string, Date>()
-
-    for (const [id, iso] of Object.entries(raw)) {
-      map.set(id, new Date(iso))
-    }
-
-    return map
-  }
-
-  save(state: Map<string, Date>): void {
-    const obj: Record<string, string> = {}
-
-    for (const [id, date] of state) {
-      obj[id] = date.toISOString()
-    }
-
-    this.fs.mkdirSync(dirname(this.path), { recursive: true })
-    this.fs.writeFileSync(this.path, `${JSON.stringify(obj, null, 2)}\n`)
-  }
-}

package/lib/modules/gateway/daemon.ts

@@ -1,74 +0,0 @@
-#!/usr/bin/env bun
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
-import { FunnelChannels } from "@/modules/channels/funnel-channels"
-import { FunnelConnectors } from "@/modules/connectors/funnel-connectors"
-import { createConnectorStores } from "@/modules/connectors/funnel-connector-stores"
-import { migrateLegacyConnectors } from "@/modules/connectors/migrate-legacy-connectors"
-import { FunnelGatewayServer } from "@/modules/gateway/funnel-gateway-server"
-import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
-import { FunnelProfiles } from "@/modules/profiles/funnel-profiles"
-import { FUNNEL_DIR, FunnelSettingsStore } from "@/modules/settings/funnel-settings-store"
-
-const PORT = Number(process.env.FUNNEL_PORT) || 9742
-const PID_FILE = join(FUNNEL_DIR, "gateway.pid")
-const LOG_DIR = "/tmp/funnel/events"
-
-const logger = new NodeFunnelLogger()
-
-mkdirSync(FUNNEL_DIR, { recursive: true })
-
-if (existsSync(PID_FILE)) {
-  const existing = Number(readFileSync(PID_FILE, "utf-8").trim())
-
-  if (existing > 0) {
-    const check = Bun.spawnSync(["ps", "-p", String(existing), "-o", "state="], {
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    if (check.exitCode === 0 && check.stdout.toString().trim()) {
-      logger.error(`funnel gateway already running`, { pid: existing })
-      process.exit(1)
-    }
-  }
-}
-
-writeFileSync(PID_FILE, String(process.pid))
-
-process.on("exit", () => {
-  try {
-    unlinkSync(PID_FILE)
-  } catch {
-    // ignore
-  }
-})
-process.on("SIGINT", () => process.exit(130))
-process.on("SIGTERM", () => process.exit(143))
-
-const store = new FunnelSettingsStore()
-const connectorStores = createConnectorStores()
-
-migrateLegacyConnectors({ stores: connectorStores })
-
-const profiles = new FunnelProfiles({ store })
-const channels: FunnelChannels = new FunnelChannels({
-  store,
-  connectorChecker: { has: (name: string) => connectors.has(name) },
-  profileChecker: profiles,
-  profileRefUpdater: profiles,
-})
-const connectors: FunnelConnectors = new FunnelConnectors({
-  ...connectorStores,
-  refUpdater: channels,
-})
-
-const server = new FunnelGatewayServer({
-  connectors,
-  settings: store,
-  port: PORT,
-  logDir: LOG_DIR,
-  logger,
-})
-
-await server.start()

package/lib/modules/gateway/funnel-broadcaster.ts

@@ -1,37 +0,0 @@
-import type { ServerWebSocket } from "bun"
-
-type ClientData = {
-  channel: string
-  connectors: string[]
-}
-
-export class FunnelBroadcaster {
-  private readonly clients: Map<ServerWebSocket<unknown>, ClientData> = new Map()
-
-  addClient(ws: ServerWebSocket<unknown>, data: ClientData): void {
-    this.clients.set(ws, data)
-  }
-
-  removeClient(ws: ServerWebSocket<unknown>): void {
-    this.clients.delete(ws)
-  }
-
-  getClientCount(): number {
-    return this.clients.size
-  }
-
-  listChannels(): { channel: string; connectors: string[] }[] {
-    return [...this.clients.values()].map((d) => ({ ...d }))
-  }
-
-  broadcast(content: string, meta?: Record<string, string>): void {
-    const payload = JSON.stringify({ content, meta })
-    const connector = meta?.connector
-
-    for (const [ws, data] of this.clients) {
-      if (connector && !data.connectors.includes(connector)) continue
-
-      ws.send(payload)
-    }
-  }
-}

package/lib/modules/gateway/funnel-event-logger.ts

@@ -1,59 +0,0 @@
-import { join } from "node:path"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
-
-const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000 // 30 days
-
-type Deps = {
-  logDir: string
-  fs?: FunnelFileSystem
-  now?: () => number
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-
-export class FunnelEventLogger {
-  private readonly logDir: string
-  private readonly fs: FunnelFileSystem
-  private readonly now: () => number
-
-  constructor(deps: Deps) {
-    this.logDir = deps.logDir
-    this.fs = deps.fs ?? defaultFs
-    this.now = deps.now ?? (() => Date.now())
-    this.fs.mkdirSync(this.logDir, { recursive: true })
-    this.rotate()
-    Object.freeze(this)
-  }
-
-  log(content: string, meta?: Record<string, string>): void {
-    const entry = {
-      timestamp: new Date(this.now()).toISOString(),
-      eventType: meta?.event_type ?? "unknown",
-      content: content.length > 2000 ? `${content.slice(0, 2000)}...` : content,
-      meta,
-    }
-    const dateStr = new Date(this.now()).toISOString().slice(0, 10)
-    const logFile = join(this.logDir, `${dateStr}.jsonl`)
-
-    this.fs.appendFileSync(logFile, `${JSON.stringify(entry)}\n`)
-  }
-
-  private rotate(): void {
-    const now = this.now()
-
-    for (const name of this.fs.readdirSync(this.logDir)) {
-      if (!name.endsWith(".jsonl")) continue
-
-      const path = join(this.logDir, name)
-
-      try {
-        const stat = this.fs.statSync(path)
-
-        if (now - stat.mtimeMs > MAX_AGE_MS) this.fs.unlink(path)
-      } catch {
-        // ignore
-      }
-    }
-  }
-}

package/lib/modules/gateway/funnel-gateway-server.ts

@@ -1,241 +0,0 @@
-import type { Server, ServerWebSocket } from "bun"
-import { Hono } from "hono"
-import type { FunnelConnectors } from "@/modules/connectors/funnel-connectors"
-import type { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { FunnelBroadcaster } from "@/modules/gateway/funnel-broadcaster"
-import { FunnelEventLogger } from "@/modules/gateway/funnel-event-logger"
-import { killCompetingSlackGateways } from "@/modules/gateway/kill-competing-slack-gateways"
-import { FunnelLogger } from "@/modules/logger/funnel-logger"
-import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
-import type { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
-import type { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
-import type { FunnelClock } from "@/modules/time/funnel-clock"
-
-const DEFAULT_PORT = 9742
-const DEFAULT_LOG_DIR = "/tmp/funnel/events"
-
-type Deps = {
-  connectors: FunnelConnectors
-  settings: FunnelSettingsReader
-  port?: number
-  logDir?: string
-  fs?: FunnelFileSystem
-  process?: FunnelProcessRunner
-  clock?: FunnelClock
-  logger?: FunnelLogger
-  selfPid?: number
-  killCompetingSlack?: boolean
-}
-
-type WsData = { channel: string; connectors: string[] }
-
-const defaultLogger = new NodeFunnelLogger()
-
-/**
- * In-process gateway: runs `Bun.serve` (HTTP + WebSocket /ws), boots all
- * connector listeners, fans events out via FunnelBroadcaster, and persists
- * them via FunnelEventLogger. Useful for embedding the gateway in a custom
- * host or driving it from tests.
- */
-export class FunnelGatewayServer {
-  private readonly connectors: FunnelConnectors
-  private readonly settings: FunnelSettingsReader
-  private readonly port: number
-  private readonly logDir: string
-  private readonly fs?: FunnelFileSystem
-  private readonly process?: FunnelProcessRunner
-  private readonly logger: FunnelLogger
-  private readonly selfPid: number
-  private readonly killCompetingSlack: boolean
-  private readonly broadcaster: FunnelBroadcaster
-  private readonly eventLogger: FunnelEventLogger
-  private server: Server<WsData> | null = null
-
-  constructor(deps: Deps) {
-    this.connectors = deps.connectors
-    this.settings = deps.settings
-    this.port = deps.port ?? DEFAULT_PORT
-    this.logDir = deps.logDir ?? DEFAULT_LOG_DIR
-    this.fs = deps.fs
-    this.process = deps.process
-    this.logger = deps.logger ?? defaultLogger
-    this.selfPid = deps.selfPid ?? globalThis.process.pid
-    this.killCompetingSlack = deps.killCompetingSlack ?? true
-    this.broadcaster = new FunnelBroadcaster()
-    this.eventLogger = new FunnelEventLogger({
-      logDir: this.logDir,
-      fs: this.fs,
-      now: deps.clock ? () => deps.clock!.millis() : undefined,
-    })
-  }
-
-  async start(): Promise<Server<WsData>> {
-    if (this.server) return this.server
-
-    const app = this.buildApp()
-
-    this.server = Bun.serve<WsData>({
-      port: this.port,
-      fetch: (request, server) => {
-        const url = new URL(request.url)
-
-        if (url.pathname === "/ws" && request.headers.get("upgrade") === "websocket") {
-          const channelName = url.searchParams.get("channel") ?? ""
-          const connectors = channelName ? this.resolveConnectors(channelName) : []
-          const data: WsData = { channel: channelName, connectors }
-          const upgraded = server.upgrade(request, { data })
-
-          if (upgraded) return undefined
-
-          return new Response("WebSocket upgrade failed", { status: 400 })
-        }
-
-        return app.fetch(request)
-      },
-      websocket: {
-        open: (ws: ServerWebSocket<WsData>) => {
-          const data = ws.data
-
-          this.broadcaster.addClient(ws, data)
-          this.eventLogger.log("channel connected", {
-            event_type: "system",
-            action: "channel_connect",
-            channel: data.channel,
-            connectors: data.connectors.join(","),
-            total: String(this.broadcaster.getClientCount()),
-          })
-        },
-        close: (ws: ServerWebSocket<WsData>) => {
-          this.broadcaster.removeClient(ws)
-          this.eventLogger.log("channel disconnected", {
-            event_type: "system",
-            action: "channel_disconnect",
-            total: String(this.broadcaster.getClientCount()),
-          })
-        },
-        message() {
-          // future: client → gateway messages
-        },
-      },
-    })
-
-    this.eventLogger.log("gateway started", {
-      event_type: "system",
-      action: "gateway_start",
-      port: String(this.port),
-      pid: String(this.selfPid),
-    })
-
-    this.logger.info("funnel gateway listening", {
-      url: `http://localhost:${this.port}`,
-      websocket: `ws://localhost:${this.port}/ws`,
-      health: `http://localhost:${this.port}/health`,
-    })
-
-    await this.bootListeners()
-
-    return this.server
-  }
-
-  stop(): void {
-    if (!this.server) return
-
-    this.server.stop()
-    this.server = null
-  }
-
-  getStatus(): { clients: number; channels: { channel: string; connectors: string[] }[] } {
-    return {
-      clients: this.broadcaster.getClientCount(),
-      channels: this.broadcaster.listChannels(),
-    }
-  }
-
-  getBroadcaster(): FunnelBroadcaster {
-    return this.broadcaster
-  }
-
-  private buildApp(): Hono {
-    const app = new Hono()
-
-    app.get("/health", (c) =>
-      c.json({
-        ok: true,
-        pid: this.selfPid,
-        clients: this.broadcaster.getClientCount(),
-      }),
-    )
-
-    app.get("/status", (c) =>
-      c.json({
-        ok: true,
-        clients: this.broadcaster.listChannels(),
-      }),
-    )
-
-    return app
-  }
-
-  private resolveConnectors(channelName: string): string[] {
-    const settings = this.settings.read()
-    const channel = settings?.channels.find((c) => c.name === channelName)
-
-    return channel?.connectors ?? []
-  }
-
-  private async bootListeners(): Promise<void> {
-    const allConnectors = this.connectors.list()
-
-    if (this.killCompetingSlack && allConnectors.some((c) => c.type === "slack")) {
-      const killed = await killCompetingSlackGateways({
-        selfPid: this.selfPid,
-        process: this.process,
-        logger: this.logger,
-      })
-
-      if (killed.length > 0) {
-        this.eventLogger.log("killed competing Slack gateway processes", {
-          event_type: "system",
-          action: "kill_competing",
-          pids: killed.join(","),
-        })
-      }
-    }
-
-    for (const { config, listener } of this.connectors.createListeners()) {
-      const bind = (content: string, meta?: Record<string, string>) =>
-        this.notify(config.name, content, meta)
-
-      try {
-        await listener.start(bind)
-
-        this.eventLogger.log(`${config.type} listener started: ${config.name}`, {
-          event_type: "system",
-          action: `${config.type}_connect`,
-          connector: config.name,
-        })
-
-        this.logger.info(`${config.type} listener started`, { connector: config.name })
-      } catch (error) {
-        this.logger.error(`${config.type} listener failed`, {
-          connector: config.name,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    }
-
-    this.logger.info(`event logs: ${this.logDir}`)
-    this.logger.info("funnel gateway running")
-  }
-
-  private async notify(
-    connectorName: string,
-    content: string,
-    meta?: Record<string, string>,
-  ): Promise<void> {
-    const withConnector: Record<string, string> = { ...meta, connector: connectorName }
-
-    this.eventLogger.log(content, withConnector)
-    this.broadcaster.broadcast(content, withConnector)
-  }
-}