@interactive-inc/claude-funnel 0.4.1 → 0.8.0

package/lib/modules/connectors/schedule-last-fired-store.ts

@@ -1,48 +0,0 @@
-import { dirname, join } from "node:path"
-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"
-
-type Deps = {
-  connector: string
-  fs?: FunnelFileSystem
-  dir?: string
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-
-export class ScheduleLastFiredStore {
-  private readonly path: string
-  private readonly fs: FunnelFileSystem
-
-  constructor(deps: Deps) {
-    this.fs = deps.fs ?? defaultFs
-    const base = deps.dir ?? DEFAULT_FUNNEL_DIR
-    this.path = join(base, "connectors", "schedule", `${deps.connector}.state.json`)
-    Object.freeze(this)
-  }
-
-  load(): Map<string, Date> {
-    if (!this.fs.existsSync(this.path)) return new Map()
-
-    const raw = JSON.parse(this.fs.readFileSync(this.path)) as Record<string, string>
-    const map = new Map<string, Date>()
-
-    for (const [id, iso] of Object.entries(raw)) {
-      map.set(id, new Date(iso))
-    }
-
-    return map
-  }
-
-  save(state: Map<string, Date>): void {
-    const obj: Record<string, string> = {}
-
-    for (const [id, date] of state) {
-      obj[id] = date.toISOString()
-    }
-
-    this.fs.mkdirSync(dirname(this.path), { recursive: true })
-    this.fs.writeFileSync(this.path, `${JSON.stringify(obj, null, 2)}\n`)
-  }
-}

package/lib/modules/gateway/daemon.ts

@@ -1,207 +0,0 @@
-#!/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 { FunnelProfiles } from "@/modules/profiles/funnel-profiles"
-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 connectorStores = createConnectorStores()
-
-migrateLegacyConnectors({ stores: connectorStores })
-
-const profiles = new FunnelProfiles({ store })
-const channels: FunnelChannels = new FunnelChannels({
-  store,
-  connectorChecker: { has: (name: string) => connectors.has(name) },
-  profileChecker: profiles,
-  profileRefUpdater: profiles,
-})
-const connectors: FunnelConnectors = new FunnelConnectors({
-  ...connectorStores,
-  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>({
-  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 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")

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

@@ -1,37 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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/logger.ts

@@ -1,26 +0,0 @@
-import { appendFileSync, mkdirSync } from "node:fs"
-import { dirname, join } from "node:path"
-
-const LOG_FILE = join("/tmp/funnel", "funnel.log")
-
-type Level = "info" | "warn" | "error"
-
-const write = (level: Level, message: string, meta?: Record<string, unknown>) => {
-  mkdirSync(dirname(LOG_FILE), { recursive: true })
-
-  const entry = {
-    time: new Date().toISOString(),
-    level,
-    message,
-    ...(meta ? { meta } : {}),
-  }
-
-  appendFileSync(LOG_FILE, `${JSON.stringify(entry)}\n`)
-}
-
-export const logger = {
-  info: (message: string, meta?: Record<string, unknown>) => write("info", message, meta),
-  warn: (message: string, meta?: Record<string, unknown>) => write("warn", message, meta),
-  error: (message: string, meta?: Record<string, unknown>) => write("error", message, meta),
-  file: LOG_FILE,
-}

package/lib/modules/mcp/channel-server.ts

@@ -1,76 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js"
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
-import { FUNNEL_MCP_NAME } from "@/modules/mcp/funnel-mcp"
-
-const GATEWAY_WS_URL = process.env.FUNNEL_GATEWAY_URL ?? "ws://localhost:9742/ws"
-const RECONNECT_DELAY = 1000
-const MAX_RECONNECT_DELAY = 10000
-
-export const startChannelServer = async (): Promise<void> => {
-  const server = new Server(
-    { name: FUNNEL_MCP_NAME, version: "1.0.0" },
-    {
-      capabilities: {
-        experimental: { "claude/channel": {} },
-      },
-      instructions: [
-        `Events arrive inside <channel source="${FUNNEL_MCP_NAME}"> tags. Use meta.event_type to discriminate.`,
-        "",
-        "To reply or act on an event, run `funnel request <platform> --help` via the Bash tool (e.g. `funnel request slack --help`). For general CLI usage, run `funnel --help`.",
-      ].join("\n"),
-    },
-  )
-
-  const transport = new StdioServerTransport()
-
-  await server.connect(transport)
-
-  const channelId = process.env.FUNNEL_CHANNEL_ID
-
-  if (!channelId) return
-
-  const wsUrl = `${GATEWAY_WS_URL}?channel=${encodeURIComponent(channelId)}`
-  let reconnectDelay = RECONNECT_DELAY
-
-  const connect = () => {
-    const ws = new WebSocket(wsUrl)
-
-    ws.addEventListener("open", () => {
-      reconnectDelay = RECONNECT_DELAY
-      process.stderr.write(`funnel: connected (${wsUrl})\n`)
-    })
-
-    ws.addEventListener("message", async (event) => {
-      try {
-        const payload = JSON.parse(String(event.data))
-        const eventType = payload.meta?.event_type ?? "unknown"
-
-        process.stderr.write(`funnel: received event (${eventType})\n`)
-
-        await server.notification({
-          method: "notifications/claude/channel",
-          params: {
-            content: payload.content,
-            meta: payload.meta,
-          },
-        })
-      } catch (error) {
-        process.stderr.write(
-          `funnel: error: ${error instanceof Error ? error.message : String(error)}\n`,
-        )
-      }
-    })
-
-    ws.addEventListener("close", () => {
-      process.stderr.write(`funnel: disconnected, reconnecting in ${reconnectDelay}ms\n`)
-      setTimeout(connect, reconnectDelay)
-      reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY)
-    })
-
-    ws.addEventListener("error", () => {
-      // close handler will reconnect
-    })
-  }
-
-  connect()
-}

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

@@ -1,123 +0,0 @@
-import { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
-import type { ProfileConfig } from "@/modules/settings/settings-schema"
-
-type Deps = {
-  store: FunnelSettingsReader
-}
-
-export class FunnelProfiles {
-  private readonly store: FunnelSettingsReader
-
-  constructor(deps: Deps) {
-    this.store = deps.store
-    Object.freeze(this)
-  }
-
-  list(): ProfileConfig[] {
-    return this.store.read().profiles
-  }
-
-  get(name: string): ProfileConfig | null {
-    return this.list().find((p) => p.name === name) ?? null
-  }
-
-  add(config: ProfileConfig): void {
-    const settings = this.store.read()
-
-    if (settings.profiles.some((p) => p.name === config.name)) {
-      throw new Error(`profile "${config.name}" already exists`)
-    }
-
-    if (!settings.channels.some((c) => c.name === config.channel)) {
-      throw new Error(`channel "${config.channel}" not found`)
-    }
-
-    if (config.repo && !settings.repositories.some((r) => r.name === config.repo)) {
-      throw new Error(`repo "${config.repo}" not found`)
-    }
-
-    settings.profiles.push(config)
-
-    this.store.write(settings)
-  }
-
-  remove(name: string): void {
-    const settings = this.store.read()
-
-    const index = settings.profiles.findIndex((p) => p.name === name)
-
-    if (index < 0) throw new Error(`profile "${name}" not found`)
-
-    settings.profiles.splice(index, 1)
-
-    this.store.write(settings)
-  }
-
-  rename(oldName: string, newName: string): void {
-    const settings = this.store.read()
-
-    const profile = settings.profiles.find((p) => p.name === oldName)
-
-    if (!profile) throw new Error(`profile "${oldName}" not found`)
-
-    if (settings.profiles.some((p) => p.name === newName)) {
-      throw new Error(`profile "${newName}" already exists`)
-    }
-
-    profile.name = newName
-
-    this.store.write(settings)
-  }
-
-  hasChannelRef(channelName: string): boolean {
-    return this.store.read().profiles.some((p) => p.channel === channelName)
-  }
-
-  renameChannelRef(oldName: string, newName: string): void {
-    const settings = this.store.read()
-    let changed = false
-
-    for (const profile of settings.profiles) {
-      if (profile.channel === oldName) {
-        profile.channel = newName
-        changed = true
-      }
-    }
-
-    if (changed) this.store.write(settings)
-  }
-
-  update(name: string, fields: Partial<Omit<ProfileConfig, "name">>): void {
-    const settings = this.store.read()
-
-    const profile = settings.profiles.find((p) => p.name === name)
-
-    if (!profile) throw new Error(`profile "${name}" not found`)
-
-    if (fields.channel !== undefined) {
-      if (!settings.channels.some((c) => c.name === fields.channel)) {
-        throw new Error(`channel "${fields.channel}" not found`)
-      }
-
-      profile.channel = fields.channel
-    }
-
-    if (fields.repo !== undefined) {
-      if (fields.repo && !settings.repositories.some((r) => r.name === fields.repo)) {
-        throw new Error(`repo "${fields.repo}" not found`)
-      }
-
-      profile.repo = fields.repo || undefined
-    }
-
-    if (fields.subAgent !== undefined) {
-      profile.subAgent = fields.subAgent || undefined
-    }
-
-    if (fields.envFiles !== undefined) {
-      profile.envFiles = fields.envFiles
-    }
-
-    this.store.write(settings)
-  }
-}

package/lib/modules/profiles/profile-channel-checker.ts

@@ -1,3 +0,0 @@
-export type ProfileChannelChecker = {
-  hasChannelRef(channelName: string): boolean
-}

package/lib/modules/profiles/profile-channel-ref-updater.ts

@@ -1,3 +0,0 @@
-export type ProfileChannelRefUpdater = {
-  renameChannelRef(oldName: string, newName: string): void
-}

package/lib/modules/repos/funnel-repositories.ts

@@ -1,107 +0,0 @@
-import type { FunnelMcp } from "@/modules/mcp/funnel-mcp"
-import { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
-import type { RepositoryConfig } from "@/modules/settings/settings-schema"
-
-type Deps = {
-  store: FunnelSettingsReader
-  mcp: FunnelMcp
-}
-
-export class FunnelRepositories {
-  private readonly store: FunnelSettingsReader
-  private readonly mcp: FunnelMcp
-
-  constructor(deps: Deps) {
-    this.store = deps.store
-    this.mcp = deps.mcp
-    Object.freeze(this)
-  }
-
-  list(): RepositoryConfig[] {
-    return this.store.read().repositories
-  }
-
-  get(name: string): RepositoryConfig | null {
-    return this.list().find((r) => r.name === name) ?? null
-  }
-
-  add(config: RepositoryConfig): void {
-    const settings = this.store.read()
-
-    if (settings.repositories.some((r) => r.name === config.name)) {
-      throw new Error(`repo "${config.name}" already exists`)
-    }
-
-    this.mcp.install(config.path)
-
-    settings.repositories.push(config)
-
-    this.store.write(settings)
-  }
-
-  remove(name: string): void {
-    const settings = this.store.read()
-
-    const index = settings.repositories.findIndex((r) => r.name === name)
-
-    if (index < 0) throw new Error(`repo "${name}" not found`)
-
-    if (settings.profiles.some((p) => p.repo === name)) {
-      throw new Error(`repo "${name}" is referenced by a profile`)
-    }
-
-    const repo = settings.repositories[index]!
-
-    this.mcp.uninstall(repo.path)
-
-    settings.repositories.splice(index, 1)
-
-    this.store.write(settings)
-  }
-
-  rename(oldName: string, newName: string): void {
-    const settings = this.store.read()
-
-    const repo = settings.repositories.find((r) => r.name === oldName)
-
-    if (!repo) throw new Error(`repo "${oldName}" not found`)
-
-    if (settings.repositories.some((r) => r.name === newName)) {
-      throw new Error(`repo "${newName}" already exists`)
-    }
-
-    repo.name = newName
-
-    for (const profile of settings.profiles) {
-      if (profile.repo === oldName) profile.repo = newName
-    }
-
-    this.store.write(settings)
-  }
-
-  update(name: string, fields: Partial<Pick<RepositoryConfig, "path">>): void {
-    const settings = this.store.read()
-
-    const repo = settings.repositories.find((r) => r.name === name)
-
-    if (!repo) throw new Error(`repo "${name}" not found`)
-
-    if (fields.path !== undefined && fields.path !== repo.path) {
-      this.mcp.uninstall(repo.path)
-
-      this.mcp.install(fields.path)
-
-      repo.path = fields.path
-    }
-
-    this.store.write(settings)
-  }
-
-  resolvePath(name: string): string {
-    const repo = this.get(name)
-
-    if (!repo) throw new Error(`repo "${name}" not found`)
-
-    return repo.path
-  }
-}