@interactive-inc/claude-funnel 0.10.0 → 0.10.1

package/lib/connectors/connector-factory.ts

@@ -1,94 +0,0 @@
-import type { FunnelConnectorAdapter } from "@/connectors/connector-adapter"
-import type { ConnectorConfig } from "@/connectors/connector-config-schema"
-import type { FunnelConnectorListener } from "@/connectors/connector-listener"
-import { FunnelDiscordAdapter } from "@/connectors/discord-adapter"
-import { FunnelDiscordListener } from "@/connectors/discord-listener"
-import { FunnelGhAdapter } from "@/connectors/gh-adapter"
-import { FunnelGhListener } from "@/connectors/gh-listener"
-import { FunnelScheduleListener } from "@/connectors/schedule-listener"
-import { ScheduleStateStore } from "@/connectors/schedule-state-store"
-import { FunnelSlackAdapter } from "@/connectors/slack-adapter"
-import { FunnelSlackListener } from "@/connectors/slack-listener"
-import { FunnelFileSystem } from "@/engine/fs/file-system"
-import { NodeFunnelFileSystem } from "@/engine/fs/node-file-system"
-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 { FUNNEL_DIR } from "@/engine/settings/settings-store"
-import { join } from "node:path"
-
-type Deps = {
-  fs?: FunnelFileSystem
-  process?: FunnelProcessRunner
-  logger?: FunnelLogger
-  dir?: string
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-const defaultProcess = new NodeFunnelProcessRunner()
-const defaultLogger = new NodeFunnelLogger()
-
-/**
- * Pure factory for per-type listeners and adapters. The factory has no CRUD
- * responsibility — connector configs live inside settings.json under their
- * channel, and FunnelChannels passes them in by value.
- *
- * `dir` is the funnel home (defaults to ~/.funnel); per-connector state files
- * land at `<dir>/channels/<channel-id>/connectors/<connector-id>/state.json`.
- */
-export class FunnelConnectorFactory {
-  private readonly fs: FunnelFileSystem
-  private readonly process: FunnelProcessRunner
-  private readonly logger: FunnelLogger
-  private readonly dir: string
-
-  constructor(deps: Deps = {}) {
-    this.fs = deps.fs ?? defaultFs
-    this.process = deps.process ?? defaultProcess
-    this.logger = deps.logger ?? defaultLogger
-    this.dir = deps.dir ?? FUNNEL_DIR
-    Object.freeze(this)
-  }
-
-  createListener(channelId: string, config: ConnectorConfig): FunnelConnectorListener {
-    if (config.type === "slack") {
-      return new FunnelSlackListener({ config, logger: this.logger })
-    }
-
-    if (config.type === "gh") {
-      return new FunnelGhListener({ config, process: this.process, logger: this.logger })
-    }
-
-    if (config.type === "discord") {
-      return new FunnelDiscordListener({ config, logger: this.logger })
-    }
-
-    const lastFiredStore = new ScheduleStateStore({
-      path: join(this.connectorDir(channelId, config.id), "state.json"),
-      fs: this.fs,
-    })
-
-    return new FunnelScheduleListener({
-      config,
-      lastFiredStore,
-      logger: this.logger,
-    })
-  }
-
-  createAdapter(config: ConnectorConfig): FunnelConnectorAdapter | null {
-    if (config.type === "slack") return new FunnelSlackAdapter({ config })
-    if (config.type === "gh") return new FunnelGhAdapter({ process: this.process })
-    if (config.type === "discord") return new FunnelDiscordAdapter({ config })
-
-    return null
-  }
-
-  connectorDir(channelId: string, connectorId: string): string {
-    return join(this.dir, "channels", channelId, "connectors", connectorId)
-  }
-
-  channelDir(channelId: string): string {
-    return join(this.dir, "channels", channelId)
-  }
-}

package/lib/connectors/connector-listener.ts

@@ -1,20 +0,0 @@
-export type NotifyFn = (content: string, meta?: Record<string, string>) => Promise<void>
-
-/**
- * Long-lived event source for one connector.
- *
- * `start()` opens the underlying connection (Slack Socket Mode, Discord
- * Gateway, GH polling, schedule tick) and pushes events through `notify`.
- * `stop()` releases the resources so the supervisor can recreate the listener
- * with new config without restarting the whole gateway. `isAlive()` lets the
- * supervisor periodically health-check and auto-restart dead listeners; the
- * default optimistic implementation is fine for poll/tick-based listeners
- * that self-heal.
- */
-export abstract class FunnelConnectorListener {
-  abstract start(notify: NotifyFn): Promise<void>
-  abstract stop(): Promise<void>
-  isAlive(): boolean {
-    return true
-  }
-}

package/lib/connectors/discord-adapter.ts

@@ -1,51 +0,0 @@
-import { FunnelConnectorAdapter, type CallInput } from "@/connectors/connector-adapter"
-import { FunnelHttpClient } from "@/engine/http/http-client"
-import { NodeFunnelHttpClient } from "@/engine/http/node-http-client"
-import type { DiscordConnectorConfig } from "@/connectors/discord-connector-schema"
-
-const DISCORD_API_BASE = "https://discord.com/api/v10"
-
-type Deps = {
-  config: DiscordConnectorConfig
-  http?: FunnelHttpClient
-}
-
-const defaultHttp = new NodeFunnelHttpClient()
-
-export class FunnelDiscordAdapter extends FunnelConnectorAdapter {
-  private readonly token: string
-  private readonly http: FunnelHttpClient
-
-  constructor(deps: Deps) {
-    super()
-    this.token = deps.config.botToken
-    this.http = deps.http ?? defaultHttp
-    Object.freeze(this)
-  }
-
-  async call(input: CallInput): Promise<unknown> {
-    const method = (input.method || "GET").toUpperCase()
-    const path = input.path.startsWith("/") ? input.path : `/${input.path}`
-    const body = input.body
-    const hasBody =
-      body !== null && typeof body === "object" && method !== "GET" && Object.keys(body).length > 0
-
-    const res = await this.http.fetch({
-      method,
-      url: `${DISCORD_API_BASE}${path}`,
-      headers: {
-        Authorization: `Bot ${this.token}`,
-        "Content-Type": "application/json",
-      },
-      body: hasBody ? JSON.stringify(input.body) : undefined,
-    })
-
-    if (!res.ok) {
-      throw new Error(`Discord API failed (${res.status}): ${await res.text()}`)
-    }
-
-    if (res.status === 204) return null
-
-    return await res.json()
-  }
-}

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

@@ -1,12 +0,0 @@
-import { z } from "zod"
-
-export const discordConnectorSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  type: z.literal("discord"),
-  botToken: z.string().min(10),
-  createdAt: z.string().datetime().optional(),
-  updatedAt: z.string().datetime().optional(),
-})
-
-export type DiscordConnectorConfig = z.infer<typeof discordConnectorSchema>

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

@@ -1,48 +0,0 @@
-export type DiscordInboundMessage = {
-  authorId: string
-  authorIsBot: boolean
-  channelId: string
-  guildId: string | null
-  mentionedUserIds: string[]
-  raw: unknown
-}
-
-export type DiscordProcessedSkip = { skip: true }
-
-export type DiscordProcessedEmit = {
-  skip: false
-  content: string
-  meta: Record<string, string>
-}
-
-export type DiscordProcessed = DiscordProcessedSkip | DiscordProcessedEmit
-
-type Props = {
-  ownUserId: string
-}
-
-export class FunnelDiscordEventProcessor {
-  private readonly ownUserId: string
-
-  constructor(props: Props) {
-    this.ownUserId = props.ownUserId
-  }
-
-  process(message: DiscordInboundMessage): DiscordProcessed {
-    if (message.authorIsBot) return { skip: true }
-
-    const mentioned = this.ownUserId ? message.mentionedUserIds.includes(this.ownUserId) : false
-
-    return {
-      skip: false,
-      content: JSON.stringify(message.raw),
-      meta: {
-        event_type: "discord",
-        channel_id: message.channelId,
-        user_id: message.authorId,
-        mentioned: String(mentioned),
-        guild_id: message.guildId ?? "",
-      },
-    }
-  }
-}

package/lib/connectors/discord-listener.ts

@@ -1,111 +0,0 @@
-import { Client, GatewayIntentBits, Partials } from "discord.js"
-import { FunnelConnectorListener, type NotifyFn } from "@/connectors/connector-listener"
-import { FunnelDiscordEventProcessor } from "@/connectors/discord-event-processor"
-import { FunnelLogger } from "@/engine/logger/logger"
-import { NodeFunnelLogger } from "@/engine/logger/node-logger"
-import type { DiscordConnectorConfig } from "@/connectors/discord-connector-schema"
-
-type Deps = {
-  config: DiscordConnectorConfig
-  logger?: FunnelLogger
-}
-
-const defaultLogger = new NodeFunnelLogger()
-
-export class FunnelDiscordListener extends FunnelConnectorListener {
-  private readonly config: DiscordConnectorConfig
-  private readonly logger: FunnelLogger
-  private client: Client | null = null
-
-  constructor(deps: Deps) {
-    super()
-    this.config = deps.config
-    this.logger = deps.logger ?? defaultLogger
-  }
-
-  async start(notify: NotifyFn): Promise<void> {
-    const client = new Client({
-      intents: [
-        GatewayIntentBits.Guilds,
-        GatewayIntentBits.GuildMessages,
-        GatewayIntentBits.MessageContent,
-        GatewayIntentBits.DirectMessages,
-      ],
-      partials: [Partials.Channel],
-    })
-
-    client.on("messageCreate", async (message) => {
-      const ownUserId = client.user?.id ?? ""
-      const mentionedUserIds = [...message.mentions.users.keys()]
-
-      this.logger.info("discord messageCreate", {
-        author: message.author.id,
-        authorIsBot: String(message.author.bot),
-        channelId: message.channelId,
-        guildId: message.guildId ?? "",
-        mentions: mentionedUserIds.join(","),
-        ownUserId,
-        mentioned: String(mentionedUserIds.includes(ownUserId)),
-      })
-
-      const processor = new FunnelDiscordEventProcessor({ ownUserId })
-
-      const result = processor.process({
-        authorId: message.author.id,
-        authorIsBot: message.author.bot,
-        channelId: message.channelId,
-        guildId: message.guildId,
-        mentionedUserIds,
-        raw: message.toJSON(),
-      })
-
-      if (result.skip) {
-        this.logger.info("discord skip", { reason: "bot author" })
-        return
-      }
-
-      try {
-        await notify(result.content, result.meta)
-      } catch (error) {
-        this.logger.error("discord notify error", {
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    })
-
-    client.on("ready", (readyClient) => {
-      this.logger.info("discord ready", {
-        userId: readyClient.user.id,
-        tag: readyClient.user.tag,
-        guilds: String(readyClient.guilds.cache.size),
-      })
-    })
-
-    client.on("error", (error) => {
-      this.logger.error("discord client error", {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    })
-
-    await client.login(this.config.botToken)
-    this.client = client
-  }
-
-  async stop(): Promise<void> {
-    if (!this.client) return
-
-    try {
-      await this.client.destroy()
-    } catch (error) {
-      this.logger.error("discord stop error", {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    } finally {
-      this.client = null
-    }
-  }
-
-  override isAlive(): boolean {
-    return this.client !== null
-  }
-}

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>