@interactive-inc/claude-funnel 0.2.0 → 0.4.0

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

@@ -0,0 +1,178 @@
+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"
+import {
+  type ScheduleConnectorConfig,
+  type ScheduleEntry,
+  scheduleEntrySchema,
+} from "@/modules/connectors/schedule-connector-schema"
+import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
+
+type Deps = {
+  fs?: FunnelFileSystem
+  dir?: string
+}
+
+const defaultFs = new NodeFunnelFileSystem()
+
+export class FunnelScheduleStore extends FunnelConnectorTypeStore<ScheduleConnectorConfig> {
+  readonly type = "schedule" as const
+  private readonly fs: FunnelFileSystem
+  private readonly baseDir: string
+  private readonly dir: string
+
+  constructor(deps: Deps = {}) {
+    super()
+    this.fs = deps.fs ?? defaultFs
+    this.baseDir = deps.dir ?? DEFAULT_FUNNEL_DIR
+    this.dir = join(this.baseDir, "connectors", "schedule")
+    Object.freeze(this)
+  }
+
+  list(): ScheduleConnectorConfig[] {
+    if (!this.fs.existsSync(this.dir)) return []
+
+    const files = this.fs.readdirSync(this.dir).filter((f) => f.endsWith(".jsonl"))
+    const configs: ScheduleConnectorConfig[] = []
+
+    for (const file of files) {
+      const name = file.slice(0, -6)
+      const config = this.get(name)
+
+      if (config) configs.push(config)
+    }
+
+    return configs
+  }
+
+  get(name: string): ScheduleConnectorConfig | null {
+    const path = this.pathFor(name)
+
+    if (!this.fs.existsSync(path)) return null
+
+    return { type: "schedule", name, entries: this.readEntries(name) }
+  }
+
+  has(name: string): boolean {
+    return this.fs.existsSync(this.pathFor(name))
+  }
+
+  add(config: ScheduleConnectorConfig): void {
+    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
+
+    this.fs.mkdirSync(this.dir, { recursive: true })
+    const lines = config.entries.map((e) => JSON.stringify(e)).join("\n")
+    this.fs.writeFileSync(this.pathFor(config.name), lines ? `${lines}\n` : "")
+  }
+
+  remove(name: string): void {
+    if (!this.has(name)) throw new Error(`connector "${name}" not found`)
+
+    this.fs.unlink(this.pathFor(name))
+    this.fs.unlink(this.statePathFor(name))
+  }
+
+  rename(oldName: string, newName: string): void {
+    if (!this.has(oldName)) throw new Error(`connector "${oldName}" not found`)
+    if (this.has(newName)) throw new Error(`connector "${newName}" already exists`)
+
+    const content = this.fs.readFileSync(this.pathFor(oldName))
+    this.fs.writeFileSync(this.pathFor(newName), content)
+    this.fs.unlink(this.pathFor(oldName))
+
+    if (this.fs.existsSync(this.statePathFor(oldName))) {
+      const state = this.fs.readFileSync(this.statePathFor(oldName))
+      this.fs.writeFileSync(this.statePathFor(newName), state)
+      this.fs.unlink(this.statePathFor(oldName))
+    }
+  }
+
+  addEntry(name: string, entry: Omit<ScheduleEntry, "id"> & { id?: string }): ScheduleEntry {
+    if (!this.has(name)) throw new Error(`connector "${name}" not found`)
+
+    const full: ScheduleEntry = {
+      id: entry.id ?? crypto.randomUUID(),
+      cron: entry.cron,
+      prompt: entry.prompt,
+      enabled: entry.enabled ?? true,
+    }
+
+    this.fs.appendFileSync(this.pathFor(name), `${JSON.stringify(full)}\n`)
+
+    return full
+  }
+
+  removeEntry(name: string, id: string): void {
+    const entries = this.readEntries(name)
+    const next = entries.filter((e) => e.id !== id)
+
+    if (next.length === entries.length) throw new Error(`schedule entry "${id}" not found`)
+
+    const content = next.map((e) => JSON.stringify(e)).join("\n")
+    this.fs.writeFileSync(this.pathFor(name), content ? `${content}\n` : "")
+  }
+
+  createListener(config: ScheduleConnectorConfig): FunnelConnectorListener {
+    return new FunnelScheduleListener({
+      config,
+      store: this,
+      lastFiredStore: this.createLastFiredStore(config.name),
+    })
+  }
+
+  private createLastFiredStore(name: string): ScheduleLastFiredStore {
+    return new ScheduleLastFiredStore({ connector: name, fs: this.fs, dir: this.baseDir })
+  }
+
+  private pathFor(name: string): string {
+    return join(this.dir, `${name}.jsonl`)
+  }
+
+  private statePathFor(name: string): string {
+    return join(this.dir, `${name}.state.json`)
+  }
+
+  private readEntries(name: string): ScheduleEntry[] {
+    const path = this.pathFor(name)
+
+    if (!this.fs.existsSync(path)) return []
+
+    const content = this.fs.readFileSync(path)
+    const lines = content.split("\n").filter((l) => l.trim().length > 0)
+    const entries: ScheduleEntry[] = []
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]!
+      const lineNumber = i + 1
+
+      try {
+        const parsed = JSON.parse(line)
+        const result = scheduleEntrySchema.safeParse(parsed)
+
+        if (!result.success) {
+          logger.warn("skipping invalid schedule entry", {
+            connector: name,
+            line: lineNumber,
+            issues: result.error.issues.map((iss) => `${iss.path.join(".")}: ${iss.message}`),
+          })
+          continue
+        }
+
+        entries.push(result.data)
+      } catch (error) {
+        logger.warn("skipping unparseable schedule entry", {
+          connector: name,
+          line: lineNumber,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    }
+
+    return entries
+  }
+}

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

@@ -3,7 +3,7 @@ import {
   FunnelConnectorAdapter,
   type CallInput,
 } from "@/modules/connectors/funnel-connector-adapter"
-import type { SlackConnectorConfig } from "@/modules/settings/settings-schema"
+import type { SlackConnectorConfig } from "@/modules/connectors/slack-connector-schema"
 
 export type SlackWebClientLike = {
   apiCall: (method: string, options: Record<string, unknown>) => Promise<unknown>

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

@@ -5,7 +5,7 @@ import {
 } from "@/modules/connectors/funnel-connector-listener"
 import { FunnelSlackEventProcessor } from "@/modules/connectors/funnel-slack-event-processor"
 import { logger } from "@/modules/logger"
-import type { SlackConnectorConfig } from "@/modules/settings/settings-schema"
+import type { SlackConnectorConfig } from "@/modules/connectors/slack-connector-schema"
 
 type Deps = {
   config: SlackConnectorConfig

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

@@ -0,0 +1,86 @@
+import { FunnelCallableConnectorStore } from "@/modules/connectors/funnel-callable-connector-store"
+import type { FunnelConnectorAdapter } from "@/modules/connectors/funnel-connector-adapter"
+import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
+import {
+  DEFAULT_FUNNEL_DIR,
+  FunnelJsonConnectorStore,
+} from "@/modules/connectors/funnel-json-connector-store"
+import { FunnelSlackAdapter } from "@/modules/connectors/funnel-slack-adapter"
+import { FunnelSlackListener } from "@/modules/connectors/funnel-slack-listener"
+import {
+  type SlackConnectorConfig,
+  slackConnectorSchema,
+} from "@/modules/connectors/slack-connector-schema"
+import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+
+type Deps = {
+  fs?: FunnelFileSystem
+  dir?: string
+}
+
+export type SlackUpdateFields = {
+  botToken?: string
+  appToken?: string
+}
+
+export class FunnelSlackStore extends FunnelCallableConnectorStore<SlackConnectorConfig> {
+  readonly type = "slack" as const
+  private readonly store: FunnelJsonConnectorStore<SlackConnectorConfig>
+
+  constructor(deps: Deps = {}) {
+    super()
+    this.store = new FunnelJsonConnectorStore<SlackConnectorConfig>({
+      type: "slack",
+      schema: slackConnectorSchema,
+      fs: deps.fs,
+      dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
+    })
+    Object.freeze(this)
+  }
+
+  list(): SlackConnectorConfig[] {
+    return this.store.list()
+  }
+
+  get(name: string): SlackConnectorConfig | null {
+    return this.store.get(name)
+  }
+
+  has(name: string): boolean {
+    return this.store.has(name)
+  }
+
+  add(config: SlackConnectorConfig): void {
+    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
+
+    this.store.write(config)
+  }
+
+  update(name: string, fields: SlackUpdateFields): void {
+    const current = this.store.get(name)
+
+    if (!current) throw new Error(`connector "${name}" not found`)
+
+    this.store.write({
+      ...current,
+      botToken: fields.botToken ?? current.botToken,
+      appToken: fields.appToken ?? current.appToken,
+    })
+  }
+
+  remove(name: string): void {
+    this.store.remove(name)
+  }
+
+  rename(oldName: string, newName: string): void {
+    this.store.rename(oldName, newName)
+  }
+
+  createListener(config: SlackConnectorConfig): FunnelConnectorListener {
+    return new FunnelSlackListener({ config })
+  }
+
+  createAdapter(config: SlackConnectorConfig): FunnelConnectorAdapter {
+    return new FunnelSlackAdapter({ config })
+  }
+}

package/lib/modules/connectors/gh-connector-schema.ts

@@ -0,0 +1,9 @@
+import { z } from "zod"
+
+export const ghConnectorSchema = z.object({
+  type: z.literal("gh"),
+  name: z.string(),
+  pollInterval: z.number().int().positive().optional(),
+})
+
+export type GhConnectorConfig = z.infer<typeof ghConnectorSchema>

package/lib/modules/connectors/match-cron.ts

@@ -0,0 +1,72 @@
+type Field = { min: number; max: number; values: Set<number> }
+
+const parseField = (expr: string, min: number, max: number): Field => {
+  const values = new Set<number>()
+
+  for (const part of expr.split(",")) {
+    const [rangePart, stepPart] = part.split("/")
+    const step = stepPart ? Number(stepPart) : 1
+
+    if (!Number.isFinite(step) || step <= 0) {
+      throw new Error(`invalid cron step: "${stepPart}"`)
+    }
+
+    let lo = min
+    let hi = max
+
+    if (rangePart === "*" || rangePart === undefined || rangePart === "") {
+      lo = min
+      hi = max
+    } else if (rangePart.includes("-")) {
+      const [a, b] = rangePart.split("-").map(Number)
+
+      if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        throw new Error(`invalid cron range: "${rangePart}"`)
+      }
+
+      lo = a as number
+      hi = b as number
+    } else {
+      const n = Number(rangePart)
+
+      if (!Number.isFinite(n)) throw new Error(`invalid cron value: "${rangePart}"`)
+
+      lo = n
+      hi = stepPart ? max : n
+    }
+
+    if (lo < min || hi > max || lo > hi) {
+      throw new Error(`cron value out of range: ${rangePart} (must be ${min}-${max})`)
+    }
+
+    for (let i = lo; i <= hi; i += step) {
+      values.add(i)
+    }
+  }
+
+  return { min, max, values }
+}
+
+export const matchCron = (expr: string, date: Date): boolean => {
+  const parts = expr.trim().split(/\s+/)
+
+  if (parts.length !== 5) {
+    throw new Error(`cron must have 5 fields (got ${parts.length}): "${expr}"`)
+  }
+
+  const [minute, hour, dom, month, dow] = parts as [string, string, string, string, string]
+
+  const fields = [
+    { field: parseField(minute, 0, 59), value: date.getMinutes() },
+    { field: parseField(hour, 0, 23), value: date.getHours() },
+    { field: parseField(dom, 1, 31), value: date.getDate() },
+    { field: parseField(month, 1, 12), value: date.getMonth() + 1 },
+    { field: parseField(dow, 0, 6), value: date.getDay() },
+  ]
+
+  for (const { field, value } of fields) {
+    if (!field.values.has(value)) return false
+  }
+
+  return true
+}

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

@@ -0,0 +1,77 @@
+import { join } from "node:path"
+import { connectorConfigSchema } from "@/modules/connectors/connector-config-schema"
+import type { ConnectorStoresBundle } from "@/modules/connectors/funnel-connector-stores"
+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"
+
+type Props = {
+  stores: ConnectorStoresBundle
+  fs?: FunnelFileSystem
+  dir?: string
+}
+
+const defaultFs = new NodeFunnelFileSystem()
+
+export const migrateLegacyConnectors = (props: Props): number => {
+  const fs = props.fs ?? defaultFs
+  const base = props.dir ?? DEFAULT_FUNNEL_DIR
+  const path = join(base, "settings.json")
+
+  if (!fs.existsSync(path)) return 0
+
+  const content = fs.readFileSync(path)
+  const raw = JSON.parse(content) as Record<string, unknown>
+  const legacy = raw.connectors
+
+  if (!Array.isArray(legacy) || legacy.length === 0) {
+    if (legacy !== undefined) {
+      const stripped = { ...raw }
+      delete stripped.connectors
+      fs.writeFileSync(path, `${JSON.stringify(stripped, null, 2)}\n`)
+    }
+    return 0
+  }
+
+  let migrated = 0
+
+  for (const entry of legacy) {
+    const parsed = connectorConfigSchema.safeParse(entry)
+
+    if (!parsed.success) {
+      logger.warn("skipping invalid legacy connector", {
+        error: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", "),
+      })
+      continue
+    }
+
+    const config = parsed.data
+
+    if (config.type === "slack") {
+      if (props.stores.slack.has(config.name)) continue
+      props.stores.slack.add(config)
+    } else if (config.type === "gh") {
+      if (props.stores.gh.has(config.name)) continue
+      props.stores.gh.add(config)
+    } else if (config.type === "discord") {
+      if (props.stores.discord.has(config.name)) continue
+      props.stores.discord.add(config)
+    } else {
+      if (props.stores.schedule.has(config.name)) continue
+      props.stores.schedule.add(config)
+    }
+
+    migrated++
+  }
+
+  const stripped = { ...raw }
+  delete stripped.connectors
+  fs.writeFileSync(path, `${JSON.stringify(stripped, null, 2)}\n`)
+
+  if (migrated > 0) {
+    logger.info("migrated legacy connectors from settings.json", { count: migrated })
+  }
+
+  return migrated
+}

package/lib/modules/connectors/schedule-connector-schema.ts

@@ -0,0 +1,18 @@
+import { z } from "zod"
+
+export const scheduleEntrySchema = z.object({
+  id: z.string(),
+  cron: z.string(),
+  prompt: z.string(),
+  enabled: z.boolean().default(true),
+})
+
+export type ScheduleEntry = z.infer<typeof scheduleEntrySchema>
+
+export const scheduleConnectorSchema = z.object({
+  type: z.literal("schedule"),
+  name: z.string(),
+  entries: z.array(scheduleEntrySchema).default([]),
+})
+
+export type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>

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

@@ -0,0 +1,48 @@
+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/connectors/slack-connector-schema.ts

@@ -0,0 +1,10 @@
+import { z } from "zod"
+
+export const slackConnectorSchema = z.object({
+  type: z.literal("slack"),
+  name: z.string(),
+  botToken: z.string().startsWith("xoxb-"),
+  appToken: z.string().startsWith("xapp-"),
+})
+
+export type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>

package/lib/modules/gateway/daemon.ts

@@ -4,10 +4,14 @@ 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 { 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
@@ -45,6 +49,21 @@ 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()
@@ -146,11 +165,11 @@ const notify = async (
   broadcaster.broadcast(content, withConnector)
 }
 
-const settings = store.read()
+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 (settings.connectors.some((c) => c.type === "slack")) {
+if (allConnectors.some((c) => c.type === "slack")) {
   const killed = await killCompetingSlackGateways({ selfPid: process.pid })
 
   if (killed.length > 0) {
@@ -162,25 +181,23 @@ if (settings.connectors.some((c) => c.type === "slack")) {
   }
 }
 
-for (const connector of settings.connectors) {
+for (const { config, listener } of connectors.createListeners()) {
   const bind = (content: string, meta?: Record<string, string>) =>
-    notify(connector.name, content, meta)
+    notify(config.name, content, meta)
 
   try {
-    const listener = resolveListener(connector)
-
     await listener.start(bind)
 
-    eventLogger.log(`${connector.type} listener started: ${connector.name}`, {
+    eventLogger.log(`${config.type} listener started: ${config.name}`, {
       event_type: "system",
-      action: `${connector.type}_connect`,
-      connector: connector.name,
+      action: `${config.type}_connect`,
+      connector: config.name,
     })
 
-    logger.info(`${connector.type} listener started`, { connector: connector.name })
+    logger.info(`${config.type} listener started`, { connector: config.name })
   } catch (error) {
-    logger.error(`${connector.type} listener failed`, {
-      connector: connector.name,
+    logger.error(`${config.type} listener failed`, {
+      connector: config.name,
       error: error instanceof Error ? error.message : String(error),
     })
   }

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

@@ -16,8 +16,7 @@ export const startChannelServer = async (): Promise<void> => {
       instructions: [
         `Events arrive inside <channel source="${FUNNEL_MCP_NAME}"> tags. Use meta.event_type to discriminate.`,
         "",
-        'event_type="slack": a Slack message. meta includes channel_id, user_id, mentioned, thread_ts, etc. content is the Slack event JSON.',
-        'event_type="system": system event (connect / disconnect / startup, etc.).',
+        "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"),
     },
   )