@interactive-inc/claude-funnel 0.2.0

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

@@ -0,0 +1,124 @@
+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"
+
+type Deps = {
+  store: FunnelSettingsReader
+}
+
+type UpdateFields = {
+  botToken?: string
+  appToken?: string
+  pollInterval?: number
+}
+
+export class FunnelConnectors {
+  private readonly store: FunnelSettingsReader
+
+  constructor(deps: Deps) {
+    this.store = deps.store
+    Object.freeze(this)
+  }
+
+  list(): ConnectorConfig[] {
+    return this.store.read().connectors
+  }
+
+  get(name: string): ConnectorConfig | null {
+    return this.list().find((c) => c.name === name) ?? null
+  }
+
+  add(config: ConnectorConfig): void {
+    const settings = this.store.read()
+
+    if (settings.connectors.some((c) => c.name === config.name)) {
+      throw new Error(`connector "${config.name}" already exists`)
+    }
+
+    settings.connectors.push(config)
+
+    this.store.write(settings)
+  }
+
+  rename(oldName: string, newName: string): void {
+    const settings = this.store.read()
+
+    const connector = settings.connectors.find((c) => c.name === oldName)
+
+    if (!connector) throw new Error(`connector "${oldName}" not found`)
+
+    if (settings.connectors.some((c) => c.name === newName)) {
+      throw new Error(`connector "${newName}" already exists`)
+    }
+
+    connector.name = newName
+
+    for (const channel of settings.channels) {
+      const index = channel.connectors.indexOf(oldName)
+
+      if (index >= 0) channel.connectors[index] = newName
+    }
+
+    this.store.write(settings)
+  }
+
+  update(name: string, fields: UpdateFields): void {
+    const settings = this.store.read()
+
+    const connector = settings.connectors.find((c) => c.name === name)
+
+    if (!connector) throw new Error(`connector "${name}" not found`)
+
+    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
+    }
+
+    this.store.write(settings)
+  }
+
+  remove(name: string): void {
+    const settings = this.store.read()
+
+    const index = settings.connectors.findIndex((c) => c.name === name)
+
+    if (index < 0) throw new Error(`connector "${name}" not found`)
+
+    settings.connectors.splice(index, 1)
+
+    for (const channel of settings.channels) {
+      const ci = channel.connectors.indexOf(name)
+
+      if (ci >= 0) channel.connectors.splice(ci, 1)
+    }
+
+    this.store.write(settings)
+  }
+
+  async call(name: string, input: CallInput): Promise<unknown> {
+    const connector = this.get(name)
+
+    if (!connector) throw new Error(`connector "${name}" not found`)
+
+    if (connector.type === "slack") {
+      return await new FunnelSlackAdapter({ config: connector }).call(input)
+    }
+
+    if (connector.type === "gh") {
+      return await new FunnelGhAdapter().call(input)
+    }
+
+    if (connector.type === "discord") {
+      return await new FunnelDiscordAdapter({ config: connector }).call(input)
+    }
+
+    throw new Error(`unsupported connector type: ${(connector as { type: string }).type}`)
+  }
+}

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

@@ -0,0 +1,56 @@
+import {
+  FunnelConnectorAdapter,
+  type CallInput,
+} 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"
+
+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 hasBody =
+      input.body &&
+      typeof input.body === "object" &&
+      method !== "GET" &&
+      Object.keys(input.body as object).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/modules/connectors/funnel-discord-event-processor.ts

@@ -0,0 +1,48 @@
+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/modules/connectors/funnel-discord-listener.ts

@@ -0,0 +1,65 @@
+import { Client, GatewayIntentBits, Partials } from "discord.js"
+import {
+  FunnelConnectorListener,
+  type NotifyFn,
+} 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"
+
+type Deps = {
+  config: DiscordConnectorConfig
+}
+
+export class FunnelDiscordListener extends FunnelConnectorListener {
+  private readonly config: DiscordConnectorConfig
+
+  constructor(deps: Deps) {
+    super()
+    this.config = deps.config
+    Object.freeze(this)
+  }
+
+  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 processor = new FunnelDiscordEventProcessor({ ownUserId: client.user?.id ?? "" })
+
+      const result = processor.process({
+        authorId: message.author.id,
+        authorIsBot: message.author.bot,
+        channelId: message.channelId,
+        guildId: message.guildId,
+        mentionedUserIds: [...message.mentions.users.keys()],
+        raw: message.toJSON(),
+      })
+
+      if (result.skip) return
+
+      try {
+        await notify(result.content, result.meta)
+      } catch (error) {
+        logger.error("discord notify error", {
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    })
+
+    client.on("error", (error) => {
+      logger.error("discord client error", {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    })
+
+    await client.login(this.config.botToken)
+  }
+}

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

@@ -0,0 +1,51 @@
+import {
+  FunnelConnectorAdapter,
+  type CallInput,
+} from "@/modules/connectors/funnel-connector-adapter"
+import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
+import { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-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/modules/connectors/funnel-gh-listener.ts

@@ -0,0 +1,102 @@
+import {
+  FunnelConnectorListener,
+  type NotifyFn,
+} from "@/modules/connectors/funnel-connector-listener"
+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"
+
+type GhNotification = {
+  id: string
+  reason: string
+  subject: { type: string; url: string; title: string }
+  repository: { full_name: string }
+  updated_at: string
+}
+
+type Deps = {
+  config: GhConnectorConfig
+  process?: FunnelProcessRunner
+}
+
+const defaultProcess = new NodeFunnelProcessRunner()
+
+const MAX_SEEN = 10000
+const KEEP_SEEN = 5000
+
+export class FunnelGhListener extends FunnelConnectorListener {
+  private readonly config: GhConnectorConfig
+  private readonly process: FunnelProcessRunner
+  private readonly seen = new Map<string, string>()
+  private bootstrapped = false
+  private since = new Date().toISOString()
+
+  constructor(deps: Deps) {
+    super()
+    this.config = deps.config
+    this.process = deps.process ?? defaultProcess
+  }
+
+  async start(notify: NotifyFn): Promise<void> {
+    await this.pollOnce(notify)
+
+    const interval = this.config.pollInterval ?? 60
+
+    setInterval(() => void this.pollOnce(notify), interval * 1000).unref()
+  }
+
+  async pollOnce(notify: NotifyFn): Promise<void> {
+    const nextSince = new Date().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) {
+        logger.error("gh poll failed", { stderr: result.stderr })
+        return
+      }
+
+      const items = JSON.parse(result.stdout) as GhNotification[]
+
+      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) {
+      logger.error("gh poll error", {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+}

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

@@ -0,0 +1,31 @@
+import { WebClient } from "@slack/web-api"
+import {
+  FunnelConnectorAdapter,
+  type CallInput,
+} from "@/modules/connectors/funnel-connector-adapter"
+import type { SlackConnectorConfig } from "@/modules/settings/settings-schema"
+
+export type SlackWebClientLike = {
+  apiCall: (method: string, options: Record<string, unknown>) => Promise<unknown>
+}
+
+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 && typeof input.body === "object" ? input.body : {}
+
+    return await this.client.apiCall(input.path, body as Record<string, unknown>)
+  }
+}

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

@@ -0,0 +1,91 @@
+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
+}
+
+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 = event.type as string | undefined
+
+    if (!eventType || !ALLOWED_EVENTS.has(eventType)) return { skip: true }
+
+    const subtype = event.subtype as string | undefined
+
+    if (!ALLOWED_SUBTYPES.has(subtype)) return { skip: true }
+
+    const channelId = (event.channel as string) ?? ""
+    const eventTs = (event.event_ts as string) ?? (event.ts as string) ?? ""
+    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 = event.user as string | undefined
+    const botId = event.bot_id as string | undefined
+
+    if (userId === this.ownBotUserId) return { skip: true }
+    if (botId === this.ownBotId) return { skip: true }
+
+    const text = (event.text as string) ?? ""
+    const mentioned = text.includes(`<@${this.ownBotUserId}>`)
+    const threadTs = (event.thread_ts as string) ?? (event.ts as string) ?? ""
+
+    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: (event.ts as string) ?? "",
+    }
+  }
+}

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

@@ -0,0 +1,72 @@
+import { App, LogLevel } from "@slack/bolt"
+import {
+  FunnelConnectorListener,
+  type NotifyFn,
+} 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"
+
+type Deps = {
+  config: SlackConnectorConfig
+}
+
+export class FunnelSlackListener extends FunnelConnectorListener {
+  private readonly config: SlackConnectorConfig
+
+  constructor(deps: Deps) {
+    super()
+    this.config = deps.config
+    Object.freeze(this)
+  }
+
+  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 event = (args as unknown as Record<string, unknown>).event as
+        | Record<string, unknown>
+        | undefined
+
+      if (!event) return
+
+      const result = processor.process(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) => {
+      logger.error("Slack error", {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    })
+
+    await app.start()
+  }
+}

package/lib/modules/connectors/resolve-listener.ts

@@ -0,0 +1,13 @@
+import { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
+import { FunnelDiscordListener } from "@/modules/connectors/funnel-discord-listener"
+import { FunnelGhListener } from "@/modules/connectors/funnel-gh-listener"
+import { FunnelSlackListener } from "@/modules/connectors/funnel-slack-listener"
+import type { ConnectorConfig } from "@/modules/settings/settings-schema"
+
+export const resolveListener = (config: ConnectorConfig): FunnelConnectorListener => {
+  if (config.type === "slack") return new FunnelSlackListener({ config })
+  if (config.type === "gh") return new FunnelGhListener({ config })
+  if (config.type === "discord") return new FunnelDiscordListener({ config })
+
+  throw new Error(`unsupported connector type: ${(config as { type: string }).type}`)
+}

package/lib/modules/fs/funnel-file-system.ts

@@ -0,0 +1,14 @@
+export type FileStat = {
+  mtimeMs: number
+}
+
+export abstract class FunnelFileSystem {
+  abstract existsSync(path: string): boolean
+  abstract readFileSync(path: string): string
+  abstract writeFileSync(path: string, data: string): void
+  abstract appendFileSync(path: string, data: string): void
+  abstract unlink(path: string): void
+  abstract mkdirSync(path: string, options?: { recursive?: boolean }): void
+  abstract readdirSync(path: string): string[]
+  abstract statSync(path: string): FileStat
+}