@interactive-inc/claude-funnel 0.2.0 → 0.4.0

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

@@ -1,124 +1,145 @@
+import type { ChannelConnectorRefUpdater } from "@/modules/channels/channel-connector-ref-updater"
+import type { ConnectorConfig } from "@/modules/connectors/connector-config-schema"
 import type { CallInput } from "@/modules/connectors/funnel-connector-adapter"
-import { FunnelDiscordAdapter } from "@/modules/connectors/funnel-discord-adapter"
-import { FunnelGhAdapter } from "@/modules/connectors/funnel-gh-adapter"
-import { FunnelSlackAdapter } from "@/modules/connectors/funnel-slack-adapter"
-import { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
-import type { ConnectorConfig } from "@/modules/settings/settings-schema"
+import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
+import type {
+  DiscordUpdateFields,
+  FunnelDiscordStore,
+} from "@/modules/connectors/funnel-discord-store"
+import type { FunnelGhStore, GhUpdateFields } from "@/modules/connectors/funnel-gh-store"
+import type { FunnelScheduleStore } from "@/modules/connectors/funnel-schedule-store"
+import type { FunnelSlackStore, SlackUpdateFields } from "@/modules/connectors/funnel-slack-store"
 
 type Deps = {
-  store: FunnelSettingsReader
-}
-
-type UpdateFields = {
-  botToken?: string
-  appToken?: string
-  pollInterval?: number
+  slack: FunnelSlackStore
+  gh: FunnelGhStore
+  discord: FunnelDiscordStore
+  schedule: FunnelScheduleStore
+  refUpdater: ChannelConnectorRefUpdater
 }
 
 export class FunnelConnectors {
-  private readonly store: FunnelSettingsReader
+  private readonly slack: FunnelSlackStore
+  private readonly gh: FunnelGhStore
+  private readonly discord: FunnelDiscordStore
+  private readonly schedule: FunnelScheduleStore
+  private readonly refUpdater: ChannelConnectorRefUpdater
 
   constructor(deps: Deps) {
-    this.store = deps.store
+    this.slack = deps.slack
+    this.gh = deps.gh
+    this.discord = deps.discord
+    this.schedule = deps.schedule
+    this.refUpdater = deps.refUpdater
     Object.freeze(this)
   }
 
   list(): ConnectorConfig[] {
-    return this.store.read().connectors
+    return [
+      ...this.slack.list(),
+      ...this.gh.list(),
+      ...this.discord.list(),
+      ...this.schedule.list(),
+    ]
   }
 
   get(name: string): ConnectorConfig | null {
-    return this.list().find((c) => c.name === name) ?? null
+    return (
+      this.slack.get(name) ??
+      this.gh.get(name) ??
+      this.discord.get(name) ??
+      this.schedule.get(name)
+    )
   }
 
-  add(config: ConnectorConfig): void {
-    const settings = this.store.read()
+  has(name: string): boolean {
+    return (
+      this.slack.has(name) ||
+      this.gh.has(name) ||
+      this.discord.has(name) ||
+      this.schedule.has(name)
+    )
+  }
 
-    if (settings.connectors.some((c) => c.name === config.name)) {
-      throw new Error(`connector "${config.name}" already exists`)
-    }
+  add(config: ConnectorConfig): void {
+    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
 
-    settings.connectors.push(config)
+    if (config.type === "slack") return this.slack.add(config)
+    if (config.type === "gh") return this.gh.add(config)
+    if (config.type === "discord") return this.discord.add(config)
 
-    this.store.write(settings)
+    return this.schedule.add(config)
   }
 
-  rename(oldName: string, newName: string): void {
-    const settings = this.store.read()
-
-    const connector = settings.connectors.find((c) => c.name === oldName)
+  updateSlack(name: string, fields: SlackUpdateFields): void {
+    this.slack.update(name, fields)
+  }
 
-    if (!connector) throw new Error(`connector "${oldName}" not found`)
+  updateGh(name: string, fields: GhUpdateFields): void {
+    this.gh.update(name, fields)
+  }
 
-    if (settings.connectors.some((c) => c.name === newName)) {
-      throw new Error(`connector "${newName}" already exists`)
-    }
+  updateDiscord(name: string, fields: DiscordUpdateFields): void {
+    this.discord.update(name, fields)
+  }
 
-    connector.name = newName
+  remove(name: string): void {
+    const current = this.get(name)
 
-    for (const channel of settings.channels) {
-      const index = channel.connectors.indexOf(oldName)
+    if (!current) throw new Error(`connector "${name}" not found`)
 
-      if (index >= 0) channel.connectors[index] = newName
-    }
+    if (current.type === "slack") this.slack.remove(name)
+    else if (current.type === "gh") this.gh.remove(name)
+    else if (current.type === "discord") this.discord.remove(name)
+    else this.schedule.remove(name)
 
-    this.store.write(settings)
+    this.refUpdater.removeRef(name)
   }
 
-  update(name: string, fields: UpdateFields): void {
-    const settings = this.store.read()
-
-    const connector = settings.connectors.find((c) => c.name === name)
+  rename(oldName: string, newName: string): void {
+    const current = this.get(oldName)
 
-    if (!connector) throw new Error(`connector "${name}" not found`)
+    if (!current) throw new Error(`connector "${oldName}" not found`)
+    if (this.has(newName)) throw new Error(`connector "${newName}" already exists`)
 
-    if (connector.type === "slack") {
-      if (fields.botToken !== undefined) connector.botToken = fields.botToken
-      if (fields.appToken !== undefined) connector.appToken = fields.appToken
-    } else if (connector.type === "gh") {
-      if (fields.pollInterval !== undefined) connector.pollInterval = fields.pollInterval
-    } else if (connector.type === "discord") {
-      if (fields.botToken !== undefined) connector.botToken = fields.botToken
-    }
+    if (current.type === "slack") this.slack.rename(oldName, newName)
+    else if (current.type === "gh") this.gh.rename(oldName, newName)
+    else if (current.type === "discord") this.discord.rename(oldName, newName)
+    else this.schedule.rename(oldName, newName)
 
-    this.store.write(settings)
+    this.refUpdater.renameRef(oldName, newName)
   }
 
-  remove(name: string): void {
-    const settings = this.store.read()
-
-    const index = settings.connectors.findIndex((c) => c.name === name)
+  async callSlack(name: string, input: CallInput): Promise<unknown> {
+    const config = this.slack.get(name)
 
-    if (index < 0) throw new Error(`connector "${name}" not found`)
+    if (!config) throw new Error(`slack connector "${name}" not found`)
 
-    settings.connectors.splice(index, 1)
+    return await this.slack.createAdapter(config).call(input)
+  }
 
-    for (const channel of settings.channels) {
-      const ci = channel.connectors.indexOf(name)
+  async callGh(name: string, input: CallInput): Promise<unknown> {
+    const config = this.gh.get(name)
 
-      if (ci >= 0) channel.connectors.splice(ci, 1)
-    }
+    if (!config) throw new Error(`gh connector "${name}" not found`)
 
-    this.store.write(settings)
+    return await this.gh.createAdapter(config).call(input)
   }
 
-  async call(name: string, input: CallInput): Promise<unknown> {
-    const connector = this.get(name)
-
-    if (!connector) throw new Error(`connector "${name}" not found`)
+  async callDiscord(name: string, input: CallInput): Promise<unknown> {
+    const config = this.discord.get(name)
 
-    if (connector.type === "slack") {
-      return await new FunnelSlackAdapter({ config: connector }).call(input)
-    }
+    if (!config) throw new Error(`discord connector "${name}" not found`)
 
-    if (connector.type === "gh") {
-      return await new FunnelGhAdapter().call(input)
-    }
-
-    if (connector.type === "discord") {
-      return await new FunnelDiscordAdapter({ config: connector }).call(input)
-    }
+    return await this.discord.createAdapter(config).call(input)
+  }
 
-    throw new Error(`unsupported connector type: ${(connector as { type: string }).type}`)
+  createListeners(): { config: ConnectorConfig; listener: FunnelConnectorListener }[] {
+    return [
+      ...this.slack.createAllListeners(),
+      ...this.gh.createAllListeners(),
+      ...this.discord.createAllListeners(),
+      ...this.schedule.createAllListeners(),
+    ]
   }
 }

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

@@ -4,7 +4,7 @@ import {
 } from "@/modules/connectors/funnel-connector-adapter"
 import { FunnelHttpClient } from "@/modules/http/funnel-http-client"
 import { NodeFunnelHttpClient } from "@/modules/http/node-funnel-http-client"
-import type { DiscordConnectorConfig } from "@/modules/settings/settings-schema"
+import type { DiscordConnectorConfig } from "@/modules/connectors/discord-connector-schema"
 
 const DISCORD_API_BASE = "https://discord.com/api/v10"
 

package/lib/modules/connectors/funnel-discord-listener.ts

@@ -5,7 +5,7 @@ import {
 } from "@/modules/connectors/funnel-connector-listener"
 import { FunnelDiscordEventProcessor } from "@/modules/connectors/funnel-discord-event-processor"
 import { logger } from "@/modules/logger"
-import type { DiscordConnectorConfig } from "@/modules/settings/settings-schema"
+import type { DiscordConnectorConfig } from "@/modules/connectors/discord-connector-schema"
 
 type Deps = {
   config: DiscordConnectorConfig

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

@@ -0,0 +1,84 @@
+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 { FunnelDiscordAdapter } from "@/modules/connectors/funnel-discord-adapter"
+import { FunnelDiscordListener } from "@/modules/connectors/funnel-discord-listener"
+import {
+  type DiscordConnectorConfig,
+  discordConnectorSchema,
+} from "@/modules/connectors/discord-connector-schema"
+import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+
+type Deps = {
+  fs?: FunnelFileSystem
+  dir?: string
+}
+
+export type DiscordUpdateFields = {
+  botToken?: string
+}
+
+export class FunnelDiscordStore extends FunnelCallableConnectorStore<DiscordConnectorConfig> {
+  readonly type = "discord" as const
+  private readonly store: FunnelJsonConnectorStore<DiscordConnectorConfig>
+
+  constructor(deps: Deps = {}) {
+    super()
+    this.store = new FunnelJsonConnectorStore<DiscordConnectorConfig>({
+      type: "discord",
+      schema: discordConnectorSchema,
+      fs: deps.fs,
+      dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
+    })
+    Object.freeze(this)
+  }
+
+  list(): DiscordConnectorConfig[] {
+    return this.store.list()
+  }
+
+  get(name: string): DiscordConnectorConfig | null {
+    return this.store.get(name)
+  }
+
+  has(name: string): boolean {
+    return this.store.has(name)
+  }
+
+  add(config: DiscordConnectorConfig): void {
+    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
+
+    this.store.write(config)
+  }
+
+  update(name: string, fields: DiscordUpdateFields): 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,
+    })
+  }
+
+  remove(name: string): void {
+    this.store.remove(name)
+  }
+
+  rename(oldName: string, newName: string): void {
+    this.store.rename(oldName, newName)
+  }
+
+  createListener(config: DiscordConnectorConfig): FunnelConnectorListener {
+    return new FunnelDiscordListener({ config })
+  }
+
+  createAdapter(config: DiscordConnectorConfig): FunnelConnectorAdapter {
+    return new FunnelDiscordAdapter({ config })
+  }
+}

package/lib/modules/connectors/funnel-gh-listener.ts

@@ -5,7 +5,7 @@ import {
 import { logger } from "@/modules/logger"
 import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
 import { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-process-runner"
-import type { GhConnectorConfig } from "@/modules/settings/settings-schema"
+import type { GhConnectorConfig } from "@/modules/connectors/gh-connector-schema"
 
 type GhNotification = {
   id: string

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

@@ -0,0 +1,84 @@
+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 { FunnelGhAdapter } from "@/modules/connectors/funnel-gh-adapter"
+import { FunnelGhListener } from "@/modules/connectors/funnel-gh-listener"
+import {
+  type GhConnectorConfig,
+  ghConnectorSchema,
+} from "@/modules/connectors/gh-connector-schema"
+import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+
+type Deps = {
+  fs?: FunnelFileSystem
+  dir?: string
+}
+
+export type GhUpdateFields = {
+  pollInterval?: number
+}
+
+export class FunnelGhStore extends FunnelCallableConnectorStore<GhConnectorConfig> {
+  readonly type = "gh" as const
+  private readonly store: FunnelJsonConnectorStore<GhConnectorConfig>
+
+  constructor(deps: Deps = {}) {
+    super()
+    this.store = new FunnelJsonConnectorStore<GhConnectorConfig>({
+      type: "gh",
+      schema: ghConnectorSchema,
+      fs: deps.fs,
+      dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
+    })
+    Object.freeze(this)
+  }
+
+  list(): GhConnectorConfig[] {
+    return this.store.list()
+  }
+
+  get(name: string): GhConnectorConfig | null {
+    return this.store.get(name)
+  }
+
+  has(name: string): boolean {
+    return this.store.has(name)
+  }
+
+  add(config: GhConnectorConfig): void {
+    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
+
+    this.store.write(config)
+  }
+
+  update(name: string, fields: GhUpdateFields): void {
+    const current = this.store.get(name)
+
+    if (!current) throw new Error(`connector "${name}" not found`)
+
+    this.store.write({
+      ...current,
+      pollInterval: fields.pollInterval ?? current.pollInterval,
+    })
+  }
+
+  remove(name: string): void {
+    this.store.remove(name)
+  }
+
+  rename(oldName: string, newName: string): void {
+    this.store.rename(oldName, newName)
+  }
+
+  createListener(config: GhConnectorConfig): FunnelConnectorListener {
+    return new FunnelGhListener({ config })
+  }
+
+  createAdapter(_config: GhConnectorConfig): FunnelConnectorAdapter {
+    return new FunnelGhAdapter()
+  }
+}

package/lib/modules/connectors/funnel-json-connector-store.ts

@@ -0,0 +1,100 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+import type { ZodType } from "zod"
+import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
+
+const defaultFs = new NodeFunnelFileSystem()
+
+export const DEFAULT_FUNNEL_DIR = join(homedir(), ".funnel")
+
+type Props<TConfig> = {
+  type: string
+  schema: ZodType<TConfig>
+  fs?: FunnelFileSystem
+  dir?: string
+}
+
+export class FunnelJsonConnectorStore<TConfig extends { type: string; name: string }> {
+  private readonly type: string
+  private readonly schema: ZodType<TConfig>
+  private readonly fs: FunnelFileSystem
+  private readonly dir: string
+
+  constructor(props: Props<TConfig>) {
+    this.type = props.type
+    this.schema = props.schema
+    this.fs = props.fs ?? defaultFs
+    const base = props.dir ?? DEFAULT_FUNNEL_DIR
+    this.dir = join(base, "connectors", props.type)
+    Object.freeze(this)
+  }
+
+  list(): TConfig[] {
+    if (!this.fs.existsSync(this.dir)) return []
+
+    const files = this.fs.readdirSync(this.dir).filter((f) => f.endsWith(".json"))
+    const configs: TConfig[] = []
+
+    for (const file of files) {
+      const name = file.slice(0, -5)
+      const config = this.get(name)
+
+      if (config) configs.push(config)
+    }
+
+    return configs
+  }
+
+  get(name: string): TConfig | null {
+    const path = this.pathFor(name)
+
+    if (!this.fs.existsSync(path)) return null
+
+    const content = this.fs.readFileSync(path)
+    const parsed = JSON.parse(content)
+    const result = this.schema.safeParse(parsed)
+
+    if (!result.success) {
+      throw new Error(
+        `invalid ${this.type} connector "${name}": ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`,
+      )
+    }
+
+    return result.data
+  }
+
+  has(name: string): boolean {
+    return this.fs.existsSync(this.pathFor(name))
+  }
+
+  write(config: TConfig): void {
+    this.fs.mkdirSync(this.dir, { recursive: true })
+    this.fs.writeFileSync(this.pathFor(config.name), `${JSON.stringify(config, null, 2)}\n`)
+  }
+
+  remove(name: string): void {
+    if (!this.has(name)) throw new Error(`connector "${name}" not found`)
+
+    this.fs.unlink(this.pathFor(name))
+  }
+
+  rename(oldName: string, newName: string): void {
+    const config = this.get(oldName)
+
+    if (!config) throw new Error(`connector "${oldName}" not found`)
+
+    if (this.has(newName)) {
+      throw new Error(`connector "${newName}" already exists`)
+    }
+
+    const renamed = { ...config, name: newName } as TConfig
+
+    this.write(renamed)
+    this.fs.unlink(this.pathFor(oldName))
+  }
+
+  pathFor(name: string): string {
+    return join(this.dir, `${name}.json`)
+  }
+}

package/lib/modules/connectors/funnel-schedule-listener.ts

@@ -0,0 +1,124 @@
+import {
+  FunnelConnectorListener,
+  type NotifyFn,
+} from "@/modules/connectors/funnel-connector-listener"
+import { FunnelScheduleStore } from "@/modules/connectors/funnel-schedule-store"
+import { matchCron } from "@/modules/connectors/match-cron"
+import { ScheduleLastFiredStore } from "@/modules/connectors/schedule-last-fired-store"
+import { logger } from "@/modules/logger"
+import type { ScheduleConnectorConfig } from "@/modules/connectors/schedule-connector-schema"
+
+type Deps = {
+  config: ScheduleConnectorConfig
+  store: FunnelScheduleStore
+  lastFiredStore: ScheduleLastFiredStore
+  now?: () => Date
+}
+
+const MAX_CATCHUP_MINUTES = 60 * 24
+
+export class FunnelScheduleListener extends FunnelConnectorListener {
+  private readonly config: ScheduleConnectorConfig
+  private readonly store: FunnelScheduleStore
+  private readonly lastFiredStore: ScheduleLastFiredStore
+  private readonly now: () => Date
+
+  constructor(deps: Deps) {
+    super()
+    this.config = deps.config
+    this.store = deps.store
+    this.lastFiredStore = deps.lastFiredStore
+    this.now = deps.now ?? (() => new Date())
+    Object.freeze(this)
+  }
+
+  async start(notify: NotifyFn): Promise<void> {
+    const scheduleNext = () => {
+      const date = this.now()
+      const msUntilNextMinute = 60_000 - (date.getSeconds() * 1000 + date.getMilliseconds())
+      const timer = setTimeout(async () => {
+        await this.tick(notify)
+        scheduleNext()
+      }, msUntilNextMinute)
+
+      timer.unref()
+    }
+
+    await this.tick(notify)
+    scheduleNext()
+  }
+
+  async tick(notify: NotifyFn): Promise<void> {
+    const config = this.store.get(this.config.name)
+
+    if (!config) return
+
+    const now = this.truncateToMinute(this.now())
+    const state = this.lastFiredStore.load()
+    let changed = false
+
+    for (const entry of config.entries) {
+      if (!entry.enabled) continue
+
+      const lastFired = state.get(entry.id)
+      const searchFrom = lastFired ? new Date(lastFired.getTime() + 60_000) : now
+
+      if (searchFrom.getTime() > now.getTime()) continue
+
+      const match = this.findMostRecentMatch(entry.cron, searchFrom, now, entry.id)
+
+      if (!match) continue
+
+      const meta: Record<string, string> = {
+        event_type: "schedule",
+        schedule_id: entry.id,
+        cron: entry.cron,
+        fired_at: match.toISOString(),
+      }
+
+      if (match.getTime() !== now.getTime()) meta.catchup = "true"
+
+      await notify(entry.prompt, meta)
+      state.set(entry.id, match)
+      changed = true
+    }
+
+    if (changed) this.lastFiredStore.save(state)
+  }
+
+  private findMostRecentMatch(
+    cron: string,
+    from: Date,
+    until: Date,
+    entryId: string,
+  ): Date | null {
+    const maxIterations = Math.min(
+      MAX_CATCHUP_MINUTES,
+      Math.floor((until.getTime() - from.getTime()) / 60_000) + 1,
+    )
+
+    for (let i = 0; i < maxIterations; i++) {
+      const candidate = new Date(until.getTime() - i * 60_000)
+
+      try {
+        if (matchCron(cron, candidate)) return candidate
+      } catch (error) {
+        logger.error("invalid cron expression in schedule", {
+          connector: this.config.name,
+          id: entryId,
+          cron,
+          error: error instanceof Error ? error.message : String(error),
+        })
+        return null
+      }
+    }
+
+    return null
+  }
+
+  private truncateToMinute(date: Date): Date {
+    const copy = new Date(date.getTime())
+    copy.setSeconds(0, 0)
+    return copy
+  }
+}