@interactive-inc/claude-funnel 0.10.0 → 0.10.1

package/lib/connectors/schedule-listener.ts

@@ -1,207 +0,0 @@
-import { FunnelConnectorListener, type NotifyFn } from "@/connectors/connector-listener"
-import { matchCron } from "@/connectors/match-cron"
-import { ScheduleStateStore } from "@/connectors/schedule-state-store"
-import { FunnelLogger } from "@/engine/logger/logger"
-import { NodeFunnelLogger } from "@/engine/logger/node-logger"
-import type { ScheduleConnectorConfig, ScheduleEntry } from "@/connectors/schedule-connector-schema"
-
-type Deps = {
-  config: ScheduleConnectorConfig
-  lastFiredStore: ScheduleStateStore
-  logger?: FunnelLogger
-  now?: () => Date
-}
-
-const defaultLogger = new NodeFunnelLogger()
-
-const MAX_CATCHUP_MINUTES = 60 * 24
-
-export class FunnelScheduleListener extends FunnelConnectorListener {
-  private readonly config: ScheduleConnectorConfig
-  private readonly lastFiredStore: ScheduleStateStore
-  private readonly logger: FunnelLogger
-  private readonly now: () => Date
-  private timer: ReturnType<typeof setTimeout> | null = null
-  private stopped = false
-
-  constructor(deps: Deps) {
-    super()
-    this.config = deps.config
-    this.lastFiredStore = deps.lastFiredStore
-    this.logger = deps.logger ?? defaultLogger
-    this.now = deps.now ?? (() => new Date())
-  }
-
-  async start(notify: NotifyFn): Promise<void> {
-    this.stopped = false
-
-    const scheduleNext = () => {
-      if (this.stopped) return
-
-      const date = this.now()
-      const msUntilNextMinute = 60_000 - (date.getSeconds() * 1000 + date.getMilliseconds())
-      this.timer = setTimeout(async () => {
-        if (this.stopped) return
-        await this.tick(notify)
-        scheduleNext()
-      }, msUntilNextMinute)
-
-      this.timer.unref()
-    }
-
-    await this.tick(notify)
-    scheduleNext()
-  }
-
-  async stop(): Promise<void> {
-    this.stopped = true
-
-    if (this.timer) {
-      clearTimeout(this.timer)
-      this.timer = null
-    }
-  }
-
-  override isAlive(): boolean {
-    return !this.stopped && this.timer !== null
-  }
-
-  async tick(notify: NotifyFn): Promise<void> {
-    const now = this.truncateToMinute(this.now())
-    const state = this.lastFiredStore.load()
-    let changed = false
-
-    for (const entry of this.config.entries) {
-      if (!entry.enabled) continue
-
-      const fired = await this.fireEntry(entry, now, state, notify)
-
-      if (fired) changed = true
-    }
-
-    if (changed) this.lastFiredStore.save(state)
-  }
-
-  private async fireEntry(
-    entry: ScheduleEntry,
-    now: Date,
-    state: Map<string, Date>,
-    notify: NotifyFn,
-  ): Promise<boolean> {
-    const lastFired = state.get(entry.id)
-    const searchFrom = lastFired ? new Date(lastFired.getTime() + 60_000) : now
-
-    if (searchFrom.getTime() > now.getTime()) return false
-
-    if (entry.catchupPolicy === "skip") {
-      try {
-        if (!matchCron(entry.cron, now)) return false
-      } catch (error) {
-        this.logInvalidCron(entry, error)
-        return false
-      }
-
-      await this.notifyOne(entry, now, notify, false)
-      state.set(entry.id, now)
-      return true
-    }
-
-    if (entry.catchupPolicy === "all") {
-      const matches = this.findAllMatches(entry.cron, searchFrom, now, entry.id)
-
-      if (matches.length === 0) return false
-
-      for (const match of matches) {
-        await this.notifyOne(entry, match, notify, match.getTime() !== now.getTime())
-      }
-
-      state.set(entry.id, matches[matches.length - 1] ?? now)
-      return true
-    }
-
-    const match = this.findMostRecentMatch(entry.cron, searchFrom, now, entry.id)
-
-    if (!match) return false
-
-    await this.notifyOne(entry, match, notify, match.getTime() !== now.getTime())
-    state.set(entry.id, match)
-    return true
-  }
-
-  private async notifyOne(
-    entry: ScheduleEntry,
-    firedAt: Date,
-    notify: NotifyFn,
-    catchup: boolean,
-  ): Promise<void> {
-    const meta: Record<string, string> = {
-      event_type: "schedule",
-      schedule_id: entry.id,
-      cron: entry.cron,
-      fired_at: firedAt.toISOString(),
-      catchup_policy: entry.catchupPolicy,
-    }
-
-    if (catchup) meta.catchup = "true"
-
-    await notify(entry.prompt, meta)
-  }
-
-  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) {
-        this.logInvalidCron({ id: entryId, cron } as ScheduleEntry, error)
-        return null
-      }
-    }
-
-    return null
-  }
-
-  private findAllMatches(cron: string, from: Date, until: Date, entryId: string): Date[] {
-    const maxIterations = Math.min(
-      MAX_CATCHUP_MINUTES,
-      Math.floor((until.getTime() - from.getTime()) / 60_000) + 1,
-    )
-    const matches: Date[] = []
-
-    for (let i = 0; i < maxIterations; i++) {
-      const candidate = new Date(from.getTime() + i * 60_000)
-
-      if (candidate.getTime() > until.getTime()) break
-
-      try {
-        if (matchCron(cron, candidate)) matches.push(candidate)
-      } catch (error) {
-        this.logInvalidCron({ id: entryId, cron } as ScheduleEntry, error)
-        return []
-      }
-    }
-
-    return matches
-  }
-
-  private logInvalidCron(entry: Pick<ScheduleEntry, "id" | "cron">, error: unknown): void {
-    this.logger.error("invalid cron expression in schedule", {
-      connector: this.config.name,
-      id: entry.id,
-      cron: entry.cron,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-
-  private truncateToMinute(date: Date): Date {
-    const copy = new Date(date.getTime())
-    copy.setSeconds(0, 0)
-    return copy
-  }
-}

package/lib/connectors/schedule-state-store.ts

@@ -1,54 +0,0 @@
-import { dirname } from "node:path"
-import { FunnelFileSystem } from "@/engine/fs/file-system"
-import { NodeFunnelFileSystem } from "@/engine/fs/node-file-system"
-
-type Deps = {
-  path: string
-  fs?: FunnelFileSystem
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-
-/**
- * Per-connector lastFiredAt persistence for the schedule listener. The path is
- * passed in by FunnelConnectorFactory so this store does not know about the
- * funnel directory layout (`channels/<id>/connectors/<id>/state.json` lives
- * outside this class).
- */
-export class ScheduleStateStore {
-  private readonly path: string
-  private readonly fs: FunnelFileSystem
-
-  constructor(deps: Deps) {
-    this.path = deps.path
-    this.fs = deps.fs ?? defaultFs
-    Object.freeze(this)
-  }
-
-  load(): Map<string, Date> {
-    const map = new Map<string, Date>()
-
-    if (!this.fs.existsSync(this.path)) return map
-
-    const raw: unknown = JSON.parse(this.fs.readFileSync(this.path))
-
-    if (raw === null || typeof raw !== "object") return map
-
-    for (const [id, iso] of Object.entries(raw)) {
-      if (typeof iso === "string") 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/connectors/schedule.ts

@@ -1,4 +0,0 @@
-export * from "@/connectors/match-cron"
-export * from "@/connectors/schedule-connector-schema"
-export * from "@/connectors/schedule-listener"
-export * from "@/connectors/schedule-state-store"

package/lib/connectors/slack-adapter.ts

@@ -1,36 +0,0 @@
-import { WebClient } from "@slack/web-api"
-import { FunnelConnectorAdapter, type CallInput } from "@/connectors/connector-adapter"
-import type { SlackConnectorConfig } from "@/connectors/slack-connector-schema"
-
-export type SlackWebClientLike = {
-  apiCall: (method: string, options?: Record<string, unknown>) => Promise<unknown>
-}
-
-const toRecord = (value: object): Record<string, unknown> => {
-  const result: Record<string, unknown> = {}
-
-  for (const [key, val] of Object.entries(value)) result[key] = val
-
-  return result
-}
-
-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 !== null && typeof input.body === "object" ? toRecord(input.body) : {}
-
-    return await this.client.apiCall(input.path, body)
-  }
-}

package/lib/connectors/slack-connector-schema.ts

@@ -1,13 +0,0 @@
-import { z } from "zod"
-
-export const slackConnectorSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  type: z.literal("slack"),
-  botToken: z.string().startsWith("xoxb-"),
-  appToken: z.string().startsWith("xapp-"),
-  createdAt: z.string().datetime().optional(),
-  updatedAt: z.string().datetime().optional(),
-})
-
-export type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>

package/lib/connectors/slack-event-processor.ts

@@ -1,97 +0,0 @@
-export type SlackRawEvent = Record<string, unknown>
-
-export type SlackProcessedSkip = { skip: true }
-
-export type SlackProcessedEmit = {
-  skip: false
-  content: string
-  meta: Record<string, string>
-  shouldReact: boolean
-  channel: string
-  timestamp: string
-}
-
-export type SlackProcessed = SlackProcessedSkip | SlackProcessedEmit
-
-const ALLOWED_EVENTS = new Set(["message", "app_mention"])
-const ALLOWED_SUBTYPES = new Set<string | undefined>([
-  undefined,
-  "thread_broadcast",
-  "bot_message",
-  "file_share",
-])
-
-const DEDUP_WINDOW = 10_000
-
-type Props = {
-  ownBotUserId: string
-  ownBotId: string
-  now?: () => number
-}
-
-const getString = (event: SlackRawEvent, key: string): string | undefined => {
-  const value = event[key]
-
-  return typeof value === "string" ? value : undefined
-}
-
-export class FunnelSlackEventProcessor {
-  private readonly ownBotUserId: string
-  private readonly ownBotId: string
-  private readonly now: () => number
-  private readonly dedup = new Map<string, number>()
-
-  constructor(props: Props) {
-    this.ownBotUserId = props.ownBotUserId
-    this.ownBotId = props.ownBotId
-    this.now = props.now ?? (() => Date.now())
-  }
-
-  process(event: SlackRawEvent): SlackProcessed {
-    const eventType = getString(event, "type")
-
-    if (!eventType || !ALLOWED_EVENTS.has(eventType)) return { skip: true }
-
-    const subtype = getString(event, "subtype")
-
-    if (!ALLOWED_SUBTYPES.has(subtype)) return { skip: true }
-
-    const channelId = getString(event, "channel") ?? ""
-    const eventTs = getString(event, "event_ts") ?? getString(event, "ts") ?? ""
-    const dedupKey = `${channelId}:${eventTs}`
-    const now = this.now()
-
-    if (this.dedup.has(dedupKey)) return { skip: true }
-
-    this.dedup.set(dedupKey, now)
-
-    for (const key of this.dedup.keys()) {
-      if ((this.dedup.get(key) ?? 0) < now - DEDUP_WINDOW) this.dedup.delete(key)
-    }
-
-    const userId = getString(event, "user")
-    const botId = getString(event, "bot_id")
-
-    if (userId === this.ownBotUserId) return { skip: true }
-    if (botId === this.ownBotId) return { skip: true }
-
-    const text = getString(event, "text") ?? ""
-    const mentioned = text.includes(`<@${this.ownBotUserId}>`)
-    const threadTs = getString(event, "thread_ts") ?? getString(event, "ts") ?? ""
-
-    return {
-      skip: false,
-      content: JSON.stringify(event),
-      meta: {
-        event_type: "slack",
-        channel_id: channelId,
-        user_id: userId ?? "",
-        mentioned: String(mentioned),
-        thread_ts: threadTs,
-      },
-      shouldReact: mentioned,
-      channel: channelId,
-      timestamp: getString(event, "ts") ?? "",
-    }
-  }
-}

package/lib/connectors/slack-listener.ts

@@ -1,97 +0,0 @@
-import { App, LogLevel } from "@slack/bolt"
-import { z } from "zod"
-import { FunnelConnectorListener, type NotifyFn } from "@/connectors/connector-listener"
-import { FunnelSlackEventProcessor } from "@/connectors/slack-event-processor"
-import { FunnelLogger } from "@/engine/logger/logger"
-import { NodeFunnelLogger } from "@/engine/logger/node-logger"
-import type { SlackConnectorConfig } from "@/connectors/slack-connector-schema"
-
-const middlewareArgsSchema = z.object({
-  event: z.record(z.string(), z.unknown()).optional(),
-})
-
-type Deps = {
-  config: SlackConnectorConfig
-  logger?: FunnelLogger
-}
-
-const defaultLogger = new NodeFunnelLogger()
-
-export class FunnelSlackListener extends FunnelConnectorListener {
-  private readonly config: SlackConnectorConfig
-  private readonly logger: FunnelLogger
-  private app: App | null = null
-
-  constructor(deps: Deps) {
-    super()
-    this.config = deps.config
-    this.logger = deps.logger ?? defaultLogger
-  }
-
-  async start(notify: NotifyFn): Promise<void> {
-    const app = new App({
-      token: this.config.botToken,
-      appToken: this.config.appToken,
-      socketMode: true,
-      logLevel: LogLevel.ERROR,
-    })
-
-    const authResult = await app.client.auth.test({ token: this.config.botToken })
-    const processor = new FunnelSlackEventProcessor({
-      ownBotUserId: authResult.user_id ?? "",
-      ownBotId: authResult.bot_id ?? "",
-    })
-
-    app.use(async (args) => {
-      const parsed = middlewareArgsSchema.safeParse(args)
-
-      if (!parsed.success || !parsed.data.event) return
-
-      const result = processor.process(parsed.data.event)
-
-      if (result.skip) return
-
-      if (result.shouldReact) {
-        try {
-          await app.client.reactions.add({
-            token: this.config.botToken,
-            channel: result.channel,
-            timestamp: result.timestamp,
-            name: "eyes",
-          })
-        } catch {
-          // ignore
-        }
-      }
-
-      await notify(result.content, result.meta)
-    })
-
-    app.error(async (error) => {
-      this.logger.error("Slack error", {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    })
-
-    await app.start()
-    this.app = app
-  }
-
-  async stop(): Promise<void> {
-    if (!this.app) return
-
-    try {
-      await this.app.stop()
-    } catch (error) {
-      this.logger.error("Slack stop error", {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    } finally {
-      this.app = null
-    }
-  }
-
-  override isAlive(): boolean {
-    return this.app !== null
-  }
-}

package/lib/connectors/slack.ts

@@ -1,4 +0,0 @@
-export * from "@/connectors/slack-adapter"
-export * from "@/connectors/slack-connector-schema"
-export * from "@/connectors/slack-event-processor"
-export * from "@/connectors/slack-listener"