@interactive-inc/claude-funnel 0.7.1 → 0.8.0

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

@@ -29,6 +29,12 @@ type Props = {
   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
@@ -42,16 +48,16 @@ export class FunnelSlackEventProcessor {
   }
 
   process(event: SlackRawEvent): SlackProcessed {
-    const eventType = event.type as string | undefined
+    const eventType = getString(event, "type")
 
     if (!eventType || !ALLOWED_EVENTS.has(eventType)) return { skip: true }
 
-    const subtype = event.subtype as string | undefined
+    const subtype = getString(event, "subtype")
 
     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 channelId = getString(event, "channel") ?? ""
+    const eventTs = getString(event, "event_ts") ?? getString(event, "ts") ?? ""
     const dedupKey = `${channelId}:${eventTs}`
     const now = this.now()
 
@@ -63,15 +69,15 @@ export class FunnelSlackEventProcessor {
       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
+    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 = (event.text as string) ?? ""
+    const text = getString(event, "text") ?? ""
     const mentioned = text.includes(`<@${this.ownBotUserId}>`)
-    const threadTs = (event.thread_ts as string) ?? (event.ts as string) ?? ""
+    const threadTs = getString(event, "thread_ts") ?? getString(event, "ts") ?? ""
 
     return {
       skip: false,
@@ -85,7 +91,7 @@ export class FunnelSlackEventProcessor {
       },
       shouldReact: mentioned,
       channel: channelId,
-      timestamp: (event.ts as string) ?? "",
+      timestamp: getString(event, "ts") ?? "",
     }
   }
 }

package/lib/{modules/connectors/funnel-slack-listener.ts → connectors/slack-listener.ts}

@@ -1,12 +1,14 @@
 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 { FunnelLogger } from "@/modules/logger/funnel-logger"
-import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
-import type { SlackConnectorConfig } from "@/modules/connectors/slack-connector-schema"
+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
@@ -18,12 +20,12 @@ 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
-    Object.freeze(this)
   }
 
   async start(notify: NotifyFn): Promise<void> {
@@ -41,13 +43,11 @@ export class FunnelSlackListener extends FunnelConnectorListener {
     })
 
     app.use(async (args) => {
-      const event = (args as unknown as Record<string, unknown>).event as
-        | Record<string, unknown>
-        | undefined
+      const parsed = middlewareArgsSchema.safeParse(args)
 
-      if (!event) return
+      if (!parsed.success || !parsed.data.event) return
 
-      const result = processor.process(event)
+      const result = processor.process(parsed.data.event)
 
       if (result.skip) return
 
@@ -74,5 +74,24 @@ export class FunnelSlackListener extends FunnelConnectorListener {
     })
 
     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

@@ -0,0 +1,520 @@
+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 }