@interactive-inc/claude-funnel 0.10.0 → 0.15.1

package/lib/connectors/discord.ts

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

package/lib/connectors/gh-adapter.ts

@@ -1,48 +0,0 @@
-import { FunnelConnectorAdapter, type CallInput } from "@/connectors/connector-adapter"
-import { FunnelProcessRunner } from "@/engine/process/process-runner"
-import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
-
-type Deps = {
-  process?: FunnelProcessRunner
-}
-
-const defaultProcess = new NodeFunnelProcessRunner()
-
-export class FunnelGhAdapter extends FunnelConnectorAdapter {
-  private readonly process: FunnelProcessRunner
-
-  constructor(deps: Deps = {}) {
-    super()
-    this.process = deps.process ?? defaultProcess
-    Object.freeze(this)
-  }
-
-  async call(input: CallInput): Promise<unknown> {
-    const args = ["api", input.path]
-
-    if (input.method && input.method.toLowerCase() !== "get") {
-      args.push("-X", input.method.toUpperCase())
-    }
-
-    const hasBody =
-      input.body && typeof input.body === "object" && Object.keys(input.body).length > 0
-
-    if (hasBody) {
-      args.push("--input", "-")
-    }
-
-    const result = await this.process.run(["gh", ...args], {
-      input: hasBody ? JSON.stringify(input.body) : undefined,
-    })
-
-    if (result.exitCode !== 0) {
-      throw new Error(`gh api failed: ${result.stderr.trim() || result.stdout.trim()}`)
-    }
-
-    try {
-      return JSON.parse(result.stdout)
-    } catch {
-      return result.stdout
-    }
-  }
-}

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

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

package/lib/connectors/gh-listener.ts

@@ -1,137 +0,0 @@
-import { z } from "zod"
-import { FunnelConnectorListener, type NotifyFn } from "@/connectors/connector-listener"
-import { FunnelLogger } from "@/engine/logger/logger"
-import { NodeFunnelLogger } from "@/engine/logger/node-logger"
-import { FunnelProcessRunner } from "@/engine/process/process-runner"
-import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
-import type { GhConnectorConfig } from "@/connectors/gh-connector-schema"
-
-const ghNotificationSchema = z.object({
-  id: z.string(),
-  reason: z.string(),
-  subject: z.object({
-    type: z.string(),
-    url: z.string(),
-    title: z.string(),
-  }),
-  repository: z.object({ full_name: z.string() }),
-  updated_at: z.string(),
-})
-
-const ghNotificationsSchema = z.array(ghNotificationSchema)
-
-type GhNotification = z.infer<typeof ghNotificationSchema>
-
-type Deps = {
-  config: GhConnectorConfig
-  process?: FunnelProcessRunner
-  logger?: FunnelLogger
-  now?: () => Date
-}
-
-const defaultProcess = new NodeFunnelProcessRunner()
-const defaultLogger = new NodeFunnelLogger()
-
-const MAX_SEEN = 10000
-const KEEP_SEEN = 5000
-
-export class FunnelGhListener extends FunnelConnectorListener {
-  private readonly config: GhConnectorConfig
-  private readonly process: FunnelProcessRunner
-  private readonly logger: FunnelLogger
-  private readonly now: () => Date
-  private readonly seen = new Map<string, string>()
-  private bootstrapped = false
-  private since: string
-  private timer: ReturnType<typeof setInterval> | null = null
-
-  constructor(deps: Deps) {
-    super()
-    this.config = deps.config
-    this.process = deps.process ?? defaultProcess
-    this.logger = deps.logger ?? defaultLogger
-    this.now = deps.now ?? (() => new Date())
-    this.since = this.now().toISOString()
-  }
-
-  async start(notify: NotifyFn): Promise<void> {
-    await this.pollOnce(notify)
-
-    const interval = this.config.pollInterval ?? 60
-
-    this.timer = setInterval(() => void this.pollOnce(notify), interval * 1000)
-    this.timer.unref()
-  }
-
-  async stop(): Promise<void> {
-    if (!this.timer) return
-
-    clearInterval(this.timer)
-    this.timer = null
-  }
-
-  override isAlive(): boolean {
-    return this.timer !== null
-  }
-
-  async pollOnce(notify: NotifyFn): Promise<void> {
-    const nextSince = this.now().toISOString()
-    const params = new URLSearchParams({ since: this.since, all: "false" })
-
-    try {
-      const result = await this.process.run(["gh", "api", `/notifications?${params}`])
-
-      if (result.exitCode !== 0) {
-        this.logger.error("gh poll failed", { stderr: result.stderr })
-        return
-      }
-
-      const parsed = ghNotificationsSchema.safeParse(JSON.parse(result.stdout))
-
-      if (!parsed.success) {
-        this.logger.warn("gh response did not match schema", { error: parsed.error.message })
-        return
-      }
-
-      const items: GhNotification[] = parsed.data
-
-      for (const item of items) {
-        if (this.seen.get(item.id) === item.updated_at) continue
-
-        this.seen.set(item.id, item.updated_at)
-
-        if (!this.bootstrapped) continue
-
-        const meta: Record<string, string> = {
-          event_type: "gh",
-          reason: item.reason,
-          subject_type: item.subject.type,
-          subject_url: item.subject.url,
-          repository: item.repository.full_name,
-          thread_id: item.id,
-          updated_at: item.updated_at,
-        }
-
-        await notify(JSON.stringify(item), meta)
-      }
-
-      if (this.seen.size > MAX_SEEN) {
-        const toDrop = this.seen.size - KEEP_SEEN
-        let dropped = 0
-
-        for (const key of this.seen.keys()) {
-          if (dropped >= toDrop) break
-          this.seen.delete(key)
-          dropped++
-        }
-      }
-
-      this.since = nextSince
-      this.bootstrapped = true
-    } catch (error) {
-      this.logger.error("gh poll error", {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
-  }
-}

package/lib/connectors/gh.ts

@@ -1,3 +0,0 @@
-export * from "@/connectors/gh-adapter"
-export * from "@/connectors/gh-connector-schema"
-export * from "@/connectors/gh-listener"

package/lib/connectors/match-cron.ts

@@ -1,78 +0,0 @@
-type Field = { min: number; max: number; values: Set<number> }
-
-const parseField = (expr: string, min: number, max: number): Field => {
-  const values = new Set<number>()
-
-  for (const part of expr.split(",")) {
-    const [rangePart, stepPart] = part.split("/")
-    const step = stepPart ? Number(stepPart) : 1
-
-    if (!Number.isFinite(step) || step <= 0) {
-      throw new Error(`invalid cron step: "${stepPart}"`)
-    }
-
-    let lo = min
-    let hi = max
-
-    if (rangePart === "*" || rangePart === undefined || rangePart === "") {
-      lo = min
-      hi = max
-    } else if (rangePart.includes("-")) {
-      const [aStr, bStr] = rangePart.split("-")
-      const a = Number(aStr)
-      const b = Number(bStr)
-
-      if (!Number.isFinite(a) || !Number.isFinite(b)) {
-        throw new Error(`invalid cron range: "${rangePart}"`)
-      }
-
-      lo = a
-      hi = b
-    } else {
-      const n = Number(rangePart)
-
-      if (!Number.isFinite(n)) throw new Error(`invalid cron value: "${rangePart}"`)
-
-      lo = n
-      hi = stepPart ? max : n
-    }
-
-    if (lo < min || hi > max || lo > hi) {
-      throw new Error(`cron value out of range: ${rangePart} (must be ${min}-${max})`)
-    }
-
-    for (let i = lo; i <= hi; i += step) {
-      values.add(i)
-    }
-  }
-
-  return { min, max, values }
-}
-
-export const matchCron = (expr: string, date: Date): boolean => {
-  const parts = expr.trim().split(/\s+/)
-
-  if (parts.length !== 5) {
-    throw new Error(`cron must have 5 fields (got ${parts.length}): "${expr}"`)
-  }
-
-  const [minute, hour, dom, month, dow] = parts
-
-  if (!minute || !hour || !dom || !month || !dow) {
-    throw new Error(`cron has empty fields: "${expr}"`)
-  }
-
-  const fields = [
-    { field: parseField(minute, 0, 59), value: date.getMinutes() },
-    { field: parseField(hour, 0, 23), value: date.getHours() },
-    { field: parseField(dom, 1, 31), value: date.getDate() },
-    { field: parseField(month, 1, 12), value: date.getMonth() + 1 },
-    { field: parseField(dow, 0, 6), value: date.getDay() },
-  ]
-
-  for (const { field, value } of fields) {
-    if (!field.values.has(value)) return false
-  }
-
-  return true
-}

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

@@ -1,33 +0,0 @@
-import { z } from "zod"
-
-/**
- * Catch-up behavior when the daemon was down past one or more matching minutes.
- *
- * - `latest`: fire once with the most recent missed match (default; preserves prior behavior).
- * - `all`: fire once per missed minute, oldest first (capped at 24 h).
- * - `skip`: never fire missed matches; only fire when the current minute matches.
- */
-export const scheduleCatchupPolicySchema = z.enum(["latest", "all", "skip"])
-
-export type ScheduleCatchupPolicy = z.infer<typeof scheduleCatchupPolicySchema>
-
-export const scheduleEntrySchema = z.object({
-  id: z.string(),
-  cron: z.string(),
-  prompt: z.string(),
-  enabled: z.boolean().default(true),
-  catchupPolicy: scheduleCatchupPolicySchema.default("latest"),
-})
-
-export type ScheduleEntry = z.infer<typeof scheduleEntrySchema>
-
-export const scheduleConnectorSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  type: z.literal("schedule"),
-  entries: z.array(scheduleEntrySchema).default([]),
-  createdAt: z.string().datetime().optional(),
-  updatedAt: z.string().datetime().optional(),
-})
-
-export type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>

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>