@interactive-inc/claude-funnel 0.4.1 → 0.8.0

package/lib/{modules/gateway/funnel-gateway.ts → gateway/gateway.ts}

@@ -1,31 +1,65 @@
-import { join, resolve } from "node:path"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
-import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
-import { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-process-runner"
-import { FUNNEL_DIR } from "@/modules/settings/funnel-settings-store"
+import { join } from "node:path"
+import { FunnelFileSystem } from "@/engine/fs/file-system"
+import { resolveDaemonScript } from "@/gateway/resolve-daemon-script"
+import { NodeFunnelFileSystem } from "@/engine/fs/node-file-system"
+import { FunnelProcessRunner } from "@/engine/process/process-runner"
+import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
+import { FUNNEL_DIR } from "@/engine/settings/settings-store"
+import { FunnelClock } from "@/engine/time/clock"
+import { NodeFunnelClock } from "@/engine/time/node-clock"
 
 const DEFAULT_PORT = 9742
-const PID_FILE = join(FUNNEL_DIR, "gateway.pid")
-const LOG_DIR = "/tmp/funnel/events"
-const GATEWAY_LOG = "/tmp/funnel/gateway.log"
-const TMP_DIR = "/tmp/funnel"
+const DEFAULT_TMP_DIR = "/tmp/funnel"
+const STARTUP_TIMEOUT_MS = 5000
+const SIGTERM_TIMEOUT_MS = 2000
+const POLL_INTERVAL_MS = 100
+const SIGKILL_GRACE_MS = 200
 
 type Deps = {
   process?: FunnelProcessRunner
   fs?: FunnelFileSystem
+  clock?: FunnelClock
+  dir?: string
+  tmpDir?: string
+  port?: number
+  sleep?: (ms: number) => Promise<void>
 }
 
 const defaultProcess = new NodeFunnelProcessRunner()
 const defaultFs = new NodeFunnelFileSystem()
-
+const defaultClock = new NodeFunnelClock()
+const defaultSleep = (ms: number): Promise<void> =>
+  new Promise((r) => {
+    setTimeout(r, ms)
+  })
+
+/**
+ * Manages the gateway daemon as a separate process via PID file.
+ * Use `start()` to spawn `bun daemon.ts` in the background and `stop()` to
+ * terminate it. For an in-process gateway, use `Funnel.gatewayServer` instead.
+ */
 export class FunnelGateway {
   private readonly process: FunnelProcessRunner
   private readonly fs: FunnelFileSystem
+  private readonly clock: FunnelClock
+  private readonly pidFile: string
+  private readonly logDir: string
+  private readonly gatewayLog: string
+  private readonly tmpDir: string
+  private readonly port: number
+  private readonly sleep: (ms: number) => Promise<void>
 
   constructor(deps: Deps = {}) {
     this.process = deps.process ?? defaultProcess
     this.fs = deps.fs ?? defaultFs
+    this.clock = deps.clock ?? defaultClock
+    const baseDir = deps.dir ?? FUNNEL_DIR
+    this.tmpDir = deps.tmpDir ?? DEFAULT_TMP_DIR
+    this.pidFile = join(baseDir, "gateway.pid")
+    this.logDir = join(this.tmpDir, "events")
+    this.gatewayLog = join(this.tmpDir, "gateway.log")
+    this.port = deps.port ?? DEFAULT_PORT
+    this.sleep = deps.sleep ?? defaultSleep
     Object.freeze(this)
   }
 
@@ -41,20 +75,25 @@ export class FunnelGateway {
     const pid = this.readPid()
     const running = pid !== null && this.isProcessAlive(pid)
 
-    return { running, pid: running ? pid : null, port: DEFAULT_PORT }
+    return { running, pid: running ? pid : null, port: this.port }
   }
 
   async start(options: { caffeinate?: boolean } = {}): Promise<boolean> {
     if (this.isRunning()) return true
 
-    this.fs.mkdirSync(TMP_DIR, { recursive: true })
+    this.fs.mkdirSync(this.tmpDir, { recursive: true })
 
-    const gatewayScript = resolve(import.meta.dir, "./daemon.ts")
+    const gatewayScript = resolveDaemonScript()
     const command = this.buildStartCommand(gatewayScript, options)
 
     this.process.detach(["bash", "-c", command])
 
-    await Bun.sleep(800)
+    const deadline = Date.now() + STARTUP_TIMEOUT_MS
+
+    while (Date.now() < deadline) {
+      if (this.isRunning()) return true
+      await this.sleep(POLL_INTERVAL_MS)
+    }
 
     return this.isRunning()
   }
@@ -63,7 +102,7 @@ export class FunnelGateway {
     const useCaffeinate = options.caffeinate !== false && globalThis.process.platform === "darwin"
     const prefix = useCaffeinate ? "caffeinate -i " : ""
 
-    return `nohup ${prefix}bun ${gatewayScript} >> ${GATEWAY_LOG} 2>&1 &`
+    return `nohup ${prefix}bun ${gatewayScript} >> ${this.gatewayLog} 2>&1 &`
   }
 
   async stop(): Promise<boolean> {
@@ -77,29 +116,29 @@ export class FunnelGateway {
     }
 
     try {
-      globalThis.process.kill(pid, "SIGTERM")
+      this.process.kill(pid, "SIGTERM")
     } catch {
       return false
     }
 
-    const deadline = Date.now() + 2000
+    const deadline = this.clock.millis() + SIGTERM_TIMEOUT_MS
 
-    while (Date.now() < deadline) {
+    while (this.clock.millis() < deadline) {
       if (!this.isProcessAlive(pid)) {
         this.removePid()
         return true
       }
 
-      await Bun.sleep(100)
+      await this.sleep(POLL_INTERVAL_MS)
     }
 
     try {
-      globalThis.process.kill(pid, "SIGKILL")
+      this.process.kill(pid, "SIGKILL")
     } catch {
       // ignore
     }
 
-    await Bun.sleep(200)
+    await this.sleep(SIGKILL_GRACE_MS)
     this.removePid()
 
     return !this.isProcessAlive(pid)
@@ -126,18 +165,22 @@ export class FunnelGateway {
   }
 
   getLogDir(): string {
-    return LOG_DIR
+    return this.logDir
   }
 
   getGatewayLog(): string {
-    return GATEWAY_LOG
+    return this.gatewayLog
+  }
+
+  getPort(): number {
+    return this.port
   }
 
   private readPid(): number | null {
-    if (!this.fs.existsSync(PID_FILE)) return null
+    if (!this.fs.existsSync(this.pidFile)) return null
 
     try {
-      const content = this.fs.readFileSync(PID_FILE).trim()
+      const content = this.fs.readFileSync(this.pidFile).trim()
       const pid = Number(content)
 
       if (!pid || pid <= 0) return null
@@ -149,7 +192,7 @@ export class FunnelGateway {
   }
 
   private removePid(): void {
-    this.fs.unlink(PID_FILE)
+    this.fs.unlink(this.pidFile)
   }
 
   private isProcessAlive(pid: number): boolean {

package/lib/{modules/gateway → gateway}/kill-competing-slack-gateways.ts

@@ -1,13 +1,16 @@
-import { logger } from "@/modules/logger"
-import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
-import { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-process-runner"
+import { FunnelLogger } from "@/engine/logger/logger"
+import { NodeFunnelLogger } from "@/engine/logger/node-logger"
+import { FunnelProcessRunner } from "@/engine/process/process-runner"
+import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
 
 type Props = {
   selfPid: number
   process?: FunnelProcessRunner
+  logger?: FunnelLogger
 }
 
 const defaultProcess = new NodeFunnelProcessRunner()
+const defaultLogger = new NodeFunnelLogger()
 
 const isBun = (args: string): boolean => {
   return args.includes("bun ") || /\/bun(\s|$)/.test(args)
@@ -19,6 +22,7 @@ const looksLikeSlackGateway = (args: string): boolean => {
 
 export const killCompetingSlackGateways = async (props: Props): Promise<number[]> => {
   const runner = props.process ?? defaultProcess
+  const logger = props.logger ?? defaultLogger
   const result = await runner.run(["ps", "-e", "-o", "pid=,args="])
 
   if (result.exitCode !== 0) return []

package/lib/gateway/listener-supervisor.ts

@@ -0,0 +1,339 @@
+import type { ConnectorConfig } from "@/connectors/connector-config-schema"
+import type { FunnelConnectorListener } from "@/connectors/connector-listener"
+import type { ChannelConnectorView } from "@/engine/channels/channels"
+import { FunnelLogger } from "@/engine/logger/logger"
+import { NodeFunnelLogger } from "@/engine/logger/node-logger"
+
+type ConnectorRegistry = {
+  listAllConnectors(): ChannelConnectorView[]
+  createListener(
+    channelName: string,
+    connectorName: string,
+  ): { config: ConnectorConfig; channelId: string; listener: FunnelConnectorListener } | null
+}
+
+type SupervisorNotify = (
+  channelName: string,
+  connectorName: string,
+  content: string,
+  meta?: Record<string, string>,
+) => Promise<void>
+
+type RunningEntry = {
+  config: ConnectorConfig
+  channelName: string
+  channelId: string
+  listener: FunnelConnectorListener
+}
+
+type ListenerStats = {
+  events: number
+  errors: number
+  failureCount: number
+  lastEventAt: string | null
+}
+
+type Deps = {
+  channels: ConnectorRegistry
+  notify: SupervisorNotify
+  logger?: FunnelLogger
+  healthCheckIntervalMs?: number
+  maxBackoffMs?: number
+  sleep?: (ms: number) => Promise<void>
+  now?: () => number
+}
+
+const defaultLogger = new NodeFunnelLogger()
+const DEFAULT_HEALTH_INTERVAL_MS = 30_000
+const DEFAULT_MAX_BACKOFF_MS = 60_000
+
+const defaultSleep = (ms: number): Promise<void> =>
+  new Promise((r) => {
+    setTimeout(r, ms)
+  })
+
+type ListenerEntryStatus = {
+  channelName: string
+  channelId: string
+  name: string
+  type: ConnectorConfig["type"]
+  alive: boolean
+  events: number
+  errors: number
+  failureCount: number
+  lastEventAt: string | null
+}
+
+/**
+ * Owns the running listener instances and their lifecycle.
+ *
+ * Lives in the gateway process and is the only place that calls
+ * `listener.start()` / `listener.stop()`. Each entry is keyed by
+ * `${channelName}/${connectorName}` so the same connector name can exist in
+ * multiple channels without colliding.
+ *
+ * Periodically polls each running listener's `isAlive()` and auto-restarts
+ * dead listeners with exponential backoff (1s, 2s, 4s, ... capped). Resets
+ * the backoff counter on successful restart.
+ */
+export class FunnelListenerSupervisor {
+  private readonly channels: ConnectorRegistry
+  private readonly notify: SupervisorNotify
+  private readonly logger: FunnelLogger
+  private readonly running = new Map<string, RunningEntry>()
+  private readonly failureCounts = new Map<string, number>()
+  private readonly stats = new Map<string, ListenerStats>()
+  private readonly healthCheckIntervalMs: number
+  private readonly maxBackoffMs: number
+  private readonly sleep: (ms: number) => Promise<void>
+  private readonly now: () => number
+  private healthCheckTimer: ReturnType<typeof setInterval> | null = null
+  private healthCheckInFlight = false
+
+  constructor(deps: Deps) {
+    this.channels = deps.channels
+    this.notify = deps.notify
+    this.logger = deps.logger ?? defaultLogger
+    this.healthCheckIntervalMs = deps.healthCheckIntervalMs ?? DEFAULT_HEALTH_INTERVAL_MS
+    this.maxBackoffMs = deps.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS
+    this.sleep = deps.sleep ?? defaultSleep
+    this.now = deps.now ?? (() => Date.now())
+  }
+
+  static keyOf(channelName: string, connectorName: string): string {
+    return `${channelName}/${connectorName}`
+  }
+
+  isRunning(channelName: string, connectorName: string): boolean {
+    return this.running.has(FunnelListenerSupervisor.keyOf(channelName, connectorName))
+  }
+
+  list(): ListenerEntryStatus[] {
+    return [...this.running.entries()].map(([key, entry]) => {
+      const stats = this.stats.get(key)
+
+      return {
+        channelName: entry.channelName,
+        channelId: entry.channelId,
+        name: entry.config.name,
+        type: entry.config.type,
+        alive: entry.listener.isAlive(),
+        events: stats?.events ?? 0,
+        errors: stats?.errors ?? 0,
+        failureCount: this.failureCounts.get(key) ?? 0,
+        lastEventAt: stats?.lastEventAt ?? null,
+      }
+    })
+  }
+
+  async start(
+    channelName: string,
+    connectorName: string,
+  ): Promise<{ ok: boolean; reason?: string }> {
+    const key = FunnelListenerSupervisor.keyOf(channelName, connectorName)
+
+    if (this.running.has(key)) {
+      return { ok: true, reason: "already running" }
+    }
+
+    const created = this.channels.createListener(channelName, connectorName)
+
+    if (!created) {
+      return {
+        ok: false,
+        reason: `connector "${connectorName}" not found in channel "${channelName}"`,
+      }
+    }
+
+    const bind = async (content: string, meta?: Record<string, string>) => {
+      try {
+        await this.notify(channelName, connectorName, content, meta)
+        this.recordEvent(key)
+      } catch (error) {
+        this.recordError(key)
+        throw error
+      }
+    }
+
+    try {
+      await created.listener.start(bind)
+      this.running.set(key, {
+        config: created.config,
+        channelName,
+        channelId: created.channelId,
+        listener: created.listener,
+      })
+      this.ensureStats(key)
+      this.logger.info(`${created.config.type} listener started`, {
+        channel: channelName,
+        connector: connectorName,
+      })
+
+      return { ok: true }
+    } catch (error) {
+      this.logger.error(`${created.config.type} listener failed to start`, {
+        channel: channelName,
+        connector: connectorName,
+        error: error instanceof Error ? error.message : String(error),
+      })
+
+      return {
+        ok: false,
+        reason: error instanceof Error ? error.message : String(error),
+      }
+    }
+  }
+
+  async stop(
+    channelName: string,
+    connectorName: string,
+  ): Promise<{ ok: boolean; reason?: string }> {
+    const key = FunnelListenerSupervisor.keyOf(channelName, connectorName)
+    const entry = this.running.get(key)
+
+    if (!entry) return { ok: true, reason: "not running" }
+
+    try {
+      await entry.listener.stop()
+      this.running.delete(key)
+      this.failureCounts.delete(key)
+      this.logger.info(`${entry.config.type} listener stopped`, {
+        channel: channelName,
+        connector: connectorName,
+      })
+
+      return { ok: true }
+    } catch (error) {
+      this.logger.error(`${entry.config.type} listener failed to stop`, {
+        channel: channelName,
+        connector: connectorName,
+        error: error instanceof Error ? error.message : String(error),
+      })
+
+      return {
+        ok: false,
+        reason: error instanceof Error ? error.message : String(error),
+      }
+    }
+  }
+
+  async restart(
+    channelName: string,
+    connectorName: string,
+  ): Promise<{ ok: boolean; reason?: string }> {
+    const stopped = await this.stop(channelName, connectorName)
+
+    if (!stopped.ok) return stopped
+
+    return await this.start(channelName, connectorName)
+  }
+
+  async startAll(): Promise<void> {
+    const all = this.channels.listAllConnectors()
+
+    for (const view of all) {
+      await this.start(view.channelName, view.name)
+    }
+
+    this.startHealthCheck()
+  }
+
+  async stopAll(): Promise<void> {
+    this.stopHealthCheck()
+
+    for (const [, entry] of [...this.running.entries()]) {
+      await this.stop(entry.channelName, entry.config.name)
+    }
+  }
+
+  private ensureStats(key: string): ListenerStats {
+    const existing = this.stats.get(key)
+
+    if (existing) return existing
+
+    const fresh: ListenerStats = { events: 0, errors: 0, failureCount: 0, lastEventAt: null }
+
+    this.stats.set(key, fresh)
+
+    return fresh
+  }
+
+  private recordEvent(key: string): void {
+    const stats = this.ensureStats(key)
+
+    stats.events += 1
+    stats.lastEventAt = new Date(this.now()).toISOString()
+  }
+
+  private recordError(key: string): void {
+    this.ensureStats(key).errors += 1
+  }
+
+  private startHealthCheck(): void {
+    if (this.healthCheckTimer) return
+
+    this.healthCheckTimer = setInterval(() => {
+      void this.runHealthCheck()
+    }, this.healthCheckIntervalMs)
+
+    this.healthCheckTimer.unref()
+  }
+
+  private stopHealthCheck(): void {
+    if (!this.healthCheckTimer) return
+
+    clearInterval(this.healthCheckTimer)
+    this.healthCheckTimer = null
+  }
+
+  private async runHealthCheck(): Promise<void> {
+    if (this.healthCheckInFlight) return
+
+    this.healthCheckInFlight = true
+
+    try {
+      for (const [key, entry] of [...this.running.entries()]) {
+        if (entry.listener.isAlive()) {
+          this.failureCounts.delete(key)
+          continue
+        }
+
+        await this.recoverDead(entry.channelName, entry.config.name, entry.config.type)
+      }
+    } finally {
+      this.healthCheckInFlight = false
+    }
+  }
+
+  private async recoverDead(
+    channelName: string,
+    connectorName: string,
+    type: ConnectorConfig["type"],
+  ): Promise<void> {
+    const key = FunnelListenerSupervisor.keyOf(channelName, connectorName)
+    const failureCount = this.failureCounts.get(key) ?? 0
+    const backoffMs = Math.min(1000 * 2 ** failureCount, this.maxBackoffMs)
+
+    this.logger.warn(`${type} listener unhealthy, restarting`, {
+      channel: channelName,
+      connector: connectorName,
+      attempt: failureCount + 1,
+      backoffMs,
+    })
+
+    await this.stop(channelName, connectorName)
+    await this.sleep(backoffMs)
+
+    const result = await this.start(channelName, connectorName)
+
+    if (result.ok) {
+      this.failureCounts.delete(key)
+      this.logger.info(`${type} listener recovered`, {
+        channel: channelName,
+        connector: connectorName,
+      })
+    } else {
+      this.failureCounts.set(key, failureCount + 1)
+    }
+  }
+}

package/lib/gateway/listeners-client.ts

@@ -0,0 +1,128 @@
+import { z } from "zod"
+
+type Deps = {
+  port: number
+  isDaemonRunning: () => boolean
+  /** Returns the daemon's gateway token, or null if unavailable. Sent as `Authorization: Bearer`. */
+  getToken?: () => string | null
+}
+
+const listenerEntrySchema = z.object({
+  channelName: z.string(),
+  channelId: z.string(),
+  name: z.string(),
+  type: z.string(),
+  alive: z.boolean(),
+})
+
+const listenersResponseSchema = z.object({
+  listeners: z.array(listenerEntrySchema),
+})
+
+const opErrorBodySchema = z.object({
+  reason: z.string().optional(),
+})
+
+export type ListenerEntry = z.infer<typeof listenerEntrySchema>
+
+export type ListenerOpResult =
+  | { state: "ok" }
+  | { state: "offline" }
+  | { state: "error"; reason: string }
+
+export type ListListenersResult =
+  | { state: "ok"; listeners: ListenerEntry[] }
+  | { state: "offline" }
+  | { state: "error"; reason: string }
+
+const OFFLINE: ListenerOpResult = { state: "offline" }
+
+/**
+ * HTTP client for listener operations on a running gateway daemon.
+ *
+ * Returns `{ state: "offline" }` when the daemon isn't running so callers
+ * (CLI hot-reload paths) can treat that as a no-op without parsing strings.
+ * Pair this with `FunnelGateway` (process control) for the full picture.
+ */
+export class FunnelListenersClient {
+  private readonly port: number
+  private readonly isDaemonRunning: () => boolean
+  private readonly getToken: () => string | null
+
+  constructor(deps: Deps) {
+    this.port = deps.port
+    this.isDaemonRunning = deps.isDaemonRunning
+    this.getToken = deps.getToken ?? (() => null)
+    Object.freeze(this)
+  }
+
+  async list(): Promise<ListListenersResult> {
+    if (!this.isDaemonRunning()) return { state: "offline" }
+
+    try {
+      const res = await fetch(`http://localhost:${this.port}/listeners`, {
+        headers: this.authHeaders(),
+      })
+
+      if (!res.ok) return { state: "error", reason: `HTTP ${res.status}` }
+
+      const parsed = listenersResponseSchema.safeParse(await res.json())
+
+      if (!parsed.success) {
+        return { state: "error", reason: "malformed daemon response" }
+      }
+
+      return { state: "ok", listeners: parsed.data.listeners }
+    } catch (error) {
+      return { state: "error", reason: error instanceof Error ? error.message : String(error) }
+    }
+  }
+
+  async start(channelName: string, connectorName: string): Promise<ListenerOpResult> {
+    if (!this.isDaemonRunning()) return OFFLINE
+
+    return await this.call("POST", `/listeners/${this.path(channelName, connectorName)}/start`)
+  }
+
+  async stop(channelName: string, connectorName: string): Promise<ListenerOpResult> {
+    if (!this.isDaemonRunning()) return OFFLINE
+
+    return await this.call("DELETE", `/listeners/${this.path(channelName, connectorName)}`)
+  }
+
+  async restart(channelName: string, connectorName: string): Promise<ListenerOpResult> {
+    if (!this.isDaemonRunning()) return OFFLINE
+
+    return await this.call("POST", `/listeners/${this.path(channelName, connectorName)}/restart`)
+  }
+
+  private path(channelName: string, connectorName: string): string {
+    return `${encodeURIComponent(channelName)}/${encodeURIComponent(connectorName)}`
+  }
+
+  private authHeaders(): Record<string, string> {
+    const token = this.getToken()
+
+    return token ? { authorization: `Bearer ${token}` } : {}
+  }
+
+  private async call(method: "POST" | "DELETE", path: string): Promise<ListenerOpResult> {
+    try {
+      const res = await fetch(`http://localhost:${this.port}${path}`, {
+        method,
+        headers: this.authHeaders(),
+      })
+
+      if (!res.ok) {
+        const parsed = opErrorBodySchema.safeParse(await res.json().catch(() => null))
+        const reason = parsed.success ? parsed.data.reason : undefined
+
+        return { state: "error", reason: reason ?? `HTTP ${res.status}` }
+      }
+
+      return { state: "ok" }
+    } catch (error) {
+      return { state: "error", reason: error instanceof Error ? error.message : String(error) }
+    }
+  }
+}