@interactive-inc/claude-funnel 0.8.1 → 0.10.1

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/engine/channels/channels.ts

@@ -1,520 +0,0 @@
-import type { CallInput } from "@/connectors/connector-adapter"
-import type { ConnectorConfig } from "@/connectors/connector-config-schema"
-import type { FunnelConnectorFactory } from "@/connectors/connector-factory"
-import type { FunnelConnectorListener } from "@/connectors/connector-listener"
-import type { DiscordConnectorConfig } from "@/connectors/discord-connector-schema"
-import type { GhConnectorConfig } from "@/connectors/gh-connector-schema"
-import type { ScheduleConnectorConfig, ScheduleEntry } from "@/connectors/schedule-connector-schema"
-import type { SlackConnectorConfig } from "@/connectors/slack-connector-schema"
-import type { ProfileChannelChecker } from "@/engine/profiles/profile-channel-checker"
-import { FunnelClock } from "@/engine/time/clock"
-import { NodeFunnelClock } from "@/engine/time/node-clock"
-import { FunnelIdGenerator } from "@/engine/id/id-generator"
-import { NodeFunnelIdGenerator } from "@/engine/id/node-id-generator"
-import { FunnelSettingsReader } from "@/engine/settings/settings-reader"
-import type {
-  ChannelConfig,
-  ChannelDeliveryMode,
-  Settings,
-} from "@/engine/settings/settings-schema"
-
-type Deps = {
-  store: FunnelSettingsReader
-  factory: FunnelConnectorFactory
-  profileChecker: ProfileChannelChecker
-  clock?: FunnelClock
-  idGenerator?: FunnelIdGenerator
-}
-
-export type ChannelConnectorView = ConnectorConfig & {
-  channelId: string
-  channelName: string
-}
-
-type AddConnectorInput =
-  | { type: "slack"; name: string; botToken: string; appToken: string }
-  | { type: "gh"; name: string; pollInterval?: number }
-  | { type: "discord"; name: string; botToken: string }
-  | { type: "schedule"; name: string; entries?: ScheduleEntry[] }
-
-const defaultClock = new NodeFunnelClock()
-const defaultIdGenerator = new NodeFunnelIdGenerator()
-
-/**
- * Channels own their connectors. Each channel has a stable id (UUID); the
- * `name` is the human-facing label used by the CLI. Connectors live nested
- * inside `channel.connectors[]`, so add/remove/rename are channel-scoped — no
- * global connector namespace exists. Token uniqueness is enforced across all
- * channels at add/update time so the same Slack/Discord credentials cannot
- * be registered twice.
- */
-export class FunnelChannels {
-  private readonly store: FunnelSettingsReader
-  private readonly factory: FunnelConnectorFactory
-  private readonly profileChecker: ProfileChannelChecker
-  private readonly clock: FunnelClock
-  private readonly idGenerator: FunnelIdGenerator
-
-  constructor(deps: Deps) {
-    this.store = deps.store
-    this.factory = deps.factory
-    this.profileChecker = deps.profileChecker
-    this.clock = deps.clock ?? defaultClock
-    this.idGenerator = deps.idGenerator ?? defaultIdGenerator
-    Object.freeze(this)
-  }
-
-  list(): ChannelConfig[] {
-    return this.store.read().channels
-  }
-
-  get(name: string): ChannelConfig | null {
-    return this.list().find((c) => c.name === name) ?? null
-  }
-
-  getById(id: string): ChannelConfig | null {
-    return this.list().find((c) => c.id === id) ?? null
-  }
-
-  add(input: { name: string; delivery?: ChannelDeliveryMode }): ChannelConfig {
-    const settings = this.store.read()
-
-    if (settings.channels.some((c) => c.name === input.name)) {
-      throw new Error(`channel "${input.name}" already exists`)
-    }
-
-    const channel: ChannelConfig = {
-      id: this.idGenerator.generate(),
-      name: input.name,
-      delivery: input.delivery ?? "fanout",
-      connectors: [],
-    }
-
-    settings.channels.push(channel)
-    this.store.write(settings)
-
-    return channel
-  }
-
-  setDelivery(name: string, delivery: ChannelDeliveryMode): void {
-    const settings = this.store.read()
-    const channel = this.requireChannel(settings, name)
-
-    channel.delivery = delivery
-
-    this.store.write(settings)
-  }
-
-  remove(name: string): void {
-    const settings = this.store.read()
-    const index = settings.channels.findIndex((c) => c.name === name)
-
-    if (index < 0) throw new Error(`channel "${name}" not found`)
-
-    const channel = settings.channels[index]
-
-    if (channel && this.profileChecker.hasChannelRef(channel.id)) {
-      throw new Error(`channel "${name}" is referenced by a profile`)
-    }
-
-    settings.channels.splice(index, 1)
-    this.store.write(settings)
-  }
-
-  rename(oldName: string, newName: string): void {
-    const settings = this.store.read()
-    const channel = settings.channels.find((c) => c.name === oldName)
-
-    if (!channel) throw new Error(`channel "${oldName}" not found`)
-    if (settings.channels.some((c) => c.name === newName)) {
-      throw new Error(`channel "${newName}" already exists`)
-    }
-
-    channel.name = newName
-    this.store.write(settings)
-  }
-
-  listConnectors(channelName: string): ConnectorConfig[] {
-    return this.requireChannel(this.store.read(), channelName).connectors
-  }
-
-  getConnector(channelName: string, connectorName: string): ConnectorConfig | null {
-    const channel = this.get(channelName)
-
-    if (!channel) return null
-
-    return channel.connectors.find((c) => c.name === connectorName) ?? null
-  }
-
-  listAllConnectors(): ChannelConnectorView[] {
-    const out: ChannelConnectorView[] = []
-
-    for (const channel of this.list()) {
-      for (const connector of channel.connectors) {
-        out.push({ ...connector, channelId: channel.id, channelName: channel.name })
-      }
-    }
-
-    return out
-  }
-
-  addConnector(channelName: string, input: AddConnectorInput): ConnectorConfig {
-    const settings = this.store.read()
-    const channel = this.requireChannel(settings, channelName)
-
-    if (channel.connectors.some((c) => c.name === input.name)) {
-      throw new Error(`connector "${input.name}" already exists in channel "${channelName}"`)
-    }
-
-    const candidate = this.fromInput(input)
-
-    this.assertNoTokenCollision(settings, candidate)
-
-    channel.connectors.push(candidate)
-    this.store.write(settings)
-
-    return candidate
-  }
-
-  private fromInput(input: AddConnectorInput): ConnectorConfig {
-    const id = this.idGenerator.generate()
-    const now = this.clock.iso()
-    const createdAt = now
-    const updatedAt = now
-
-    if (input.type === "slack") {
-      return {
-        id,
-        type: "slack",
-        name: input.name,
-        botToken: input.botToken,
-        appToken: input.appToken,
-        createdAt,
-        updatedAt,
-      }
-    }
-
-    if (input.type === "gh") {
-      return {
-        id,
-        type: "gh",
-        name: input.name,
-        ...(input.pollInterval !== undefined ? { pollInterval: input.pollInterval } : {}),
-        createdAt,
-        updatedAt,
-      }
-    }
-
-    if (input.type === "discord") {
-      return {
-        id,
-        type: "discord",
-        name: input.name,
-        botToken: input.botToken,
-        createdAt,
-        updatedAt,
-      }
-    }
-
-    return {
-      id,
-      type: "schedule",
-      name: input.name,
-      entries: input.entries ?? [],
-      createdAt,
-      updatedAt,
-    }
-  }
-
-  removeConnector(channelName: string, connectorName: string): void {
-    const settings = this.store.read()
-    const channel = this.requireChannel(settings, channelName)
-    const index = channel.connectors.findIndex((c) => c.name === connectorName)
-
-    if (index < 0) {
-      throw new Error(`connector "${connectorName}" not found in channel "${channelName}"`)
-    }
-
-    channel.connectors.splice(index, 1)
-    this.store.write(settings)
-  }
-
-  renameConnector(channelName: string, oldName: string, newName: string): void {
-    const settings = this.store.read()
-    const channel = this.requireChannel(settings, channelName)
-    const connector = channel.connectors.find((c) => c.name === oldName)
-
-    if (!connector) {
-      throw new Error(`connector "${oldName}" not found in channel "${channelName}"`)
-    }
-
-    if (channel.connectors.some((c) => c.name === newName)) {
-      throw new Error(`connector "${newName}" already exists in channel "${channelName}"`)
-    }
-
-    connector.name = newName
-    connector.updatedAt = this.clock.iso()
-    this.store.write(settings)
-  }
-
-  updateSlackConnector(
-    channelName: string,
-    connectorName: string,
-    fields: { botToken?: string; appToken?: string },
-  ): void {
-    const settings = this.store.read()
-    const channel = this.requireChannel(settings, channelName)
-    const connector = this.requireSlackConnector(channel, connectorName)
-
-    const updated: SlackConnectorConfig = {
-      ...connector,
-      botToken: fields.botToken ?? connector.botToken,
-      appToken: fields.appToken ?? connector.appToken,
-      updatedAt: this.clock.iso(),
-    }
-
-    this.assertNoTokenCollision(settings, updated)
-
-    Object.assign(connector, updated)
-    this.store.write(settings)
-  }
-
-  updateGhConnector(
-    channelName: string,
-    connectorName: string,
-    fields: { pollInterval?: number },
-  ): void {
-    const settings = this.store.read()
-    const channel = this.requireChannel(settings, channelName)
-    const connector = this.requireGhConnector(channel, connectorName)
-
-    if (fields.pollInterval !== undefined) connector.pollInterval = fields.pollInterval
-    connector.updatedAt = this.clock.iso()
-
-    this.store.write(settings)
-  }
-
-  updateDiscordConnector(
-    channelName: string,
-    connectorName: string,
-    fields: { botToken?: string },
-  ): void {
-    const settings = this.store.read()
-    const channel = this.requireChannel(settings, channelName)
-    const connector = this.requireDiscordConnector(channel, connectorName)
-
-    const updated: DiscordConnectorConfig = {
-      ...connector,
-      botToken: fields.botToken ?? connector.botToken,
-      updatedAt: this.clock.iso(),
-    }
-
-    this.assertNoTokenCollision(settings, updated)
-
-    Object.assign(connector, updated)
-    this.store.write(settings)
-  }
-
-  listScheduleEntries(channelName: string, connectorName: string): ScheduleEntry[] {
-    const channel = this.requireChannel(this.store.read(), channelName)
-    const connector = this.requireScheduleConnector(channel, connectorName)
-
-    return connector.entries
-  }
-
-  addScheduleEntry(
-    channelName: string,
-    connectorName: string,
-    entry: Pick<ScheduleEntry, "cron" | "prompt"> &
-      Partial<Pick<ScheduleEntry, "id" | "enabled" | "catchupPolicy">>,
-  ): ScheduleEntry {
-    const settings = this.store.read()
-    const channel = this.requireChannel(settings, channelName)
-    const connector = this.requireScheduleConnector(channel, connectorName)
-
-    const persisted: ScheduleEntry = {
-      id: entry.id ?? this.idGenerator.generate(),
-      cron: entry.cron,
-      prompt: entry.prompt,
-      enabled: entry.enabled ?? true,
-      catchupPolicy: entry.catchupPolicy ?? "latest",
-    }
-
-    connector.entries.push(persisted)
-    connector.updatedAt = this.clock.iso()
-    this.store.write(settings)
-
-    return persisted
-  }
-
-  removeScheduleEntry(channelName: string, connectorName: string, id: string): void {
-    const settings = this.store.read()
-    const channel = this.requireChannel(settings, channelName)
-    const connector = this.requireScheduleConnector(channel, connectorName)
-    const index = connector.entries.findIndex((e) => e.id === id)
-
-    if (index < 0) throw new Error(`schedule entry "${id}" not found`)
-
-    connector.entries.splice(index, 1)
-    connector.updatedAt = this.clock.iso()
-    this.store.write(settings)
-  }
-
-  async call(channelName: string, connectorName: string, input: CallInput): Promise<unknown> {
-    const connector = this.getConnector(channelName, connectorName)
-
-    if (!connector) {
-      throw new Error(`connector "${connectorName}" not found in channel "${channelName}"`)
-    }
-
-    const adapter = this.factory.createAdapter(connector)
-
-    if (!adapter) {
-      throw new Error(`connector type "${connector.type}" does not support outbound calls`)
-    }
-
-    return await adapter.call(input)
-  }
-
-  createListener(
-    channelName: string,
-    connectorName: string,
-  ): { config: ConnectorConfig; channelId: string; listener: FunnelConnectorListener } | null {
-    const channel = this.get(channelName)
-
-    if (!channel) return null
-
-    const connector = channel.connectors.find((c) => c.name === connectorName)
-
-    if (!connector) return null
-
-    return {
-      config: connector,
-      channelId: channel.id,
-      listener: this.factory.createListener(channel.id, connector),
-    }
-  }
-
-  createAllListeners(): {
-    config: ConnectorConfig
-    channelId: string
-    channelName: string
-    listener: FunnelConnectorListener
-  }[] {
-    const out: {
-      config: ConnectorConfig
-      channelId: string
-      channelName: string
-      listener: FunnelConnectorListener
-    }[] = []
-
-    for (const channel of this.list()) {
-      for (const connector of channel.connectors) {
-        out.push({
-          config: connector,
-          channelId: channel.id,
-          channelName: channel.name,
-          listener: this.factory.createListener(channel.id, connector),
-        })
-      }
-    }
-
-    return out
-  }
-
-  private requireChannel(settings: Settings, name: string): ChannelConfig {
-    const channel = settings.channels.find((c) => c.name === name)
-
-    if (!channel) throw new Error(`channel "${name}" not found`)
-
-    return channel
-  }
-
-  private requireConnector(channel: ChannelConfig, connectorName: string): ConnectorConfig {
-    const connector = channel.connectors.find((c) => c.name === connectorName)
-
-    if (!connector) {
-      throw new Error(`connector "${connectorName}" not found in channel "${channel.name}"`)
-    }
-
-    return connector
-  }
-
-  private requireSlackConnector(
-    channel: ChannelConfig,
-    connectorName: string,
-  ): SlackConnectorConfig {
-    const connector = this.requireConnector(channel, connectorName)
-
-    if (connector.type !== "slack") {
-      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "slack"`)
-    }
-
-    return connector
-  }
-
-  private requireGhConnector(channel: ChannelConfig, connectorName: string): GhConnectorConfig {
-    const connector = this.requireConnector(channel, connectorName)
-
-    if (connector.type !== "gh") {
-      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "gh"`)
-    }
-
-    return connector
-  }
-
-  private requireDiscordConnector(
-    channel: ChannelConfig,
-    connectorName: string,
-  ): DiscordConnectorConfig {
-    const connector = this.requireConnector(channel, connectorName)
-
-    if (connector.type !== "discord") {
-      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "discord"`)
-    }
-
-    return connector
-  }
-
-  private requireScheduleConnector(
-    channel: ChannelConfig,
-    connectorName: string,
-  ): ScheduleConnectorConfig {
-    const connector = this.requireConnector(channel, connectorName)
-
-    if (connector.type !== "schedule") {
-      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "schedule"`)
-    }
-
-    return connector
-  }
-
-  private assertNoTokenCollision(settings: Settings, candidate: ConnectorConfig): void {
-    const tokens = this.tokensOf(candidate)
-
-    if (tokens.length === 0) return
-
-    for (const channel of settings.channels) {
-      for (const other of channel.connectors) {
-        if (other.id === candidate.id) continue
-
-        for (const token of this.tokensOf(other)) {
-          if (tokens.includes(token)) {
-            throw new Error(
-              `token already in use by connector "${other.name}" in channel "${channel.name}"`,
-            )
-          }
-        }
-      }
-    }
-  }
-
-  private tokensOf(connector: ConnectorConfig): string[] {
-    if (connector.type === "slack") return [connector.botToken, connector.appToken]
-    if (connector.type === "discord") return [connector.botToken]
-
-    return []
-  }
-}
-
-export type { ScheduleConnectorConfig }