@interactive-inc/claude-funnel 0.3.0 → 0.4.0

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
+  }
+}

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

@@ -0,0 +1,178 @@
+import { join } from "node:path"
+import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
+import { FunnelConnectorTypeStore } from "@/modules/connectors/funnel-connector-type-store"
+import { logger } from "@/modules/logger"
+import { DEFAULT_FUNNEL_DIR } from "@/modules/connectors/funnel-json-connector-store"
+import { FunnelScheduleListener } from "@/modules/connectors/funnel-schedule-listener"
+import { ScheduleLastFiredStore } from "@/modules/connectors/schedule-last-fired-store"
+import {
+  type ScheduleConnectorConfig,
+  type ScheduleEntry,
+  scheduleEntrySchema,
+} from "@/modules/connectors/schedule-connector-schema"
+import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
+
+type Deps = {
+  fs?: FunnelFileSystem
+  dir?: string
+}
+
+const defaultFs = new NodeFunnelFileSystem()
+
+export class FunnelScheduleStore extends FunnelConnectorTypeStore<ScheduleConnectorConfig> {
+  readonly type = "schedule" as const
+  private readonly fs: FunnelFileSystem
+  private readonly baseDir: string
+  private readonly dir: string
+
+  constructor(deps: Deps = {}) {
+    super()
+    this.fs = deps.fs ?? defaultFs
+    this.baseDir = deps.dir ?? DEFAULT_FUNNEL_DIR
+    this.dir = join(this.baseDir, "connectors", "schedule")
+    Object.freeze(this)
+  }
+
+  list(): ScheduleConnectorConfig[] {
+    if (!this.fs.existsSync(this.dir)) return []
+
+    const files = this.fs.readdirSync(this.dir).filter((f) => f.endsWith(".jsonl"))
+    const configs: ScheduleConnectorConfig[] = []
+
+    for (const file of files) {
+      const name = file.slice(0, -6)
+      const config = this.get(name)
+
+      if (config) configs.push(config)
+    }
+
+    return configs
+  }
+
+  get(name: string): ScheduleConnectorConfig | null {
+    const path = this.pathFor(name)
+
+    if (!this.fs.existsSync(path)) return null
+
+    return { type: "schedule", name, entries: this.readEntries(name) }
+  }
+
+  has(name: string): boolean {
+    return this.fs.existsSync(this.pathFor(name))
+  }
+
+  add(config: ScheduleConnectorConfig): void {
+    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
+
+    this.fs.mkdirSync(this.dir, { recursive: true })
+    const lines = config.entries.map((e) => JSON.stringify(e)).join("\n")
+    this.fs.writeFileSync(this.pathFor(config.name), lines ? `${lines}\n` : "")
+  }
+
+  remove(name: string): void {
+    if (!this.has(name)) throw new Error(`connector "${name}" not found`)
+
+    this.fs.unlink(this.pathFor(name))
+    this.fs.unlink(this.statePathFor(name))
+  }
+
+  rename(oldName: string, newName: string): void {
+    if (!this.has(oldName)) throw new Error(`connector "${oldName}" not found`)
+    if (this.has(newName)) throw new Error(`connector "${newName}" already exists`)
+
+    const content = this.fs.readFileSync(this.pathFor(oldName))
+    this.fs.writeFileSync(this.pathFor(newName), content)
+    this.fs.unlink(this.pathFor(oldName))
+
+    if (this.fs.existsSync(this.statePathFor(oldName))) {
+      const state = this.fs.readFileSync(this.statePathFor(oldName))
+      this.fs.writeFileSync(this.statePathFor(newName), state)
+      this.fs.unlink(this.statePathFor(oldName))
+    }
+  }
+
+  addEntry(name: string, entry: Omit<ScheduleEntry, "id"> & { id?: string }): ScheduleEntry {
+    if (!this.has(name)) throw new Error(`connector "${name}" not found`)
+
+    const full: ScheduleEntry = {
+      id: entry.id ?? crypto.randomUUID(),
+      cron: entry.cron,
+      prompt: entry.prompt,
+      enabled: entry.enabled ?? true,
+    }
+
+    this.fs.appendFileSync(this.pathFor(name), `${JSON.stringify(full)}\n`)
+
+    return full
+  }
+
+  removeEntry(name: string, id: string): void {
+    const entries = this.readEntries(name)
+    const next = entries.filter((e) => e.id !== id)
+
+    if (next.length === entries.length) throw new Error(`schedule entry "${id}" not found`)
+
+    const content = next.map((e) => JSON.stringify(e)).join("\n")
+    this.fs.writeFileSync(this.pathFor(name), content ? `${content}\n` : "")
+  }
+
+  createListener(config: ScheduleConnectorConfig): FunnelConnectorListener {
+    return new FunnelScheduleListener({
+      config,
+      store: this,
+      lastFiredStore: this.createLastFiredStore(config.name),
+    })
+  }
+
+  private createLastFiredStore(name: string): ScheduleLastFiredStore {
+    return new ScheduleLastFiredStore({ connector: name, fs: this.fs, dir: this.baseDir })
+  }
+
+  private pathFor(name: string): string {
+    return join(this.dir, `${name}.jsonl`)
+  }
+
+  private statePathFor(name: string): string {
+    return join(this.dir, `${name}.state.json`)
+  }
+
+  private readEntries(name: string): ScheduleEntry[] {
+    const path = this.pathFor(name)
+
+    if (!this.fs.existsSync(path)) return []
+
+    const content = this.fs.readFileSync(path)
+    const lines = content.split("\n").filter((l) => l.trim().length > 0)
+    const entries: ScheduleEntry[] = []
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]!
+      const lineNumber = i + 1
+
+      try {
+        const parsed = JSON.parse(line)
+        const result = scheduleEntrySchema.safeParse(parsed)
+
+        if (!result.success) {
+          logger.warn("skipping invalid schedule entry", {
+            connector: name,
+            line: lineNumber,
+            issues: result.error.issues.map((iss) => `${iss.path.join(".")}: ${iss.message}`),
+          })
+          continue
+        }
+
+        entries.push(result.data)
+      } catch (error) {
+        logger.warn("skipping unparseable schedule entry", {
+          connector: name,
+          line: lineNumber,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    }
+
+    return entries
+  }
+}

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

@@ -3,7 +3,7 @@ import {
   FunnelConnectorAdapter,
   type CallInput,
 } from "@/modules/connectors/funnel-connector-adapter"
-import type { SlackConnectorConfig } from "@/modules/settings/settings-schema"
+import type { SlackConnectorConfig } from "@/modules/connectors/slack-connector-schema"
 
 export type SlackWebClientLike = {
   apiCall: (method: string, options: Record<string, unknown>) => Promise<unknown>

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

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

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

@@ -0,0 +1,86 @@
+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"
+
+type Deps = {
+  fs?: FunnelFileSystem
+  dir?: string
+}
+
+export type SlackUpdateFields = {
+  botToken?: string
+  appToken?: string
+}
+
+export class FunnelSlackStore extends FunnelCallableConnectorStore<SlackConnectorConfig> {
+  readonly type = "slack" as const
+  private readonly store: FunnelJsonConnectorStore<SlackConnectorConfig>
+
+  constructor(deps: Deps = {}) {
+    super()
+    this.store = new FunnelJsonConnectorStore<SlackConnectorConfig>({
+      type: "slack",
+      schema: slackConnectorSchema,
+      fs: deps.fs,
+      dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
+    })
+    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 })
+  }
+
+  createAdapter(config: SlackConnectorConfig): FunnelConnectorAdapter {
+    return new FunnelSlackAdapter({ config })
+  }
+}

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

@@ -0,0 +1,9 @@
+import { z } from "zod"
+
+export const ghConnectorSchema = z.object({
+  type: z.literal("gh"),
+  name: z.string(),
+  pollInterval: z.number().int().positive().optional(),
+})
+
+export type GhConnectorConfig = z.infer<typeof ghConnectorSchema>