@interactive-inc/claude-funnel 0.4.1 → 0.7.1

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

@@ -2,7 +2,8 @@ import {
   FunnelConnectorListener,
   type NotifyFn,
 } from "@/modules/connectors/funnel-connector-listener"
-import { logger } from "@/modules/logger"
+import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
 import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
 import { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-process-runner"
 import type { GhConnectorConfig } from "@/modules/connectors/gh-connector-schema"
@@ -18,9 +19,12 @@ type GhNotification = {
 type Deps = {
   config: GhConnectorConfig
   process?: FunnelProcessRunner
+  logger?: FunnelLogger
+  now?: () => Date
 }
 
 const defaultProcess = new NodeFunnelProcessRunner()
+const defaultLogger = new NodeFunnelLogger()
 
 const MAX_SEEN = 10000
 const KEEP_SEEN = 5000
@@ -28,14 +32,19 @@ const KEEP_SEEN = 5000
 export class FunnelGhListener extends FunnelConnectorListener {
   private readonly config: GhConnectorConfig
   private readonly process: FunnelProcessRunner
+  private readonly logger: FunnelLogger
+  private readonly now: () => Date
   private readonly seen = new Map<string, string>()
   private bootstrapped = false
-  private since = new Date().toISOString()
+  private since: string
 
   constructor(deps: Deps) {
     super()
     this.config = deps.config
     this.process = deps.process ?? defaultProcess
+    this.logger = deps.logger ?? defaultLogger
+    this.now = deps.now ?? (() => new Date())
+    this.since = this.now().toISOString()
   }
 
   async start(notify: NotifyFn): Promise<void> {
@@ -47,14 +56,14 @@ export class FunnelGhListener extends FunnelConnectorListener {
   }
 
   async pollOnce(notify: NotifyFn): Promise<void> {
-    const nextSince = new Date().toISOString()
+    const nextSince = this.now().toISOString()
     const params = new URLSearchParams({ since: this.since, all: "false" })
 
     try {
       const result = await this.process.run(["gh", "api", `/notifications?${params}`])
 
       if (result.exitCode !== 0) {
-        logger.error("gh poll failed", { stderr: result.stderr })
+        this.logger.error("gh poll failed", { stderr: result.stderr })
         return
       }
 
@@ -94,7 +103,7 @@ export class FunnelGhListener extends FunnelConnectorListener {
       this.since = nextSince
       this.bootstrapped = true
     } catch (error) {
-      logger.error("gh poll error", {
+      this.logger.error("gh poll error", {
         error: error instanceof Error ? error.message : String(error),
       })
     }

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

@@ -12,10 +12,16 @@ import {
   ghConnectorSchema,
 } from "@/modules/connectors/gh-connector-schema"
 import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+import type { FunnelLogger } from "@/modules/logger/funnel-logger"
+import type { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
+import type { FunnelClock } from "@/modules/time/funnel-clock"
 
 type Deps = {
   fs?: FunnelFileSystem
   dir?: string
+  process?: FunnelProcessRunner
+  logger?: FunnelLogger
+  clock?: FunnelClock
 }
 
 export type GhUpdateFields = {
@@ -25,6 +31,9 @@ export type GhUpdateFields = {
 export class FunnelGhStore extends FunnelCallableConnectorStore<GhConnectorConfig> {
   readonly type = "gh" as const
   private readonly store: FunnelJsonConnectorStore<GhConnectorConfig>
+  private readonly process?: FunnelProcessRunner
+  private readonly logger?: FunnelLogger
+  private readonly clock?: FunnelClock
 
   constructor(deps: Deps = {}) {
     super()
@@ -34,6 +43,9 @@ export class FunnelGhStore extends FunnelCallableConnectorStore<GhConnectorConfi
       fs: deps.fs,
       dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
     })
+    this.process = deps.process
+    this.logger = deps.logger
+    this.clock = deps.clock
     Object.freeze(this)
   }
 
@@ -75,7 +87,12 @@ export class FunnelGhStore extends FunnelCallableConnectorStore<GhConnectorConfi
   }
 
   createListener(config: GhConnectorConfig): FunnelConnectorListener {
-    return new FunnelGhListener({ config })
+    return new FunnelGhListener({
+      config,
+      process: this.process,
+      logger: this.logger,
+      now: this.clock ? () => this.clock!.now() : undefined,
+    })
   }
 
   createAdapter(_config: GhConnectorConfig): FunnelConnectorAdapter {

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

@@ -5,22 +5,27 @@ import {
 import { FunnelScheduleStore } from "@/modules/connectors/funnel-schedule-store"
 import { matchCron } from "@/modules/connectors/match-cron"
 import { ScheduleLastFiredStore } from "@/modules/connectors/schedule-last-fired-store"
-import { logger } from "@/modules/logger"
+import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
 import type { ScheduleConnectorConfig } from "@/modules/connectors/schedule-connector-schema"
 
 type Deps = {
   config: ScheduleConnectorConfig
   store: FunnelScheduleStore
   lastFiredStore: ScheduleLastFiredStore
+  logger?: FunnelLogger
   now?: () => Date
 }
 
+const defaultLogger = new NodeFunnelLogger()
+
 const MAX_CATCHUP_MINUTES = 60 * 24
 
 export class FunnelScheduleListener extends FunnelConnectorListener {
   private readonly config: ScheduleConnectorConfig
   private readonly store: FunnelScheduleStore
   private readonly lastFiredStore: ScheduleLastFiredStore
+  private readonly logger: FunnelLogger
   private readonly now: () => Date
 
   constructor(deps: Deps) {
@@ -28,6 +33,7 @@ export class FunnelScheduleListener extends FunnelConnectorListener {
     this.config = deps.config
     this.store = deps.store
     this.lastFiredStore = deps.lastFiredStore
+    this.logger = deps.logger ?? defaultLogger
     this.now = deps.now ?? (() => new Date())
     Object.freeze(this)
   }
@@ -103,7 +109,7 @@ export class FunnelScheduleListener extends FunnelConnectorListener {
       try {
         if (matchCron(cron, candidate)) return candidate
       } catch (error) {
-        logger.error("invalid cron expression in schedule", {
+        this.logger.error("invalid cron expression in schedule", {
           connector: this.config.name,
           id: entryId,
           cron,

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

@@ -1,7 +1,6 @@
 import { join } from "node:path"
 import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
 import { FunnelConnectorTypeStore } from "@/modules/connectors/funnel-connector-type-store"
-import { logger } from "@/modules/logger"
 import { DEFAULT_FUNNEL_DIR } from "@/modules/connectors/funnel-json-connector-store"
 import { FunnelScheduleListener } from "@/modules/connectors/funnel-schedule-listener"
 import { ScheduleLastFiredStore } from "@/modules/connectors/schedule-last-fired-store"
@@ -12,25 +11,41 @@ import {
 } from "@/modules/connectors/schedule-connector-schema"
 import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
 import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
+import { FunnelIdGenerator } from "@/modules/id/funnel-id-generator"
+import { NodeFunnelIdGenerator } from "@/modules/id/node-funnel-id-generator"
+import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
+import type { FunnelClock } from "@/modules/time/funnel-clock"
 
 type Deps = {
   fs?: FunnelFileSystem
   dir?: string
+  logger?: FunnelLogger
+  idGenerator?: FunnelIdGenerator
+  clock?: FunnelClock
 }
 
 const defaultFs = new NodeFunnelFileSystem()
+const defaultLogger = new NodeFunnelLogger()
+const defaultIdGenerator = new NodeFunnelIdGenerator()
 
 export class FunnelScheduleStore extends FunnelConnectorTypeStore<ScheduleConnectorConfig> {
   readonly type = "schedule" as const
   private readonly fs: FunnelFileSystem
   private readonly baseDir: string
   private readonly dir: string
+  private readonly logger: FunnelLogger
+  private readonly idGenerator: FunnelIdGenerator
+  private readonly clock?: FunnelClock
 
   constructor(deps: Deps = {}) {
     super()
     this.fs = deps.fs ?? defaultFs
     this.baseDir = deps.dir ?? DEFAULT_FUNNEL_DIR
     this.dir = join(this.baseDir, "connectors", "schedule")
+    this.logger = deps.logger ?? defaultLogger
+    this.idGenerator = deps.idGenerator ?? defaultIdGenerator
+    this.clock = deps.clock
     Object.freeze(this)
   }
 
@@ -96,7 +111,7 @@ export class FunnelScheduleStore extends FunnelConnectorTypeStore<ScheduleConnec
     if (!this.has(name)) throw new Error(`connector "${name}" not found`)
 
     const full: ScheduleEntry = {
-      id: entry.id ?? crypto.randomUUID(),
+      id: entry.id ?? this.idGenerator.generate(),
       cron: entry.cron,
       prompt: entry.prompt,
       enabled: entry.enabled ?? true,
@@ -122,6 +137,8 @@ export class FunnelScheduleStore extends FunnelConnectorTypeStore<ScheduleConnec
       config,
       store: this,
       lastFiredStore: this.createLastFiredStore(config.name),
+      logger: this.logger,
+      now: this.clock ? () => this.clock!.now() : undefined,
     })
   }
 
@@ -155,7 +172,7 @@ export class FunnelScheduleStore extends FunnelConnectorTypeStore<ScheduleConnec
         const result = scheduleEntrySchema.safeParse(parsed)
 
         if (!result.success) {
-          logger.warn("skipping invalid schedule entry", {
+          this.logger.warn("skipping invalid schedule entry", {
             connector: name,
             line: lineNumber,
             issues: result.error.issues.map((iss) => `${iss.path.join(".")}: ${iss.message}`),
@@ -165,7 +182,7 @@ export class FunnelScheduleStore extends FunnelConnectorTypeStore<ScheduleConnec
 
         entries.push(result.data)
       } catch (error) {
-        logger.warn("skipping unparseable schedule entry", {
+        this.logger.warn("skipping unparseable schedule entry", {
           connector: name,
           line: lineNumber,
           error: error instanceof Error ? error.message : String(error),

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

@@ -4,19 +4,25 @@ import {
   type NotifyFn,
 } from "@/modules/connectors/funnel-connector-listener"
 import { FunnelSlackEventProcessor } from "@/modules/connectors/funnel-slack-event-processor"
-import { logger } from "@/modules/logger"
+import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
 import type { SlackConnectorConfig } from "@/modules/connectors/slack-connector-schema"
 
 type Deps = {
   config: SlackConnectorConfig
+  logger?: FunnelLogger
 }
 
+const defaultLogger = new NodeFunnelLogger()
+
 export class FunnelSlackListener extends FunnelConnectorListener {
   private readonly config: SlackConnectorConfig
+  private readonly logger: FunnelLogger
 
   constructor(deps: Deps) {
     super()
     this.config = deps.config
+    this.logger = deps.logger ?? defaultLogger
     Object.freeze(this)
   }
 
@@ -62,7 +68,7 @@ export class FunnelSlackListener extends FunnelConnectorListener {
     })
 
     app.error(async (error) => {
-      logger.error("Slack error", {
+      this.logger.error("Slack error", {
         error: error instanceof Error ? error.message : String(error),
       })
     })

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

@@ -12,10 +12,12 @@ import {
   slackConnectorSchema,
 } from "@/modules/connectors/slack-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 SlackUpdateFields = {
@@ -26,6 +28,7 @@ export type SlackUpdateFields = {
 export class FunnelSlackStore extends FunnelCallableConnectorStore<SlackConnectorConfig> {
   readonly type = "slack" as const
   private readonly store: FunnelJsonConnectorStore<SlackConnectorConfig>
+  private readonly logger?: FunnelLogger
 
   constructor(deps: Deps = {}) {
     super()
@@ -35,6 +38,7 @@ export class FunnelSlackStore extends FunnelCallableConnectorStore<SlackConnecto
       fs: deps.fs,
       dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
     })
+    this.logger = deps.logger
     Object.freeze(this)
   }
 
@@ -77,7 +81,7 @@ export class FunnelSlackStore extends FunnelCallableConnectorStore<SlackConnecto
   }
 
   createListener(config: SlackConnectorConfig): FunnelConnectorListener {
-    return new FunnelSlackListener({ config })
+    return new FunnelSlackListener({ config, logger: this.logger })
   }
 
   createAdapter(config: SlackConnectorConfig): FunnelConnectorAdapter {

package/lib/modules/connectors/migrate-legacy-connectors.ts

@@ -4,20 +4,24 @@ import type { ConnectorStoresBundle } from "@/modules/connectors/funnel-connecto
 import { DEFAULT_FUNNEL_DIR } from "@/modules/connectors/funnel-json-connector-store"
 import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
 import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
-import { logger } from "@/modules/logger"
+import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
 
 type Props = {
   stores: ConnectorStoresBundle
   fs?: FunnelFileSystem
   dir?: string
+  logger?: FunnelLogger
 }
 
 const defaultFs = new NodeFunnelFileSystem()
+const defaultLogger = new NodeFunnelLogger()
 
 export const migrateLegacyConnectors = (props: Props): number => {
   const fs = props.fs ?? defaultFs
   const base = props.dir ?? DEFAULT_FUNNEL_DIR
   const path = join(base, "settings.json")
+  const logger = props.logger ?? defaultLogger
 
   if (!fs.existsSync(path)) return 0
 

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

@@ -2,6 +2,11 @@ export type FileStat = {
   mtimeMs: number
 }
 
+/**
+ * Filesystem boundary used everywhere funnel reads or writes.
+ * Default is NodeFunnelFileSystem (real `node:fs`); MemoryFunnelFileSystem
+ * provides a sandbox for tests and embedded use.
+ */
 export abstract class FunnelFileSystem {
   abstract existsSync(path: string): boolean
   abstract readFileSync(path: string): string

package/lib/modules/gateway/daemon.ts

@@ -1,16 +1,12 @@
 #!/usr/bin/env bun
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
-import type { ServerWebSocket } from "bun"
-import { Hono } from "hono"
-import { logger } from "@/modules/logger"
 import { FunnelChannels } from "@/modules/channels/funnel-channels"
 import { FunnelConnectors } from "@/modules/connectors/funnel-connectors"
 import { createConnectorStores } from "@/modules/connectors/funnel-connector-stores"
 import { migrateLegacyConnectors } from "@/modules/connectors/migrate-legacy-connectors"
-import { FunnelBroadcaster } from "@/modules/gateway/funnel-broadcaster"
-import { FunnelEventLogger } from "@/modules/gateway/funnel-event-logger"
-import { killCompetingSlackGateways } from "@/modules/gateway/kill-competing-slack-gateways"
+import { FunnelGatewayServer } from "@/modules/gateway/funnel-gateway-server"
+import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
 import { FunnelProfiles } from "@/modules/profiles/funnel-profiles"
 import { FUNNEL_DIR, FunnelSettingsStore } from "@/modules/settings/funnel-settings-store"
 
@@ -18,6 +14,8 @@ const PORT = Number(process.env.FUNNEL_PORT) || 9742
 const PID_FILE = join(FUNNEL_DIR, "gateway.pid")
 const LOG_DIR = "/tmp/funnel/events"
 
+const logger = new NodeFunnelLogger()
+
 mkdirSync(FUNNEL_DIR, { recursive: true })
 
 if (existsSync(PID_FILE)) {
@@ -65,143 +63,12 @@ const connectors: FunnelConnectors = new FunnelConnectors({
   refUpdater: channels,
 })
 
-const eventLogger = new FunnelEventLogger({ logDir: LOG_DIR })
-const broadcaster = new FunnelBroadcaster()
-const app = new Hono()
-
-app.get("/health", (c) =>
-  c.json({
-    ok: true,
-    pid: process.pid,
-    clients: broadcaster.getClientCount(),
-  }),
-)
-
-app.get("/status", (c) =>
-  c.json({
-    ok: true,
-    clients: broadcaster.listChannels(),
-  }),
-)
-
-const resolveConnectors = (channelName: string): string[] => {
-  const settings = store.read()
-  const channel = settings?.channels.find((c) => c.name === channelName)
-
-  return channel?.connectors ?? []
-}
-
-type WsData = { channel: string; connectors: string[] }
-
-Bun.serve<WsData>({
+const server = new FunnelGatewayServer({
+  connectors,
+  settings: store,
   port: PORT,
-  fetch(request, server) {
-    const url = new URL(request.url)
-
-    if (url.pathname === "/ws" && request.headers.get("upgrade") === "websocket") {
-      const channelName = url.searchParams.get("channel") ?? ""
-      const connectors = channelName ? resolveConnectors(channelName) : []
-      const data: WsData = { channel: channelName, connectors }
-
-      const upgraded = server.upgrade(request, { data })
-
-      if (upgraded) return undefined
-
-      return new Response("WebSocket upgrade failed", { status: 400 })
-    }
-
-    return app.fetch(request)
-  },
-  websocket: {
-    open(ws: ServerWebSocket<WsData>) {
-      const data = ws.data
-
-      broadcaster.addClient(ws, data)
-
-      eventLogger.log("channel connected", {
-        event_type: "system",
-        action: "channel_connect",
-        channel: data.channel,
-        connectors: data.connectors.join(","),
-        total: String(broadcaster.getClientCount()),
-      })
-    },
-    close(ws: ServerWebSocket<WsData>) {
-      broadcaster.removeClient(ws)
-
-      eventLogger.log("channel disconnected", {
-        event_type: "system",
-        action: "channel_disconnect",
-        total: String(broadcaster.getClientCount()),
-      })
-    },
-    message(_ws: ServerWebSocket<WsData>, _message: string | Buffer) {
-      // Future: channel → gateway messages
-    },
-  },
+  logDir: LOG_DIR,
+  logger,
 })
 
-eventLogger.log("gateway started", {
-  event_type: "system",
-  action: "gateway_start",
-  port: String(PORT),
-  pid: String(process.pid),
-})
-
-logger.info(`funnel gateway listening`, {
-  url: `http://localhost:${PORT}`,
-  websocket: `ws://localhost:${PORT}/ws`,
-  health: `http://localhost:${PORT}/health`,
-})
-
-const notify = async (
-  connectorName: string,
-  content: string,
-  meta?: Record<string, string>,
-): Promise<void> => {
-  const withConnector: Record<string, string> = { ...meta, connector: connectorName }
-
-  eventLogger.log(content, withConnector)
-  broadcaster.broadcast(content, withConnector)
-}
-
-const allConnectors = connectors.list()
-
-// Multiple Slack Socket Mode connections sharing one App Token steal DMs/mentions
-// from each other. Terminate other bun + gateway/bolt/slack processes first.
-if (allConnectors.some((c) => c.type === "slack")) {
-  const killed = await killCompetingSlackGateways({ selfPid: process.pid })
-
-  if (killed.length > 0) {
-    eventLogger.log("killed competing Slack gateway processes", {
-      event_type: "system",
-      action: "kill_competing",
-      pids: killed.join(","),
-    })
-  }
-}
-
-for (const { config, listener } of connectors.createListeners()) {
-  const bind = (content: string, meta?: Record<string, string>) =>
-    notify(config.name, content, meta)
-
-  try {
-    await listener.start(bind)
-
-    eventLogger.log(`${config.type} listener started: ${config.name}`, {
-      event_type: "system",
-      action: `${config.type}_connect`,
-      connector: config.name,
-    })
-
-    logger.info(`${config.type} listener started`, { connector: config.name })
-  } catch (error) {
-    logger.error(`${config.type} listener failed`, {
-      connector: config.name,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
-logger.info(`event logs: ${LOG_DIR}`)
-logger.info("funnel gateway running")
+await server.start()