@interactive-inc/claude-funnel 0.7.1 → 0.8.1

package/lib/cli/routes/profiles.add.$profile.ts

@@ -0,0 +1,46 @@
+import { HTTPException } from "hono/http-exception"
+import { z } from "zod"
+import { factory } from "@/cli/factory"
+import { zValidator } from "@/cli/router/validator"
+
+export const addHelp = `funnel profiles add — add a profile
+
+usage: funnel profiles add <name> --path <path> --sub-agent <agent> --channel <channel-name>
+
+options:
+  --path        working directory passed to claude as cwd
+  --sub-agent   sub-agent name passed to claude --agent
+  --channel     channel name (resolved to channel id internally)`
+
+export const profilesAddHandler = factory.createHandlers(
+  zValidator("param", z.object({ profile: z.string() })),
+  zValidator(
+    "query",
+    z.object({
+      path: z.string(),
+      "sub-agent": z.string(),
+      channel: z.string(),
+    }),
+    addHelp,
+  ),
+  (c) => {
+    const param = c.req.valid("param")
+    const query = c.req.valid("query")
+    const funnel = c.var.funnel
+
+    const channel = funnel.channels.get(query.channel)
+
+    if (!channel) {
+      throw new HTTPException(400, { message: `channel "${query.channel}" not found` })
+    }
+
+    funnel.profiles.add({
+      name: param.profile,
+      path: query.path,
+      subAgent: query["sub-agent"],
+      channelId: channel.id,
+    })
+
+    return c.text(`added profile "${param.profile}"`)
+  },
+)

package/lib/cli/routes/profiles.remove.$profile.ts

@@ -0,0 +1,20 @@
+import { z } from "zod"
+import { factory } from "@/cli/factory"
+import { zValidator } from "@/cli/router/validator"
+
+export const removeHelp = `funnel profiles remove — remove a profile
+
+usage: funnel profiles remove <name>`
+
+export const profilesRemoveHandler = factory.createHandlers(
+  zValidator("param", z.object({ profile: z.string() })),
+  zValidator("query", z.object({}), removeHelp),
+  (c) => {
+    const param = c.req.valid("param")
+    const funnel = c.var.funnel
+
+    funnel.profiles.remove(param.profile)
+
+    return c.text(`removed profile "${param.profile}"`)
+  },
+)

package/lib/cli/routes/profiles.set.$profile.ts

@@ -0,0 +1,46 @@
+import { HTTPException } from "hono/http-exception"
+import { z } from "zod"
+import { factory } from "@/cli/factory"
+import { zValidator } from "@/cli/router/validator"
+
+export const setHelp = `funnel profiles <name> set — update a profile
+
+usage: funnel profiles <name> set [--path <path>] [--sub-agent <agent>] [--channel <channel-name>]`
+
+export const profilesSetHandler = factory.createHandlers(
+  zValidator("param", z.object({ profile: z.string() })),
+  zValidator(
+    "query",
+    z.object({
+      path: z.string().optional(),
+      "sub-agent": z.string().optional(),
+      channel: z.string().optional(),
+    }),
+    setHelp,
+  ),
+  (c) => {
+    const param = c.req.valid("param")
+    const query = c.req.valid("query")
+    const funnel = c.var.funnel
+
+    let channelId: string | undefined
+
+    if (query.channel !== undefined) {
+      const channel = funnel.channels.get(query.channel)
+
+      if (!channel) {
+        throw new HTTPException(400, { message: `channel "${query.channel}" not found` })
+      }
+
+      channelId = channel.id
+    }
+
+    funnel.profiles.update(param.profile, {
+      path: query.path,
+      subAgent: query["sub-agent"],
+      channelId,
+    })
+
+    return c.text(`updated profile "${param.profile}"`)
+  },
+)

package/lib/cli/routes/profiles.ts

@@ -0,0 +1,40 @@
+import { z } from "zod"
+import { factory } from "@/cli/factory"
+import { zValidator } from "@/cli/router/validator"
+
+export const groupHelp = `funnel profiles — manage launch profiles
+
+usage: funnel profiles [subcommand]
+
+subcommands:
+  (none)                          list (first entry is the default)
+  add <name> --path <path> --sub-agent <agent> --channel <channel>
+  <name> set [--path ...] [--sub-agent ...] [--channel ...]
+  <name> as-default               move profile to the front (becomes default)
+  rename <old> <new>              rename
+  remove <name>                   remove
+  <name> run                      launch (sugar for fnl claude -p <name>)
+  <name>                          launch (alias for run)
+
+examples:
+  funnel profiles add cto --path /repo/myapp --sub-agent cto --channel prod-inbox
+  funnel profiles cto as-default
+  funnel profiles cto run`
+
+export const profilesGroupHandler = factory.createHandlers(
+  zValidator("query", z.object({}), groupHelp),
+  (c) => {
+    const funnel = c.var.funnel
+    const profiles = funnel.profiles.list()
+
+    if (profiles.length === 0) return c.text("no profiles")
+
+    const lines = profiles.map((profile, index) => {
+      const tag = index === 0 ? " (default)" : ""
+
+      return `${profile.name}${tag}  [path=${profile.path}, sub-agent=${profile.subAgent}, channel=${profile.channelId}]`
+    })
+
+    return c.text(lines.join("\n"))
+  },
+)

package/lib/cli/routes/status.ts

@@ -0,0 +1,93 @@
+import { z } from "zod"
+import { factory } from "@/cli/factory"
+import { zValidator } from "@/cli/router/validator"
+
+export const statusHelp = `funnel status — show overall connection status
+
+usage: funnel status
+
+Lists configured connectors / channels / profiles, gateway running status,
+and active MCP WebSocket clients.`
+
+type GatewayClient = { channel: string; connectors: string[] }
+
+type GatewayStatus = {
+  ok: boolean
+  clients: GatewayClient[]
+}
+
+const isGatewayStatus = (value: unknown): value is GatewayStatus => {
+  if (value === null || typeof value !== "object") return false
+  if (!("clients" in value) || !Array.isArray(value.clients)) return false
+
+  return value.clients.every(
+    (client: unknown) =>
+      typeof client === "object" &&
+      client !== null &&
+      "channel" in client &&
+      typeof client.channel === "string" &&
+      "connectors" in client &&
+      Array.isArray(client.connectors),
+  )
+}
+
+export const statusHandler = factory.createHandlers(
+  zValidator("query", z.object({}), statusHelp),
+  async (c) => {
+    const funnel = c.var.funnel
+    const channels = funnel.channels.list()
+    const profiles = funnel.profiles.list()
+    const gatewayStatus = funnel.gateway.getStatus()
+
+    const lines: string[] = []
+
+    lines.push("= funnel status =")
+    lines.push("")
+
+    lines.push(`channels: ${channels.length}`)
+    for (const ch of channels) {
+      const attached =
+        ch.connectors.length > 0
+          ? ch.connectors.map((c) => `${c.name}:${c.type}`).join(", ")
+          : "(none)"
+      lines.push(`  - ${ch.name} [${attached}]`)
+    }
+    lines.push("")
+
+    lines.push(`profiles: ${profiles.length}`)
+    for (const [index, profile] of profiles.entries()) {
+      const tag = index === 0 ? " (default)" : ""
+      const channel = funnel.channels.getById(profile.channelId)
+      const channelLabel = channel ? channel.name : `id:${profile.channelId}`
+
+      lines.push(
+        `  - ${profile.name}${tag} [path=${profile.path}, sub-agent=${profile.subAgent}, channel=${channelLabel}]`,
+      )
+    }
+    lines.push("")
+
+    if (!gatewayStatus.running) {
+      lines.push("gateway: not running")
+    } else {
+      lines.push(`gateway: running (pid ${gatewayStatus.pid}, port ${gatewayStatus.port})`)
+
+      const res = await fetch(`http://localhost:${gatewayStatus.port}/status`).catch(() => null)
+
+      if (res && res.ok) {
+        const body: unknown = await res.json()
+
+        if (isGatewayStatus(body)) {
+          lines.push(`  clients: ${body.clients.length}`)
+
+          for (const client of body.clients) {
+            const connectorList =
+              client.connectors.length > 0 ? client.connectors.join(", ") : "(none)"
+            lines.push(`    - channel=${client.channel || "(unset)"} [${connectorList}]`)
+          }
+        }
+      }
+    }
+
+    return c.text(lines.join("\n"))
+  },
+)

package/lib/cli/routes/update.ts

@@ -0,0 +1,27 @@
+import { HTTPException } from "hono/http-exception"
+import { z } from "zod"
+import { factory } from "@/cli/factory"
+import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
+import { zValidator } from "@/cli/router/validator"
+
+export const updateHelp = `funnel update — update funnel to the latest version
+
+usage: funnel update
+
+Runs "bun i -g @interactive-inc/claude-funnel".`
+
+const PACKAGE = "@interactive-inc/claude-funnel"
+
+export const updateHandler = factory.createHandlers(
+  zValidator("query", z.object({}), updateHelp),
+  async (c) => {
+    const runner = new NodeFunnelProcessRunner()
+    const exitCode = await runner.attach(["bun", "i", "-g", PACKAGE])
+
+    if (exitCode !== 0) {
+      throw new HTTPException(500, { message: `update failed (exit ${exitCode})` })
+    }
+
+    return c.text(`updated ${PACKAGE}`)
+  },
+)

package/lib/connectors/connector-config-schema.ts

@@ -0,0 +1,16 @@
+import { z } from "zod"
+import { discordConnectorSchema } from "@/connectors/discord-connector-schema"
+import { ghConnectorSchema } from "@/connectors/gh-connector-schema"
+import { scheduleConnectorSchema } from "@/connectors/schedule-connector-schema"
+import { slackConnectorSchema } from "@/connectors/slack-connector-schema"
+
+export const connectorConfigSchema = z.discriminatedUnion("type", [
+  slackConnectorSchema,
+  ghConnectorSchema,
+  discordConnectorSchema,
+  scheduleConnectorSchema,
+])
+
+export type ConnectorConfig = z.infer<typeof connectorConfigSchema>
+
+export type ConnectorType = ConnectorConfig["type"]

package/lib/connectors/connector-factory.ts

@@ -0,0 +1,94 @@
+import type { FunnelConnectorAdapter } from "@/connectors/connector-adapter"
+import type { ConnectorConfig } from "@/connectors/connector-config-schema"
+import type { FunnelConnectorListener } from "@/connectors/connector-listener"
+import { FunnelDiscordAdapter } from "@/connectors/discord-adapter"
+import { FunnelDiscordListener } from "@/connectors/discord-listener"
+import { FunnelGhAdapter } from "@/connectors/gh-adapter"
+import { FunnelGhListener } from "@/connectors/gh-listener"
+import { FunnelScheduleListener } from "@/connectors/schedule-listener"
+import { ScheduleStateStore } from "@/connectors/schedule-state-store"
+import { FunnelSlackAdapter } from "@/connectors/slack-adapter"
+import { FunnelSlackListener } from "@/connectors/slack-listener"
+import { FunnelFileSystem } from "@/engine/fs/file-system"
+import { NodeFunnelFileSystem } from "@/engine/fs/node-file-system"
+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"
+import { FUNNEL_DIR } from "@/engine/settings/settings-store"
+import { join } from "node:path"
+
+type Deps = {
+  fs?: FunnelFileSystem
+  process?: FunnelProcessRunner
+  logger?: FunnelLogger
+  dir?: string
+}
+
+const defaultFs = new NodeFunnelFileSystem()
+const defaultProcess = new NodeFunnelProcessRunner()
+const defaultLogger = new NodeFunnelLogger()
+
+/**
+ * Pure factory for per-type listeners and adapters. The factory has no CRUD
+ * responsibility — connector configs live inside settings.json under their
+ * channel, and FunnelChannels passes them in by value.
+ *
+ * `dir` is the funnel home (defaults to ~/.funnel); per-connector state files
+ * land at `<dir>/channels/<channel-id>/connectors/<connector-id>/state.json`.
+ */
+export class FunnelConnectorFactory {
+  private readonly fs: FunnelFileSystem
+  private readonly process: FunnelProcessRunner
+  private readonly logger: FunnelLogger
+  private readonly dir: string
+
+  constructor(deps: Deps = {}) {
+    this.fs = deps.fs ?? defaultFs
+    this.process = deps.process ?? defaultProcess
+    this.logger = deps.logger ?? defaultLogger
+    this.dir = deps.dir ?? FUNNEL_DIR
+    Object.freeze(this)
+  }
+
+  createListener(channelId: string, config: ConnectorConfig): FunnelConnectorListener {
+    if (config.type === "slack") {
+      return new FunnelSlackListener({ config, logger: this.logger })
+    }
+
+    if (config.type === "gh") {
+      return new FunnelGhListener({ config, process: this.process, logger: this.logger })
+    }
+
+    if (config.type === "discord") {
+      return new FunnelDiscordListener({ config, logger: this.logger })
+    }
+
+    const lastFiredStore = new ScheduleStateStore({
+      path: join(this.connectorDir(channelId, config.id), "state.json"),
+      fs: this.fs,
+    })
+
+    return new FunnelScheduleListener({
+      config,
+      lastFiredStore,
+      logger: this.logger,
+    })
+  }
+
+  createAdapter(config: ConnectorConfig): FunnelConnectorAdapter | null {
+    if (config.type === "slack") return new FunnelSlackAdapter({ config })
+    if (config.type === "gh") return new FunnelGhAdapter({ process: this.process })
+    if (config.type === "discord") return new FunnelDiscordAdapter({ config })
+
+    return null
+  }
+
+  connectorDir(channelId: string, connectorId: string): string {
+    return join(this.dir, "channels", channelId, "connectors", connectorId)
+  }
+
+  channelDir(channelId: string): string {
+    return join(this.dir, "channels", channelId)
+  }
+}

package/lib/connectors/connector-listener.ts

@@ -0,0 +1,20 @@
+export type NotifyFn = (content: string, meta?: Record<string, string>) => Promise<void>
+
+/**
+ * Long-lived event source for one connector.
+ *
+ * `start()` opens the underlying connection (Slack Socket Mode, Discord
+ * Gateway, GH polling, schedule tick) and pushes events through `notify`.
+ * `stop()` releases the resources so the supervisor can recreate the listener
+ * with new config without restarting the whole gateway. `isAlive()` lets the
+ * supervisor periodically health-check and auto-restart dead listeners; the
+ * default optimistic implementation is fine for poll/tick-based listeners
+ * that self-heal.
+ */
+export abstract class FunnelConnectorListener {
+  abstract start(notify: NotifyFn): Promise<void>
+  abstract stop(): Promise<void>
+  isAlive(): boolean {
+    return true
+  }
+}

package/lib/{modules/connectors/funnel-discord-adapter.ts → connectors/discord-adapter.ts}

@@ -1,10 +1,7 @@
-import {
-  FunnelConnectorAdapter,
-  type CallInput,
-} from "@/modules/connectors/funnel-connector-adapter"
-import { FunnelHttpClient } from "@/modules/http/funnel-http-client"
-import { NodeFunnelHttpClient } from "@/modules/http/node-funnel-http-client"
-import type { DiscordConnectorConfig } from "@/modules/connectors/discord-connector-schema"
+import { FunnelConnectorAdapter, type CallInput } from "@/connectors/connector-adapter"
+import { FunnelHttpClient } from "@/engine/http/http-client"
+import { NodeFunnelHttpClient } from "@/engine/http/node-http-client"
+import type { DiscordConnectorConfig } from "@/connectors/discord-connector-schema"
 
 const DISCORD_API_BASE = "https://discord.com/api/v10"
 
@@ -29,11 +26,9 @@ export class FunnelDiscordAdapter extends FunnelConnectorAdapter {
   async call(input: CallInput): Promise<unknown> {
     const method = (input.method || "GET").toUpperCase()
     const path = input.path.startsWith("/") ? input.path : `/${input.path}`
+    const body = input.body
     const hasBody =
-      input.body &&
-      typeof input.body === "object" &&
-      method !== "GET" &&
-      Object.keys(input.body as object).length > 0
+      body !== null && typeof body === "object" && method !== "GET" && Object.keys(body).length > 0
 
     const res = await this.http.fetch({
       method,

package/lib/{modules/connectors → connectors}/discord-connector-schema.ts

@@ -1,9 +1,12 @@
 import { z } from "zod"
 
 export const discordConnectorSchema = z.object({
-  type: z.literal("discord"),
+  id: z.string(),
   name: z.string(),
+  type: z.literal("discord"),
   botToken: z.string().min(10),
+  createdAt: z.string().datetime().optional(),
+  updatedAt: z.string().datetime().optional(),
 })
 
 export type DiscordConnectorConfig = z.infer<typeof discordConnectorSchema>

package/lib/connectors/discord-listener.ts

@@ -0,0 +1,111 @@
+import { Client, GatewayIntentBits, Partials } from "discord.js"
+import { FunnelConnectorListener, type NotifyFn } from "@/connectors/connector-listener"
+import { FunnelDiscordEventProcessor } from "@/connectors/discord-event-processor"
+import { FunnelLogger } from "@/engine/logger/logger"
+import { NodeFunnelLogger } from "@/engine/logger/node-logger"
+import type { DiscordConnectorConfig } from "@/connectors/discord-connector-schema"
+
+type Deps = {
+  config: DiscordConnectorConfig
+  logger?: FunnelLogger
+}
+
+const defaultLogger = new NodeFunnelLogger()
+
+export class FunnelDiscordListener extends FunnelConnectorListener {
+  private readonly config: DiscordConnectorConfig
+  private readonly logger: FunnelLogger
+  private client: Client | null = null
+
+  constructor(deps: Deps) {
+    super()
+    this.config = deps.config
+    this.logger = deps.logger ?? defaultLogger
+  }
+
+  async start(notify: NotifyFn): Promise<void> {
+    const client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages,
+      ],
+      partials: [Partials.Channel],
+    })
+
+    client.on("messageCreate", async (message) => {
+      const ownUserId = client.user?.id ?? ""
+      const mentionedUserIds = [...message.mentions.users.keys()]
+
+      this.logger.info("discord messageCreate", {
+        author: message.author.id,
+        authorIsBot: String(message.author.bot),
+        channelId: message.channelId,
+        guildId: message.guildId ?? "",
+        mentions: mentionedUserIds.join(","),
+        ownUserId,
+        mentioned: String(mentionedUserIds.includes(ownUserId)),
+      })
+
+      const processor = new FunnelDiscordEventProcessor({ ownUserId })
+
+      const result = processor.process({
+        authorId: message.author.id,
+        authorIsBot: message.author.bot,
+        channelId: message.channelId,
+        guildId: message.guildId,
+        mentionedUserIds,
+        raw: message.toJSON(),
+      })
+
+      if (result.skip) {
+        this.logger.info("discord skip", { reason: "bot author" })
+        return
+      }
+
+      try {
+        await notify(result.content, result.meta)
+      } catch (error) {
+        this.logger.error("discord notify error", {
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    })
+
+    client.on("ready", (readyClient) => {
+      this.logger.info("discord ready", {
+        userId: readyClient.user.id,
+        tag: readyClient.user.tag,
+        guilds: String(readyClient.guilds.cache.size),
+      })
+    })
+
+    client.on("error", (error) => {
+      this.logger.error("discord client error", {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    })
+
+    await client.login(this.config.botToken)
+    this.client = client
+  }
+
+  async stop(): Promise<void> {
+    if (!this.client) return
+
+    try {
+      await this.client.destroy()
+    } catch (error) {
+      this.logger.error("discord stop error", {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    } finally {
+      this.client = null
+    }
+  }
+
+  override isAlive(): boolean {
+    return this.client !== null
+  }
+}

package/lib/{modules/connectors/funnel-gh-adapter.ts → connectors/gh-adapter.ts}

@@ -1,9 +1,6 @@
-import {
-  FunnelConnectorAdapter,
-  type CallInput,
-} from "@/modules/connectors/funnel-connector-adapter"
-import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
-import { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-process-runner"
+import { FunnelConnectorAdapter, type CallInput } from "@/connectors/connector-adapter"
+import { FunnelProcessRunner } from "@/engine/process/process-runner"
+import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
 
 type Deps = {
   process?: FunnelProcessRunner

package/lib/{modules/connectors → connectors}/gh-connector-schema.ts

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