@interactive-inc/claude-funnel 0.4.0 → 0.7.1

package/README.md

@@ -160,6 +160,106 @@ Connectors are stored per type, one file per connector:
         → ~/.funnel/connectors/<type>/<name>.(json|jsonl)
 ```
 
+## Programmable API (Bun)
+
+`funnel` is also usable as a library — the same `Funnel` facade the CLI uses is exported from the package root, with no CLI side effects.
+
+```ts
+import {
+  Funnel,
+  FunnelSettingsStore,
+} from "@interactive-inc/claude-funnel"
+
+const funnel = new Funnel({ store: new FunnelSettingsStore() })
+
+funnel.connectors.add({
+  type: "slack",
+  name: "my-slack",
+  botToken: "xoxb-...",
+  appToken: "xapp-...",
+})
+
+funnel.channels.add({ name: "inbox", connectors: ["my-slack"] })
+
+for (const c of funnel.connectors.list()) console.log(c.type, c.name)
+```
+
+All Funnel facets — `connectors` / `channels` / `profiles` / `repositories` / `schedule` / `gateway` / `mcp` / `claude` — are reachable from the same instance:
+
+```ts
+funnel.gateway.getStatus()                  // { running, pid, port }
+await funnel.gateway.start()                // spawns the daemon as a separate process
+await funnel.claude.launch({ channel: "inbox" })
+funnel.mcp.install("/path/to/repo")         // writes .mcp.json
+```
+
+Or run the gateway in-process (no daemon spawn — useful for tests, embedding, or custom hosts):
+
+```ts
+const server = funnel.gatewayServer({ port: 9742 })
+await server.start()             // starts Bun.serve, boots all connector listeners
+server.getStatus()                // { clients, channels: [...] }
+server.getBroadcaster().broadcast("hello", { connector: "my-slack" })
+server.stop()
+```
+
+Every side-effecting boundary is a DI seam. For tests / sandbox use, swap them all with the in-memory implementations and Funnel will not touch real disk, real processes, real time, or real UUIDs:
+
+```ts
+import {
+  Funnel,
+  MemoryFunnelClock,
+  MemoryFunnelFileSystem,
+  MemoryFunnelIdGenerator,
+  MemoryFunnelLogger,
+  MemoryFunnelProcessRunner,
+  MockFunnelSettingsReader,
+} from "@interactive-inc/claude-funnel"
+
+const funnel = new Funnel({
+  store: new MockFunnelSettingsReader(),
+  fs: new MemoryFunnelFileSystem(),
+  process: new MemoryFunnelProcessRunner(),
+  logger: new MemoryFunnelLogger(),
+  clock: new MemoryFunnelClock({ start: new Date("2026-01-01T00:00:00Z") }),
+  idGenerator: new MemoryFunnelIdGenerator({ prefix: "test" }),
+  dir: "/sandbox/.funnel",
+  tmpDir: "/sandbox/tmp",
+})
+```
+
+Available abstractions (each has `Funnel*` interface, `Node*` default, and `Memory*` for tests): `FunnelFileSystem`, `FunnelProcessRunner`, `FunnelLogger`, `FunnelClock`, `FunnelIdGenerator`. Plus `NoopFunnelLogger` for silent operation.
+
+The package ships TypeScript sources directly, so a Bun runtime is required. Importing `@interactive-inc/claude-funnel/cli` resolves to the CLI entry point (with side effects) — only do this if you're embedding the CLI rather than the library.
+
+## Claude Code skill
+
+This repo ships a Claude Code skill at `.claude/skills/funnel/SKILL.md`. It briefs Claude on the architecture and command groups, and tells it to defer flag-level details to `funnel <command> --help`.
+
+### Project-scoped (auto)
+
+If you run `claude` inside this repo, the skill is picked up automatically — no install step.
+
+### Global (use the skill in any project)
+
+Claude Code does not currently provide a CLI to install skills from a remote URL, so copy the file into your personal skills directory:
+
+```bash
+# from a clone of this repo
+mkdir -p ~/.claude/skills/funnel
+cp .claude/skills/funnel/SKILL.md ~/.claude/skills/funnel/
+```
+
+Or fetch it directly without cloning:
+
+```bash
+mkdir -p ~/.claude/skills/funnel
+curl -fsSL https://raw.githubusercontent.com/interactive-inc/open-claude-funnel/main/.claude/skills/funnel/SKILL.md \
+  -o ~/.claude/skills/funnel/SKILL.md
+```
+
+After this, Claude Code will load the skill in any session.
+
 ## Discord bot setup
 
 - Create a bot in the Discord Developer Portal and obtain its token
@@ -187,15 +287,15 @@ Connectors are stored per type, one file per connector:
 
 ## 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/api.ts

@@ -0,0 +1,54 @@
+export { Funnel } from "@/funnel"
+
+export { FunnelChannels } from "@/modules/channels/funnel-channels"
+export { FunnelClaude } from "@/modules/claude/funnel-claude"
+export { FunnelConnectors } from "@/modules/connectors/funnel-connectors"
+export {
+  type ConnectorStoresBundle,
+  createConnectorStores,
+} from "@/modules/connectors/funnel-connector-stores"
+export { FunnelGateway } from "@/modules/gateway/funnel-gateway"
+export { FunnelGatewayServer } from "@/modules/gateway/funnel-gateway-server"
+export { FunnelBroadcaster } from "@/modules/gateway/funnel-broadcaster"
+export { FunnelEventLogger } from "@/modules/gateway/funnel-event-logger"
+export { FunnelMcp } from "@/modules/mcp/funnel-mcp"
+export { FunnelProfiles } from "@/modules/profiles/funnel-profiles"
+export { FunnelRepositories } from "@/modules/repos/funnel-repositories"
+export { FunnelSchedule } from "@/modules/schedule/funnel-schedule"
+
+export { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+export { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
+export { MemoryFunnelFileSystem } from "@/modules/fs/memory-funnel-file-system"
+
+export { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
+export { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-process-runner"
+export { MemoryFunnelProcessRunner } from "@/modules/process/memory-funnel-process-runner"
+
+export { FunnelLogger } from "@/modules/logger/funnel-logger"
+export { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
+export { MemoryFunnelLogger, type LogEntry } from "@/modules/logger/memory-funnel-logger"
+export { NoopFunnelLogger } from "@/modules/logger/noop-funnel-logger"
+
+export { FunnelClock } from "@/modules/time/funnel-clock"
+export { NodeFunnelClock } from "@/modules/time/node-funnel-clock"
+export { MemoryFunnelClock } from "@/modules/time/memory-funnel-clock"
+
+export { FunnelIdGenerator } from "@/modules/id/funnel-id-generator"
+export { NodeFunnelIdGenerator } from "@/modules/id/node-funnel-id-generator"
+export { MemoryFunnelIdGenerator } from "@/modules/id/memory-funnel-id-generator"
+
+export { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
+export { FunnelSettingsStore } from "@/modules/settings/funnel-settings-store"
+export { MockFunnelSettingsReader } from "@/modules/settings/mock-funnel-settings-reader"
+
+export type { ConnectorConfig } from "@/modules/connectors/connector-config-schema"
+export type {
+  ChannelConfig,
+  ProfileConfig,
+  RepositoryConfig,
+  Settings,
+} from "@/modules/settings/settings-schema"
+export type {
+  ScheduleConnectorConfig,
+  ScheduleEntry,
+} from "@/modules/connectors/schedule-connector-schema"

package/lib/funnel.ts

@@ -1,3 +1,4 @@
+import { join } from "node:path"
 import { FunnelChannels } from "@/modules/channels/funnel-channels"
 import { FunnelClaude } from "@/modules/claude/funnel-claude"
 import {
@@ -7,89 +8,175 @@ import {
 import { FunnelConnectors } from "@/modules/connectors/funnel-connectors"
 import type { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
 import { FunnelGateway } from "@/modules/gateway/funnel-gateway"
+import { FunnelGatewayServer } from "@/modules/gateway/funnel-gateway-server"
+import type { FunnelIdGenerator } from "@/modules/id/funnel-id-generator"
+import type { FunnelLogger } from "@/modules/logger/funnel-logger"
 import { FunnelMcp } from "@/modules/mcp/funnel-mcp"
+import type { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
 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"
+import { FUNNEL_DIR, FunnelSettingsStore } from "@/modules/settings/funnel-settings-store"
+import type { FunnelClock } from "@/modules/time/funnel-clock"
 
 type Props = {
-  store: FunnelSettingsReader
+  /** Settings persistence (channels / repositories / profiles). Defaults to a FunnelSettingsStore rooted at `dir`. */
+  store?: FunnelSettingsReader
+  /** Filesystem boundary. Replace with MemoryFunnelFileSystem to sandbox all disk I/O. */
   fs?: FunnelFileSystem
+  /** Process runner used by gateway / claude / gh listener. Replace with MemoryFunnelProcessRunner for tests. */
+  process?: FunnelProcessRunner
+  /** Logger flowed into every facet. Replace with MemoryFunnelLogger or NoopFunnelLogger to silence/inspect. */
+  logger?: FunnelLogger
+  /** Clock used by schedule listener, gh poll watermarks, and gateway timeouts. */
+  clock?: FunnelClock
+  /** ID generator for schedule entry ids. Use MemoryFunnelIdGenerator for deterministic tests. */
+  idGenerator?: FunnelIdGenerator
+  /** Funnel home directory (settings.json + connectors/<type>/). Defaults to ~/.funnel. */
   dir?: string
+  /** Temp / runtime directory (gateway logs and PID adjacent files). Defaults to /tmp/funnel. */
+  tmpDir?: string
+  /** Pre-built connector stores. Useful when sharing stores between multiple Funnel instances. */
   connectorStores?: ConnectorStoresBundle
 }
 
+/**
+ * Facade exposing every funnel facet as a getter.
+ *
+ * The same `Funnel` is used by the CLI, the TUI, and as a programmable library.
+ * All side-effecting boundaries (filesystem, process, logger, clock, id, paths) are
+ * injectable via `Props` — passing memory implementations gives a fully sandboxed
+ * Funnel that touches no real disk, processes, or wall-clock time.
+ *
+ * @example
+ * ```ts
+ * const funnel = new Funnel({})
+ * funnel.connectors.add({ type: "slack", name: "ops", botToken, appToken })
+ * funnel.channels.add({ name: "inbox", connectors: ["ops"] })
+ * await funnel.gatewayServer({ port: 9742 }).start()
+ * ```
+ */
 export class Funnel {
-  constructor(private readonly props: Props) {
+  constructor(private readonly props: Props = {}) {
     Object.freeze(this)
   }
 
+  /** Settings reader. If not injected, a FunnelSettingsStore rooted at `dir` is created. */
+  get store(): FunnelSettingsReader {
+    return (
+      this.props.store ??
+      new FunnelSettingsStore({
+        path: join(this.props.dir ?? FUNNEL_DIR, "settings.json"),
+        fs: this.props.fs,
+      })
+    )
+  }
+
+  /** Per-type connector stores (slack / gh / discord / schedule), all DI'd from Props. */
   get stores(): ConnectorStoresBundle {
     return (
       this.props.connectorStores ??
-      createConnectorStores({ fs: this.props.fs, dir: this.props.dir })
+      createConnectorStores({
+        fs: this.props.fs,
+        process: this.props.process,
+        logger: this.props.logger,
+        clock: this.props.clock,
+        idGenerator: this.props.idGenerator,
+        dir: this.props.dir,
+      })
     )
   }
 
+  /** Connector CRUD + per-type call/listener APIs. Wired with channels in a forward-const closure. */
   get connectors(): FunnelConnectors {
-    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
+    return this.wirePair().connectors
   }
 
+  /** Channel CRUD + connector attach/detach. Wired with connectors and profiles via DI. */
   get channels(): FunnelChannels {
-    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
+    return this.wirePair().channels
   }
 
+  /** Schedule connector entry CRUD (cron lines). */
   get schedule(): FunnelSchedule {
     return new FunnelSchedule({ store: this.stores.schedule })
   }
 
+  /** Launch profiles (named presets for `fnl claude`). */
   get profiles(): FunnelProfiles {
-    return new FunnelProfiles({ store: this.props.store })
+    return new FunnelProfiles({ store: this.store })
   }
 
+  /** Repository registry; writes the funnel MCP entry into each repo's .mcp.json. */
   get repositories(): FunnelRepositories {
-    return new FunnelRepositories({ store: this.props.store, mcp: this.mcp })
+    return new FunnelRepositories({ store: this.store, mcp: this.mcp })
   }
 
+  /** Launch Claude Code with a channel injected via env, MCP installed, gateway ensured. */
   get claude(): FunnelClaude {
     return new FunnelClaude({
       channels: this.channels,
       repositories: this.repositories,
       mcp: this.mcp,
       gateway: this.gateway,
+      fs: this.props.fs,
+      process: this.props.process,
+      logger: this.props.logger,
+      dir: this.props.dir,
     })
   }
 
+  /** Gateway daemon controller (PID-file, start/stop the separate `bun daemon.ts` process). */
   get gateway(): FunnelGateway {
-    return new FunnelGateway()
+    return new FunnelGateway({
+      fs: this.props.fs,
+      process: this.props.process,
+      clock: this.props.clock,
+      dir: this.props.dir,
+      tmpDir: this.props.tmpDir,
+    })
   }
 
+  /**
+   * In-process gateway server. Unlike `gateway.start()` (which spawns a daemon),
+   * this returns a class that runs `Bun.serve` + listeners inside the current process —
+   * useful for tests, embedding, or custom hosts.
+   */
+  gatewayServer(
+    options: { port?: number; logDir?: string; killCompetingSlack?: boolean } = {},
+  ): FunnelGatewayServer {
+    return new FunnelGatewayServer({
+      connectors: this.connectors,
+      settings: this.store,
+      port: options.port,
+      logDir: options.logDir,
+      fs: this.props.fs,
+      process: this.props.process,
+      clock: this.props.clock,
+      logger: this.props.logger,
+      killCompetingSlack: options.killCompetingSlack,
+    })
+  }
+
+  /** funnel MCP installer (writes/removes `.mcp.json` entries in target repos). */
   get mcp(): FunnelMcp {
-    return new FunnelMcp()
+    return new FunnelMcp({ fs: this.props.fs })
+  }
+
+  private wirePair(): { channels: FunnelChannels; connectors: FunnelConnectors } {
+    const stores = this.stores
+    const profiles = this.profiles
+    const channels: FunnelChannels = new FunnelChannels({
+      store: this.store,
+      connectorChecker: { has: (name) => connectors.has(name) },
+      profileChecker: profiles,
+      profileRefUpdater: profiles,
+    })
+    const connectors: FunnelConnectors = new FunnelConnectors({
+      ...stores,
+      refUpdater: channels,
+    })
+    return { channels, connectors }
   }
 }

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

@@ -11,6 +11,11 @@ type Deps = {
   profileRefUpdater: ProfileChannelRefUpdater
 }
 
+/**
+ * Subscription boxes that fan connector events out to Claude Code sessions.
+ * A channel attaches one or more connectors; the gateway's WebSocket clients
+ * subscribe by channel name. Name changes propagate to profile channel refs.
+ */
 export class FunnelChannels {
   private readonly store: FunnelSettingsReader
   private readonly connectorChecker: ConnectorExistenceChecker

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

@@ -3,15 +3,14 @@ import type { FunnelChannels } from "@/modules/channels/funnel-channels"
 import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
 import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
 import type { FunnelGateway } from "@/modules/gateway/funnel-gateway"
-import { logger } from "@/modules/logger"
+import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
 import type { FunnelMcp } from "@/modules/mcp/funnel-mcp"
 import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
 import { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-process-runner"
 import type { FunnelRepositories } from "@/modules/repos/funnel-repositories"
 import { FUNNEL_DIR } from "@/modules/settings/funnel-settings-store"
 
-const CLAUDE_PID_DIR = join(FUNNEL_DIR, "claude")
-
 export type LaunchOptions = {
   channel: string
   repo?: string
@@ -28,11 +27,20 @@ type Deps = {
   gateway: FunnelGateway
   process?: FunnelProcessRunner
   fs?: FunnelFileSystem
+  logger?: FunnelLogger
+  dir?: string
 }
 
 const defaultProcess = new NodeFunnelProcessRunner()
 const defaultFs = new NodeFunnelFileSystem()
-
+const defaultLogger = new NodeFunnelLogger()
+
+/**
+ * Launches Claude Code with funnel pre-wired: ensures the gateway is running,
+ * installs the funnel MCP into the target repo's `.mcp.json` if missing,
+ * injects `FUNNEL_CHANNEL_ID` into the child env, and writes a per-profile
+ * PID file to enforce singleton launches.
+ */
 export class FunnelClaude {
   private readonly channels: FunnelChannels
   private readonly repositories: FunnelRepositories
@@ -40,6 +48,8 @@ export class FunnelClaude {
   private readonly gateway: FunnelGateway
   private readonly process: FunnelProcessRunner
   private readonly fs: FunnelFileSystem
+  private readonly logger: FunnelLogger
+  private readonly pidDir: string
 
   constructor(deps: Deps) {
     this.channels = deps.channels
@@ -48,6 +58,8 @@ export class FunnelClaude {
     this.gateway = deps.gateway
     this.process = deps.process ?? defaultProcess
     this.fs = deps.fs ?? defaultFs
+    this.logger = deps.logger ?? defaultLogger
+    this.pidDir = join(deps.dir ?? FUNNEL_DIR, "claude")
     Object.freeze(this)
   }
 
@@ -69,11 +81,11 @@ export class FunnelClaude {
     if (!this.mcp.findInstalledName(cwd)) {
       this.mcp.install(cwd)
 
-      logger.info(`added funnel MCP to .mcp.json`, { cwd })
+      this.logger.info(`added funnel MCP to .mcp.json`, { cwd })
     }
 
     if (!this.gateway.isRunning()) {
-      logger.info(`starting gateway automatically`)
+      this.logger.info(`starting gateway automatically`)
       await this.gateway.start()
     }
 
@@ -85,7 +97,7 @@ export class FunnelClaude {
     const claudeArgs = this.buildArgs(options, cwd)
     const env = this.buildEnv(options, cwd)
 
-    logger.info(`claude launch`, {
+    this.logger.info(`claude launch`, {
       channel: options.channel,
       repo: options.repo,
       subAgent: options.subAgent,
@@ -108,7 +120,7 @@ export class FunnelClaude {
   }
 
   private pidPath(profileName: string): string {
-    return join(CLAUDE_PID_DIR, `${profileName}.pid`)
+    return join(this.pidDir, `${profileName}.pid`)
   }
 
   private readPid(profileName: string): number | null {
@@ -129,7 +141,7 @@ export class FunnelClaude {
   }
 
   private writePidFile(profileName: string): void {
-    this.fs.mkdirSync(CLAUDE_PID_DIR, { recursive: true })
+    this.fs.mkdirSync(this.pidDir, { recursive: true })
     this.fs.writeFileSync(this.pidPath(profileName), String(globalThis.process.pid))
   }
 

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

@@ -3,6 +3,10 @@ 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"
+import { FunnelIdGenerator } from "@/modules/id/funnel-id-generator"
+import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
+import { FunnelClock } from "@/modules/time/funnel-clock"
 
 export type ConnectorStoresBundle = {
   slack: FunnelSlackStore
@@ -13,12 +17,36 @@ export type ConnectorStoresBundle = {
 
 type Deps = {
   fs?: FunnelFileSystem
+  process?: FunnelProcessRunner
+  logger?: FunnelLogger
+  clock?: FunnelClock
+  idGenerator?: FunnelIdGenerator
   dir?: string
 }
 
 export const createConnectorStores = (deps: Deps = {}): ConnectorStoresBundle => ({
-  slack: new FunnelSlackStore(deps),
-  gh: new FunnelGhStore(deps),
-  discord: new FunnelDiscordStore(deps),
-  schedule: new FunnelScheduleStore(deps),
+  slack: new FunnelSlackStore({
+    fs: deps.fs,
+    dir: deps.dir,
+    logger: deps.logger,
+  }),
+  gh: new FunnelGhStore({
+    fs: deps.fs,
+    dir: deps.dir,
+    process: deps.process,
+    logger: deps.logger,
+    clock: deps.clock,
+  }),
+  discord: new FunnelDiscordStore({
+    fs: deps.fs,
+    dir: deps.dir,
+    logger: deps.logger,
+  }),
+  schedule: new FunnelScheduleStore({
+    fs: deps.fs,
+    dir: deps.dir,
+    logger: deps.logger,
+    idGenerator: deps.idGenerator,
+    clock: deps.clock,
+  }),
 })

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

@@ -18,6 +18,12 @@ type Deps = {
   refUpdater: ChannelConnectorRefUpdater
 }
 
+/**
+ * Aggregates per-type connector stores (slack / gh / discord / schedule) behind a single facade.
+ * Add / remove / rename mutate the underlying type-specific store and propagate name changes
+ * to channel references via `refUpdater`. Per-type APIs (`updateSlack`, `callDiscord`, ...) keep
+ * field-level operations type-narrowed without runtime defense.
+ */
 export class FunnelConnectors {
   private readonly slack: FunnelSlackStore
   private readonly gh: FunnelGhStore

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

@@ -4,19 +4,25 @@ import {
   type NotifyFn,
 } from "@/modules/connectors/funnel-connector-listener"
 import { FunnelDiscordEventProcessor } from "@/modules/connectors/funnel-discord-event-processor"
-import { logger } from "@/modules/logger"
+import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
 import type { DiscordConnectorConfig } from "@/modules/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
 
   constructor(deps: Deps) {
     super()
     this.config = deps.config
+    this.logger = deps.logger ?? defaultLogger
     Object.freeze(this)
   }
 
@@ -48,14 +54,14 @@ export class FunnelDiscordListener extends FunnelConnectorListener {
       try {
         await notify(result.content, result.meta)
       } catch (error) {
-        logger.error("discord notify error", {
+        this.logger.error("discord notify error", {
           error: error instanceof Error ? error.message : String(error),
         })
       }
     })
 
     client.on("error", (error) => {
-      logger.error("discord client error", {
+      this.logger.error("discord client error", {
         error: error instanceof Error ? error.message : String(error),
       })
     })

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

@@ -12,10 +12,12 @@ import {
   discordConnectorSchema,
 } from "@/modules/connectors/discord-connector-schema"
 import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+import type { FunnelLogger } from "@/modules/logger/funnel-logger"
 
 type Deps = {
   fs?: FunnelFileSystem
   dir?: string
+  logger?: FunnelLogger
 }
 
 export type DiscordUpdateFields = {
@@ -25,6 +27,7 @@ export type DiscordUpdateFields = {
 export class FunnelDiscordStore extends FunnelCallableConnectorStore<DiscordConnectorConfig> {
   readonly type = "discord" as const
   private readonly store: FunnelJsonConnectorStore<DiscordConnectorConfig>
+  private readonly logger?: FunnelLogger
 
   constructor(deps: Deps = {}) {
     super()
@@ -34,6 +37,7 @@ export class FunnelDiscordStore extends FunnelCallableConnectorStore<DiscordConn
       fs: deps.fs,
       dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
     })
+    this.logger = deps.logger
     Object.freeze(this)
   }
 
@@ -75,7 +79,7 @@ export class FunnelDiscordStore extends FunnelCallableConnectorStore<DiscordConn
   }
 
   createListener(config: DiscordConnectorConfig): FunnelConnectorListener {
-    return new FunnelDiscordListener({ config })
+    return new FunnelDiscordListener({ config, logger: this.logger })
   }
 
   createAdapter(config: DiscordConnectorConfig): FunnelConnectorAdapter {