@interactive-inc/claude-funnel 0.3.0 → 0.4.1

package/README.md

@@ -3,17 +3,32 @@
 [![npm](https://img.shields.io/npm/v/@interactive-inc/claude-funnel.svg)](https://www.npmjs.com/package/@interactive-inc/claude-funnel)
 [![license](https://img.shields.io/npm/l/@interactive-inc/claude-funnel.svg)](./LICENSE)
 
-A hub CLI that connects multiple Claude Code agents to external services (Slack / GitHub / Discord). External events flow through subscription "channels" into Claude Code sessions, and outbound API calls from Claude are funneled through the same connectors.
+A hub CLI that connects multiple Claude Code agents to external services (Slack / GitHub / Discord) and time-based triggers (cron). External events flow through subscription "channels" into Claude Code sessions, and outbound API calls from Claude are funneled through the same connectors.
 
 The command is `funnel` or its shorthand `fnl`.
 
 ## Overview
 
 ```
-Slack/others         Connectors      Channels                Claude Code
-(external APIs) ─→   (funnel)  ─→    (subscription router) ──WS/MCP─→   (received as <channel> tags)
-                                                           ↑
-                                               funnel MCP server (funnel mcp)
+External sources
+(Slack / GitHub / Discord / cron)
+            │
+            ▼
+        Connectors
+       (per-type stores)
+            │
+            ▼
+         Channels
+   (subscription router)
+            │
+            ▼  WebSocket
+       Gateway daemon
+            │
+            ▼  MCP (stdio)
+       Claude Code
+  (events surfaced as <channel> tags;
+   outbound calls go back through the
+   same connectors via funnel MCP)
 ```
 
 ## Requirements
@@ -47,16 +62,34 @@ fnl gateway start
 fnl claude --channel my-inbox
 ```
 
+Schedule (cron) trigger:
+
+```bash
+# Register a schedule connector and a cron entry
+fnl connectors add daily --type schedule
+fnl connectors daily schedules add --cron "0 9 * * *" --prompt "morning standup"
+
+# Attach it to a channel just like any other connector
+fnl channels my-inbox connectors attach daily
+```
+
 ## Commands
 
 ```
 fnl connectors                              list
-fnl connectors add <name> --type <t> --bot-token <t> --app-token <t>
+fnl connectors add <name> --type slack    --bot-token xoxb-... --app-token xapp-...
+fnl connectors add <name> --type gh       [--poll-interval <sec>]
+fnl connectors add <name> --type discord  --bot-token <token>
+fnl connectors add <name> --type schedule
 fnl connectors <name>                       show details
-fnl connectors <name> set [--bot-token ...] [--app-token ...]
+fnl connectors <name> set [--bot-token ...] [--app-token ...] [--poll-interval ...]
 fnl connectors rename <old> <new>
 fnl connectors remove <name>
 
+fnl connectors <name> schedules                              list cron entries
+fnl connectors <name> schedules add --cron "<expr>" --prompt "<text>" [--disabled]
+fnl connectors <name> schedules remove <id>
+
 fnl request slack   post <path> [body] --connector <name>   call Slack Web API
 fnl request discord <method> <path> [body] --connector <name>   call Discord REST API
 
@@ -102,16 +135,29 @@ fnl --help        (every subcommand has --help)
 
 ```
 Connector =
-  | { type: "slack",   name, botToken, appToken }          Slack Socket Mode
-  | { type: "gh",      name, pollInterval? }                GitHub (gh CLI)
-  | { type: "discord", name, botToken }                     Discord Gateway
+  | { type: "slack",    name, botToken, appToken }
+        Slack Socket Mode
+  | { type: "gh",       name, pollInterval? }
+        GitHub (gh CLI)
+  | { type: "discord",  name, botToken }
+        Discord Gateway
+  | { type: "schedule", name, entries[] }
+        cron-driven, entries = { id, cron, prompt, enabled }
+
+Channel    = { name, connectors[] }
+        subscription box
+
+Repository = { name, path }
+        extra
+
+Profile    = { name, channel, repo?, subAgent?, envFiles? }
+        launch profile
 
-Channel    = { name, connectors[] }                        subscription box
-Repository = { name, path }                                 extra
-Profile    = { name, channel, repo?, subAgent?, envFiles? } launch profile
+Settings = { channels[], repositories[], profiles[] }
+        → ~/.funnel/settings.json
 
-Settings = { connectors[], channels[], repositories[], profiles[] }
-         → ~/.funnel/settings.json
+Connectors are stored per type, one file per connector:
+        → ~/.funnel/connectors/<type>/<name>.(json|jsonl)
 ```
 
 ## Discord bot setup
@@ -130,22 +176,26 @@ Settings = { connectors[], channels[], repositories[], profiles[] }
 
 ## File layout
 
-- Config: `~/.funnel/settings.json`
+- Config: `~/.funnel/settings.json` (channels / repositories / profiles)
+- Connectors: `~/.funnel/connectors/<type>/<name>.(json|jsonl)`
+  - `slack/<name>.json`, `gh/<name>.json`, `discord/<name>.json`
+  - `schedule/<name>.jsonl` (one entry per line) and `schedule/<name>.state.json` (last-fired timestamps for catch-up)
 - PID: `~/.funnel/gateway.pid`
+- Claude PIDs: `~/.funnel/claude/<profile>.pid`
 - Event log: `/tmp/funnel/events/*.jsonl` (auto-deleted after 30 days)
 - Process log: `/tmp/funnel/gateway.log`
 
 ## Links
 
-- [GitHub](https://github.com/interactive-inc/claude-funnel)
-- [Issues](https://github.com/interactive-inc/claude-funnel/issues)
-- Coding rules and design principles: [CLAUDE.md](https://github.com/interactive-inc/claude-funnel/blob/main/CLAUDE.md)
-- Design notes: [`.docs/`](https://github.com/interactive-inc/claude-funnel/tree/main/.docs)
+- [GitHub](https://github.com/interactive-inc/open-claude-funnel)
+- [Issues](https://github.com/interactive-inc/open-claude-funnel/issues)
+- Coding rules and design principles: [CLAUDE.md](https://github.com/interactive-inc/open-claude-funnel/blob/main/CLAUDE.md)
+- Design notes: [`.docs/`](https://github.com/interactive-inc/open-claude-funnel/tree/main/.docs)
 
 ## Development
 
 ```bash
-git clone https://github.com/interactive-inc/claude-funnel.git
+git clone https://github.com/interactive-inc/open-claude-funnel.git
 cd claude-funnel
 bun install
 bun link            # register funnel / fnl globally

package/lib/funnel.ts

@@ -1,14 +1,23 @@
 import { FunnelChannels } from "@/modules/channels/funnel-channels"
 import { FunnelClaude } from "@/modules/claude/funnel-claude"
+import {
+  type ConnectorStoresBundle,
+  createConnectorStores,
+} from "@/modules/connectors/funnel-connector-stores"
 import { FunnelConnectors } from "@/modules/connectors/funnel-connectors"
+import type { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
 import { FunnelGateway } from "@/modules/gateway/funnel-gateway"
 import { FunnelMcp } from "@/modules/mcp/funnel-mcp"
 import { FunnelProfiles } from "@/modules/profiles/funnel-profiles"
 import { FunnelRepositories } from "@/modules/repos/funnel-repositories"
+import { FunnelSchedule } from "@/modules/schedule/funnel-schedule"
 import { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
 
 type Props = {
   store: FunnelSettingsReader
+  fs?: FunnelFileSystem
+  dir?: string
+  connectorStores?: ConnectorStoresBundle
 }
 
 export class Funnel {
@@ -16,12 +25,47 @@ export class Funnel {
     Object.freeze(this)
   }
 
+  get stores(): ConnectorStoresBundle {
+    return (
+      this.props.connectorStores ??
+      createConnectorStores({ fs: this.props.fs, dir: this.props.dir })
+    )
+  }
+
   get connectors(): FunnelConnectors {
-    return new FunnelConnectors({ store: this.props.store })
+    const stores = this.stores
+    const profiles = this.profiles
+    const channels: FunnelChannels = new FunnelChannels({
+      store: this.props.store,
+      connectorChecker: { has: (name) => connectors.has(name) },
+      profileChecker: profiles,
+      profileRefUpdater: profiles,
+    })
+    const connectors: FunnelConnectors = new FunnelConnectors({
+      ...stores,
+      refUpdater: channels,
+    })
+    return connectors
   }
 
   get channels(): FunnelChannels {
-    return new FunnelChannels({ store: this.props.store })
+    const stores = this.stores
+    const profiles = this.profiles
+    const channels: FunnelChannels = new FunnelChannels({
+      store: this.props.store,
+      connectorChecker: { has: (name) => connectors.has(name) },
+      profileChecker: profiles,
+      profileRefUpdater: profiles,
+    })
+    const connectors: FunnelConnectors = new FunnelConnectors({
+      ...stores,
+      refUpdater: channels,
+    })
+    return channels
+  }
+
+  get schedule(): FunnelSchedule {
+    return new FunnelSchedule({ store: this.stores.schedule })
   }
 
   get profiles(): FunnelProfiles {

package/lib/index.ts

@@ -1,5 +1,7 @@
 #!/usr/bin/env bun
 import pkg from "../package.json" with { type: "json" }
+import { createConnectorStores } from "@/modules/connectors/funnel-connector-stores"
+import { migrateLegacyConnectors } from "@/modules/connectors/migrate-legacy-connectors"
 import { startChannelServer } from "@/modules/mcp/channel-server"
 import { toRequest } from "@/modules/router/to-request"
 import { launchTui } from "@/modules/tui/tui"
@@ -7,6 +9,8 @@ import { app } from "@/routes"
 
 process.title = "funnel"
 
+migrateLegacyConnectors({ stores: createConnectorStores() })
+
 const HELP = `funnel — Open Claude Funnel
 
 usage: funnel [command]

package/lib/modules/channels/channel-connector-ref-updater.ts

@@ -0,0 +1,4 @@
+export type ChannelConnectorRefUpdater = {
+  renameRef(oldName: string, newName: string): void
+  removeRef(connectorName: string): void
+}

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

@@ -1,15 +1,27 @@
+import type { ConnectorExistenceChecker } from "@/modules/connectors/connector-existence-checker"
+import type { ProfileChannelChecker } from "@/modules/profiles/profile-channel-checker"
+import type { ProfileChannelRefUpdater } from "@/modules/profiles/profile-channel-ref-updater"
 import { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
 import type { ChannelConfig } from "@/modules/settings/settings-schema"
 
 type Deps = {
   store: FunnelSettingsReader
+  connectorChecker: ConnectorExistenceChecker
+  profileChecker: ProfileChannelChecker
+  profileRefUpdater: ProfileChannelRefUpdater
 }
 
 export class FunnelChannels {
   private readonly store: FunnelSettingsReader
+  private readonly connectorChecker: ConnectorExistenceChecker
+  private readonly profileChecker: ProfileChannelChecker
+  private readonly profileRefUpdater: ProfileChannelRefUpdater
 
   constructor(deps: Deps) {
     this.store = deps.store
+    this.connectorChecker = deps.connectorChecker
+    this.profileChecker = deps.profileChecker
+    this.profileRefUpdater = deps.profileRefUpdater
     Object.freeze(this)
   }
 
@@ -29,7 +41,7 @@ export class FunnelChannels {
     }
 
     for (const connectorName of config.connectors) {
-      if (!settings.connectors.some((c) => c.name === connectorName)) {
+      if (!this.connectorChecker.has(connectorName)) {
         throw new Error(`connector "${connectorName}" not found`)
       }
     }
@@ -46,7 +58,7 @@ export class FunnelChannels {
 
     if (index < 0) throw new Error(`channel "${name}" not found`)
 
-    if (settings.profiles.some((p) => p.channel === name)) {
+    if (this.profileChecker.hasChannelRef(name)) {
       throw new Error(`channel "${name}" is referenced by a profile`)
     }
 
@@ -68,11 +80,9 @@ export class FunnelChannels {
 
     channel.name = newName
 
-    for (const profile of settings.profiles) {
-      if (profile.channel === oldName) profile.channel = newName
-    }
-
     this.store.write(settings)
+
+    this.profileRefUpdater.renameChannelRef(oldName, newName)
   }
 
   attachConnector(name: string, connectorName: string): void {
@@ -82,7 +92,7 @@ export class FunnelChannels {
 
     if (!channel) throw new Error(`channel "${name}" not found`)
 
-    if (!settings.connectors.some((c) => c.name === connectorName)) {
+    if (!this.connectorChecker.has(connectorName)) {
       throw new Error(`connector "${connectorName}" not found`)
     }
 
@@ -110,4 +120,36 @@ export class FunnelChannels {
 
     this.store.write(settings)
   }
+
+  renameRef(oldName: string, newName: string): void {
+    const settings = this.store.read()
+    let changed = false
+
+    for (const channel of settings.channels) {
+      const i = channel.connectors.indexOf(oldName)
+
+      if (i >= 0) {
+        channel.connectors[i] = newName
+        changed = true
+      }
+    }
+
+    if (changed) this.store.write(settings)
+  }
+
+  removeRef(connectorName: string): void {
+    const settings = this.store.read()
+    let changed = false
+
+    for (const channel of settings.channels) {
+      const i = channel.connectors.indexOf(connectorName)
+
+      if (i >= 0) {
+        channel.connectors.splice(i, 1)
+        changed = true
+      }
+    }
+
+    if (changed) this.store.write(settings)
+  }
 }

package/lib/modules/connectors/connector-config-schema.ts

@@ -0,0 +1,16 @@
+import { z } from "zod"
+import { discordConnectorSchema } from "@/modules/connectors/discord-connector-schema"
+import { ghConnectorSchema } from "@/modules/connectors/gh-connector-schema"
+import { scheduleConnectorSchema } from "@/modules/connectors/schedule-connector-schema"
+import { slackConnectorSchema } from "@/modules/connectors/slack-connector-schema"
+
+export const connectorConfigSchema = z.discriminatedUnion("type", [
+  slackConnectorSchema,
+  ghConnectorSchema,
+  discordConnectorSchema,
+  scheduleConnectorSchema,
+])
+
+export type ConnectorConfig = z.infer<typeof connectorConfigSchema>
+
+export type ConnectorType = ConnectorConfig["type"]

package/lib/modules/connectors/connector-existence-checker.ts

@@ -0,0 +1,3 @@
+export type ConnectorExistenceChecker = {
+  has(name: string): boolean
+}

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

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

package/lib/modules/connectors/funnel-callable-connector-store.ts

@@ -0,0 +1,9 @@
+import type { FunnelConnectorAdapter } from "@/modules/connectors/funnel-connector-adapter"
+import { FunnelConnectorTypeStore } from "@/modules/connectors/funnel-connector-type-store"
+import type { ConnectorConfig } from "@/modules/connectors/connector-config-schema"
+
+export abstract class FunnelCallableConnectorStore<
+  TConfig extends ConnectorConfig,
+> extends FunnelConnectorTypeStore<TConfig> {
+  abstract createAdapter(config: TConfig): FunnelConnectorAdapter
+}

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

@@ -0,0 +1,24 @@
+import { FunnelDiscordStore } from "@/modules/connectors/funnel-discord-store"
+import { FunnelGhStore } from "@/modules/connectors/funnel-gh-store"
+import { FunnelScheduleStore } from "@/modules/connectors/funnel-schedule-store"
+import { FunnelSlackStore } from "@/modules/connectors/funnel-slack-store"
+import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+
+export type ConnectorStoresBundle = {
+  slack: FunnelSlackStore
+  gh: FunnelGhStore
+  discord: FunnelDiscordStore
+  schedule: FunnelScheduleStore
+}
+
+type Deps = {
+  fs?: FunnelFileSystem
+  dir?: string
+}
+
+export const createConnectorStores = (deps: Deps = {}): ConnectorStoresBundle => ({
+  slack: new FunnelSlackStore(deps),
+  gh: new FunnelGhStore(deps),
+  discord: new FunnelDiscordStore(deps),
+  schedule: new FunnelScheduleStore(deps),
+})

package/lib/modules/connectors/funnel-connector-type-store.ts

@@ -0,0 +1,24 @@
+import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
+import type { ConnectorConfig } from "@/modules/connectors/connector-config-schema"
+
+export abstract class FunnelConnectorTypeStore<TConfig extends ConnectorConfig> {
+  abstract readonly type: TConfig["type"]
+
+  abstract list(): TConfig[]
+
+  abstract get(name: string): TConfig | null
+
+  abstract has(name: string): boolean
+
+  abstract add(config: TConfig): void
+
+  abstract remove(name: string): void
+
+  abstract rename(oldName: string, newName: string): void
+
+  abstract createListener(config: TConfig): FunnelConnectorListener
+
+  createAllListeners(): { config: TConfig; listener: FunnelConnectorListener }[] {
+    return this.list().map((config) => ({ config, listener: this.createListener(config) }))
+  }
+}

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

@@ -1,124 +1,145 @@
+import type { ChannelConnectorRefUpdater } from "@/modules/channels/channel-connector-ref-updater"
+import type { ConnectorConfig } from "@/modules/connectors/connector-config-schema"
 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"
+import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
+import type {
+  DiscordUpdateFields,
+  FunnelDiscordStore,
+} from "@/modules/connectors/funnel-discord-store"
+import type { FunnelGhStore, GhUpdateFields } from "@/modules/connectors/funnel-gh-store"
+import type { FunnelScheduleStore } from "@/modules/connectors/funnel-schedule-store"
+import type { FunnelSlackStore, SlackUpdateFields } from "@/modules/connectors/funnel-slack-store"
 
 type Deps = {
-  store: FunnelSettingsReader
-}
-
-type UpdateFields = {
-  botToken?: string
-  appToken?: string
-  pollInterval?: number
+  slack: FunnelSlackStore
+  gh: FunnelGhStore
+  discord: FunnelDiscordStore
+  schedule: FunnelScheduleStore
+  refUpdater: ChannelConnectorRefUpdater
 }
 
 export class FunnelConnectors {
-  private readonly store: FunnelSettingsReader
+  private readonly slack: FunnelSlackStore
+  private readonly gh: FunnelGhStore
+  private readonly discord: FunnelDiscordStore
+  private readonly schedule: FunnelScheduleStore
+  private readonly refUpdater: ChannelConnectorRefUpdater
 
   constructor(deps: Deps) {
-    this.store = deps.store
+    this.slack = deps.slack
+    this.gh = deps.gh
+    this.discord = deps.discord
+    this.schedule = deps.schedule
+    this.refUpdater = deps.refUpdater
     Object.freeze(this)
   }
 
   list(): ConnectorConfig[] {
-    return this.store.read().connectors
+    return [
+      ...this.slack.list(),
+      ...this.gh.list(),
+      ...this.discord.list(),
+      ...this.schedule.list(),
+    ]
   }
 
   get(name: string): ConnectorConfig | null {
-    return this.list().find((c) => c.name === name) ?? null
+    return (
+      this.slack.get(name) ??
+      this.gh.get(name) ??
+      this.discord.get(name) ??
+      this.schedule.get(name)
+    )
   }
 
-  add(config: ConnectorConfig): void {
-    const settings = this.store.read()
+  has(name: string): boolean {
+    return (
+      this.slack.has(name) ||
+      this.gh.has(name) ||
+      this.discord.has(name) ||
+      this.schedule.has(name)
+    )
+  }
 
-    if (settings.connectors.some((c) => c.name === config.name)) {
-      throw new Error(`connector "${config.name}" already exists`)
-    }
+  add(config: ConnectorConfig): void {
+    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
 
-    settings.connectors.push(config)
+    if (config.type === "slack") return this.slack.add(config)
+    if (config.type === "gh") return this.gh.add(config)
+    if (config.type === "discord") return this.discord.add(config)
 
-    this.store.write(settings)
+    return this.schedule.add(config)
   }
 
-  rename(oldName: string, newName: string): void {
-    const settings = this.store.read()
-
-    const connector = settings.connectors.find((c) => c.name === oldName)
+  updateSlack(name: string, fields: SlackUpdateFields): void {
+    this.slack.update(name, fields)
+  }
 
-    if (!connector) throw new Error(`connector "${oldName}" not found`)
+  updateGh(name: string, fields: GhUpdateFields): void {
+    this.gh.update(name, fields)
+  }
 
-    if (settings.connectors.some((c) => c.name === newName)) {
-      throw new Error(`connector "${newName}" already exists`)
-    }
+  updateDiscord(name: string, fields: DiscordUpdateFields): void {
+    this.discord.update(name, fields)
+  }
 
-    connector.name = newName
+  remove(name: string): void {
+    const current = this.get(name)
 
-    for (const channel of settings.channels) {
-      const index = channel.connectors.indexOf(oldName)
+    if (!current) throw new Error(`connector "${name}" not found`)
 
-      if (index >= 0) channel.connectors[index] = newName
-    }
+    if (current.type === "slack") this.slack.remove(name)
+    else if (current.type === "gh") this.gh.remove(name)
+    else if (current.type === "discord") this.discord.remove(name)
+    else this.schedule.remove(name)
 
-    this.store.write(settings)
+    this.refUpdater.removeRef(name)
   }
 
-  update(name: string, fields: UpdateFields): void {
-    const settings = this.store.read()
-
-    const connector = settings.connectors.find((c) => c.name === name)
+  rename(oldName: string, newName: string): void {
+    const current = this.get(oldName)
 
-    if (!connector) throw new Error(`connector "${name}" not found`)
+    if (!current) throw new Error(`connector "${oldName}" not found`)
+    if (this.has(newName)) throw new Error(`connector "${newName}" already exists`)
 
-    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
-    }
+    if (current.type === "slack") this.slack.rename(oldName, newName)
+    else if (current.type === "gh") this.gh.rename(oldName, newName)
+    else if (current.type === "discord") this.discord.rename(oldName, newName)
+    else this.schedule.rename(oldName, newName)
 
-    this.store.write(settings)
+    this.refUpdater.renameRef(oldName, newName)
   }
 
-  remove(name: string): void {
-    const settings = this.store.read()
-
-    const index = settings.connectors.findIndex((c) => c.name === name)
+  async callSlack(name: string, input: CallInput): Promise<unknown> {
+    const config = this.slack.get(name)
 
-    if (index < 0) throw new Error(`connector "${name}" not found`)
+    if (!config) throw new Error(`slack connector "${name}" not found`)
 
-    settings.connectors.splice(index, 1)
+    return await this.slack.createAdapter(config).call(input)
+  }
 
-    for (const channel of settings.channels) {
-      const ci = channel.connectors.indexOf(name)
+  async callGh(name: string, input: CallInput): Promise<unknown> {
+    const config = this.gh.get(name)
 
-      if (ci >= 0) channel.connectors.splice(ci, 1)
-    }
+    if (!config) throw new Error(`gh connector "${name}" not found`)
 
-    this.store.write(settings)
+    return await this.gh.createAdapter(config).call(input)
   }
 
-  async call(name: string, input: CallInput): Promise<unknown> {
-    const connector = this.get(name)
-
-    if (!connector) throw new Error(`connector "${name}" not found`)
+  async callDiscord(name: string, input: CallInput): Promise<unknown> {
+    const config = this.discord.get(name)
 
-    if (connector.type === "slack") {
-      return await new FunnelSlackAdapter({ config: connector }).call(input)
-    }
+    if (!config) throw new Error(`discord connector "${name}" not found`)
 
-    if (connector.type === "gh") {
-      return await new FunnelGhAdapter().call(input)
-    }
-
-    if (connector.type === "discord") {
-      return await new FunnelDiscordAdapter({ config: connector }).call(input)
-    }
+    return await this.discord.createAdapter(config).call(input)
+  }
 
-    throw new Error(`unsupported connector type: ${(connector as { type: string }).type}`)
+  createListeners(): { config: ConnectorConfig; listener: FunnelConnectorListener }[] {
+    return [
+      ...this.slack.createAllListeners(),
+      ...this.gh.createAllListeners(),
+      ...this.discord.createAllListeners(),
+      ...this.schedule.createAllListeners(),
+    ]
   }
 }