@interactive-inc/claude-funnel 0.2.0

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

@@ -0,0 +1,85 @@
+import { type FileStat, FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+
+type Props = {
+  dirs?: string[]
+  files?: Record<string, string>
+  mtimes?: Record<string, number>
+  now?: () => number
+}
+
+export class MemoryFunnelFileSystem extends FunnelFileSystem {
+  private readonly dirs: Set<string>
+  private readonly files: Map<string, string>
+  private readonly mtimes: Map<string, number>
+  private readonly now: () => number
+
+  constructor(props: Props = {}) {
+    super()
+    this.dirs = new Set(props.dirs ?? [])
+    this.files = new Map(Object.entries(props.files ?? {}))
+    this.mtimes = new Map(Object.entries(props.mtimes ?? {}))
+    this.now = props.now ?? (() => Date.now())
+  }
+
+  existsSync(path: string): boolean {
+    return this.dirs.has(path) || this.files.has(path)
+  }
+
+  readFileSync(path: string): string {
+    return this.files.get(path) ?? ""
+  }
+
+  writeFileSync(path: string, data: string): void {
+    this.files.set(path, data)
+    this.touch(path)
+  }
+
+  appendFileSync(path: string, data: string): void {
+    const prev = this.files.get(path) ?? ""
+    this.files.set(path, prev + data)
+    this.touch(path)
+  }
+
+  unlink(path: string): void {
+    this.files.delete(path)
+    this.mtimes.delete(path)
+  }
+
+  mkdirSync(path: string): void {
+    this.dirs.add(path)
+  }
+
+  readdirSync(path: string): string[] {
+    const prefix = path.endsWith("/") ? path : `${path}/`
+    const names: string[] = []
+
+    for (const file of this.files.keys()) {
+      if (!file.startsWith(prefix)) continue
+
+      const rest = file.slice(prefix.length)
+
+      if (!rest.includes("/")) names.push(rest)
+    }
+
+    return names
+  }
+
+  statSync(path: string): FileStat {
+    const mtimeMs = this.mtimes.get(path)
+
+    if (mtimeMs === undefined) {
+      throw new Error(`not found: ${path}`)
+    }
+
+    return { mtimeMs }
+  }
+
+  setMtime(path: string, mtimeMs: number): void {
+    this.mtimes.set(path, mtimeMs)
+  }
+
+  private touch(path: string): void {
+    if (!this.mtimes.has(path)) this.mtimes.set(path, this.now())
+    else this.mtimes.set(path, this.now())
+  }
+}

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

@@ -0,0 +1,56 @@
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs"
+import { type FileStat, FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+
+export class NodeFunnelFileSystem extends FunnelFileSystem {
+  constructor() {
+    super()
+    Object.freeze(this)
+  }
+
+  existsSync(path: string): boolean {
+    return existsSync(path)
+  }
+
+  readFileSync(path: string): string {
+    return readFileSync(path, "utf-8")
+  }
+
+  writeFileSync(path: string, data: string): void {
+    writeFileSync(path, data)
+  }
+
+  appendFileSync(path: string, data: string): void {
+    appendFileSync(path, data)
+  }
+
+  unlink(path: string): void {
+    try {
+      unlinkSync(path)
+    } catch {
+      // ignore
+    }
+  }
+
+  mkdirSync(path: string, options?: { recursive?: boolean }): void {
+    mkdirSync(path, { recursive: options?.recursive ?? false })
+  }
+
+  readdirSync(path: string): string[] {
+    return readdirSync(path)
+  }
+
+  statSync(path: string): FileStat {
+    const stat = statSync(path)
+
+    return { mtimeMs: stat.mtimeMs }
+  }
+}

package/lib/modules/gateway/daemon.ts

@@ -0,0 +1,190 @@
+#!/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 { resolveListener } from "@/modules/connectors/resolve-listener"
+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 { FUNNEL_DIR, FunnelSettingsStore } from "@/modules/settings/funnel-settings-store"
+
+const PORT = Number(process.env.FUNNEL_PORT) || 9742
+const PID_FILE = join(FUNNEL_DIR, "gateway.pid")
+const LOG_DIR = "/tmp/funnel/events"
+
+mkdirSync(FUNNEL_DIR, { recursive: true })
+
+if (existsSync(PID_FILE)) {
+  const existing = Number(readFileSync(PID_FILE, "utf-8").trim())
+
+  if (existing > 0) {
+    const check = Bun.spawnSync(["ps", "-p", String(existing), "-o", "state="], {
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    if (check.exitCode === 0 && check.stdout.toString().trim()) {
+      logger.error(`funnel gateway already running`, { pid: existing })
+      process.exit(1)
+    }
+  }
+}
+
+writeFileSync(PID_FILE, String(process.pid))
+
+process.on("exit", () => {
+  try {
+    unlinkSync(PID_FILE)
+  } catch {
+    // ignore
+  }
+})
+process.on("SIGINT", () => process.exit(130))
+process.on("SIGTERM", () => process.exit(143))
+
+const store = new FunnelSettingsStore()
+
+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>({
+  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
+    },
+  },
+})
+
+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 settings = store.read()
+
+// Multiple Slack Socket Mode connections sharing one App Token steal DMs/mentions
+// from each other. Terminate other bun + gateway/bolt/slack processes first.
+if (settings.connectors.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 connector of settings.connectors) {
+  const bind = (content: string, meta?: Record<string, string>) =>
+    notify(connector.name, content, meta)
+
+  try {
+    const listener = resolveListener(connector)
+
+    await listener.start(bind)
+
+    eventLogger.log(`${connector.type} listener started: ${connector.name}`, {
+      event_type: "system",
+      action: `${connector.type}_connect`,
+      connector: connector.name,
+    })
+
+    logger.info(`${connector.type} listener started`, { connector: connector.name })
+  } catch (error) {
+    logger.error(`${connector.type} listener failed`, {
+      connector: connector.name,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+logger.info(`event logs: ${LOG_DIR}`)
+logger.info("funnel gateway running")

package/lib/modules/gateway/funnel-broadcaster.ts

@@ -0,0 +1,37 @@
+import type { ServerWebSocket } from "bun"
+
+type ClientData = {
+  channel: string
+  connectors: string[]
+}
+
+export class FunnelBroadcaster {
+  private readonly clients: Map<ServerWebSocket<unknown>, ClientData> = new Map()
+
+  addClient(ws: ServerWebSocket<unknown>, data: ClientData): void {
+    this.clients.set(ws, data)
+  }
+
+  removeClient(ws: ServerWebSocket<unknown>): void {
+    this.clients.delete(ws)
+  }
+
+  getClientCount(): number {
+    return this.clients.size
+  }
+
+  listChannels(): { channel: string; connectors: string[] }[] {
+    return [...this.clients.values()].map((d) => ({ ...d }))
+  }
+
+  broadcast(content: string, meta?: Record<string, string>): void {
+    const payload = JSON.stringify({ content, meta })
+    const connector = meta?.connector
+
+    for (const [ws, data] of this.clients) {
+      if (connector && !data.connectors.includes(connector)) continue
+
+      ws.send(payload)
+    }
+  }
+}

package/lib/modules/gateway/funnel-event-logger.ts

@@ -0,0 +1,59 @@
+import { join } from "node:path"
+import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
+
+const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000 // 30 days
+
+type Deps = {
+  logDir: string
+  fs?: FunnelFileSystem
+  now?: () => number
+}
+
+const defaultFs = new NodeFunnelFileSystem()
+
+export class FunnelEventLogger {
+  private readonly logDir: string
+  private readonly fs: FunnelFileSystem
+  private readonly now: () => number
+
+  constructor(deps: Deps) {
+    this.logDir = deps.logDir
+    this.fs = deps.fs ?? defaultFs
+    this.now = deps.now ?? (() => Date.now())
+    this.fs.mkdirSync(this.logDir, { recursive: true })
+    this.rotate()
+    Object.freeze(this)
+  }
+
+  log(content: string, meta?: Record<string, string>): void {
+    const entry = {
+      timestamp: new Date(this.now()).toISOString(),
+      eventType: meta?.event_type ?? "unknown",
+      content: content.length > 2000 ? `${content.slice(0, 2000)}...` : content,
+      meta,
+    }
+    const dateStr = new Date(this.now()).toISOString().slice(0, 10)
+    const logFile = join(this.logDir, `${dateStr}.jsonl`)
+
+    this.fs.appendFileSync(logFile, `${JSON.stringify(entry)}\n`)
+  }
+
+  private rotate(): void {
+    const now = this.now()
+
+    for (const name of this.fs.readdirSync(this.logDir)) {
+      if (!name.endsWith(".jsonl")) continue
+
+      const path = join(this.logDir, name)
+
+      try {
+        const stat = this.fs.statSync(path)
+
+        if (now - stat.mtimeMs > MAX_AGE_MS) this.fs.unlink(path)
+      } catch {
+        // ignore
+      }
+    }
+  }
+}

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

@@ -0,0 +1,166 @@
+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"
+
+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"
+
+type Deps = {
+  process?: FunnelProcessRunner
+  fs?: FunnelFileSystem
+}
+
+const defaultProcess = new NodeFunnelProcessRunner()
+const defaultFs = new NodeFunnelFileSystem()
+
+export class FunnelGateway {
+  private readonly process: FunnelProcessRunner
+  private readonly fs: FunnelFileSystem
+
+  constructor(deps: Deps = {}) {
+    this.process = deps.process ?? defaultProcess
+    this.fs = deps.fs ?? defaultFs
+    Object.freeze(this)
+  }
+
+  isRunning(): boolean {
+    const pid = this.readPid()
+
+    if (!pid) return false
+
+    return this.isProcessAlive(pid)
+  }
+
+  getStatus(): { running: boolean; pid: number | null; port: number } {
+    const pid = this.readPid()
+    const running = pid !== null && this.isProcessAlive(pid)
+
+    return { running, pid: running ? pid : null, port: DEFAULT_PORT }
+  }
+
+  async start(options: { caffeinate?: boolean } = {}): Promise<boolean> {
+    if (this.isRunning()) return true
+
+    this.fs.mkdirSync(TMP_DIR, { recursive: true })
+
+    const gatewayScript = resolve(import.meta.dir, "./daemon.ts")
+    const command = this.buildStartCommand(gatewayScript, options)
+
+    this.process.detach(["bash", "-c", command])
+
+    await Bun.sleep(800)
+
+    return this.isRunning()
+  }
+
+  buildStartCommand(gatewayScript: string, options: { caffeinate?: boolean } = {}): string {
+    const useCaffeinate = options.caffeinate !== false && globalThis.process.platform === "darwin"
+    const prefix = useCaffeinate ? "caffeinate -i " : ""
+
+    return `nohup ${prefix}bun ${gatewayScript} >> ${GATEWAY_LOG} 2>&1 &`
+  }
+
+  async stop(): Promise<boolean> {
+    const pid = this.readPid()
+
+    if (!pid) return true
+
+    if (!this.isProcessAlive(pid)) {
+      this.removePid()
+      return true
+    }
+
+    try {
+      globalThis.process.kill(pid, "SIGTERM")
+    } catch {
+      return false
+    }
+
+    const deadline = Date.now() + 2000
+
+    while (Date.now() < deadline) {
+      if (!this.isProcessAlive(pid)) {
+        this.removePid()
+        return true
+      }
+
+      await Bun.sleep(100)
+    }
+
+    try {
+      globalThis.process.kill(pid, "SIGKILL")
+    } catch {
+      // ignore
+    }
+
+    await Bun.sleep(200)
+    this.removePid()
+
+    return !this.isProcessAlive(pid)
+  }
+
+  async restart(
+    options: { onlyIfRunning?: boolean; caffeinate?: boolean } = {},
+  ): Promise<{ ok: boolean; wasRunning: boolean; stopped: boolean; started: boolean }> {
+    const wasRunning = this.isRunning()
+
+    if (options.onlyIfRunning && !wasRunning) {
+      return { ok: true, wasRunning: false, stopped: false, started: false }
+    }
+
+    const stopped = wasRunning ? await this.stop() : true
+
+    if (!stopped) {
+      return { ok: false, wasRunning, stopped: false, started: false }
+    }
+
+    const started = await this.start({ caffeinate: options.caffeinate })
+
+    return { ok: started, wasRunning, stopped, started }
+  }
+
+  getLogDir(): string {
+    return LOG_DIR
+  }
+
+  getGatewayLog(): string {
+    return GATEWAY_LOG
+  }
+
+  private readPid(): number | null {
+    if (!this.fs.existsSync(PID_FILE)) return null
+
+    try {
+      const content = this.fs.readFileSync(PID_FILE).trim()
+      const pid = Number(content)
+
+      if (!pid || pid <= 0) return null
+
+      return pid
+    } catch {
+      return null
+    }
+  }
+
+  private removePid(): void {
+    this.fs.unlink(PID_FILE)
+  }
+
+  private isProcessAlive(pid: number): boolean {
+    const result = this.process.runSync(["ps", "-p", String(pid), "-o", "state="])
+
+    if (result.exitCode !== 0) return false
+
+    const state = result.stdout.trim()
+
+    if (!state) return false
+
+    return !state.startsWith("Z")
+  }
+}

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

@@ -0,0 +1,52 @@
+import { logger } from "@/modules/logger"
+import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
+import { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-process-runner"
+
+type Props = {
+  selfPid: number
+  process?: FunnelProcessRunner
+}
+
+const defaultProcess = new NodeFunnelProcessRunner()
+
+const isBun = (args: string): boolean => {
+  return args.includes("bun ") || /\/bun(\s|$)/.test(args)
+}
+
+const looksLikeSlackGateway = (args: string): boolean => {
+  return /(gateway|bolt|slack)/i.test(args)
+}
+
+export const killCompetingSlackGateways = async (props: Props): Promise<number[]> => {
+  const runner = props.process ?? defaultProcess
+  const result = await runner.run(["ps", "-e", "-o", "pid=,args="])
+
+  if (result.exitCode !== 0) return []
+
+  const killed: number[] = []
+
+  for (const raw of result.stdout.split("\n")) {
+    const line = raw.trim()
+
+    if (!line) continue
+
+    const match = /^(\d+)\s+(.+)$/.exec(line)
+
+    if (!match) continue
+
+    const pid = Number(match[1])
+    const args = match[2]!
+
+    if (!Number.isInteger(pid) || pid <= 0) continue
+    if (pid === props.selfPid) continue
+    if (!isBun(args)) continue
+    if (!looksLikeSlackGateway(args)) continue
+
+    runner.kill(pid, "SIGTERM")
+    killed.push(pid)
+
+    logger.info("killed competing Slack gateway process", { pid, args: args.slice(0, 160) })
+  }
+
+  return killed
+}

package/lib/modules/http/funnel-http-client.ts

@@ -0,0 +1,17 @@
+export type HttpRequest = {
+  method: string
+  url: string
+  headers?: Record<string, string>
+  body?: string
+}
+
+export type HttpResponse = {
+  status: number
+  ok: boolean
+  text(): Promise<string>
+  json(): Promise<unknown>
+}
+
+export abstract class FunnelHttpClient {
+  abstract fetch(request: HttpRequest): Promise<HttpResponse>
+}

package/lib/modules/http/memory-funnel-http-client.ts

@@ -0,0 +1,40 @@
+import {
+  FunnelHttpClient,
+  type HttpRequest,
+  type HttpResponse,
+} from "@/modules/http/funnel-http-client"
+
+export type MemoryHttpResponse = {
+  status?: number
+  body?: string
+}
+
+export type MemoryHttpHandler = (
+  request: HttpRequest,
+) => MemoryHttpResponse | Promise<MemoryHttpResponse>
+
+export class MemoryFunnelHttpClient extends FunnelHttpClient {
+  readonly calls: HttpRequest[] = []
+  private handler: MemoryHttpHandler = () => ({ status: 200, body: "" })
+
+  on(handler: MemoryHttpHandler): this {
+    this.handler = handler
+
+    return this
+  }
+
+  async fetch(request: HttpRequest): Promise<HttpResponse> {
+    this.calls.push(request)
+
+    const response = await this.handler(request)
+    const status = response.status ?? 200
+    const body = response.body ?? ""
+
+    return {
+      status,
+      ok: status >= 200 && status < 300,
+      text: async () => body,
+      json: async () => JSON.parse(body),
+    }
+  }
+}