@interactive-inc/claude-funnel 0.10.0 → 0.15.1

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

@@ -1,36 +0,0 @@
-import { HTTPException } from "hono/http-exception"
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { queryToCliArgs } from "@/cli/router/query-to-cli-args"
-import { zValidator } from "@/cli/router/validator"
-
-export const launchHelp = `funnel profiles <name> run — launch a profile (sugar for fnl claude)
-
-usage: funnel profiles <name> run [additional claude args...]
-       funnel profiles <name>     (alias)`
-
-const RESERVED_KEYS: string[] = []
-
-export const profilesLaunchHandler = factory.createHandlers(
-  zValidator("param", z.object({ profile: z.string() })),
-  zValidator("query", z.object({}).passthrough(), launchHelp),
-  async (c) => {
-    const param = c.req.valid("param")
-    const funnel = c.var.funnel
-    const profile = funnel.profiles.get(param.profile)
-
-    if (!profile) {
-      throw new HTTPException(404, { message: `profile "${param.profile}" not found` })
-    }
-
-    const exitCode = await funnel.claude.launch({
-      channel: profile.channelId,
-      cwd: profile.path,
-      subAgent: profile.subAgent,
-      userArgs: queryToCliArgs(c.req.url, RESERVED_KEYS),
-      profileName: profile.name,
-    })
-
-    process.exit(exitCode)
-  },
-)

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

@@ -1,49 +0,0 @@
-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> [--brief]
-
-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)
-  --brief       forward --brief to claude on launch (enables SendUserMessage tool)`
-
-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(),
-      brief: z.coerce.boolean().optional(),
-    }),
-    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,
-      ...(query.brief !== undefined ? { brief: query.brief } : {}),
-    })
-
-    return c.text(`added profile "${param.profile}"`)
-  },
-)

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

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

@@ -1,45 +0,0 @@
-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>] [--brief | --no-brief]`
-
-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(),
-      brief: z.coerce.boolean().optional(),
-      "no-brief": z.coerce.boolean().optional(),
-    }),
-    setHelp,
-  ),
-  (c) => {
-    const param = c.req.valid("param")
-    const query = c.req.valid("query")
-    const funnel = c.var.funnel
-
-    const channel = query.channel !== undefined ? funnel.channels.get(query.channel) : null
-
-    if (query.channel !== undefined && !channel) {
-      throw new HTTPException(400, { message: `channel "${query.channel}" not found` })
-    }
-
-    const brief = query["no-brief"] ? false : query.brief
-
-    funnel.profiles.update(param.profile, {
-      path: query.path,
-      subAgent: query["sub-agent"],
-      channelId: channel?.id,
-      ...(brief !== undefined ? { brief } : {}),
-    })
-
-    return c.text(`updated profile "${param.profile}"`)
-  },
-)

package/lib/cli/routes/profiles.ts

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

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

@@ -1,27 +0,0 @@
-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-adapter.ts

@@ -1,9 +0,0 @@
-export type CallInput = {
-  method: string
-  path: string
-  body?: unknown
-}
-
-export abstract class FunnelConnectorAdapter {
-  abstract call(input: CallInput): Promise<unknown>
-}

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

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

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

@@ -1,20 +0,0 @@
-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/connectors/discord-adapter.ts

@@ -1,51 +0,0 @@
-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"
-
-type Deps = {
-  config: DiscordConnectorConfig
-  http?: FunnelHttpClient
-}
-
-const defaultHttp = new NodeFunnelHttpClient()
-
-export class FunnelDiscordAdapter extends FunnelConnectorAdapter {
-  private readonly token: string
-  private readonly http: FunnelHttpClient
-
-  constructor(deps: Deps) {
-    super()
-    this.token = deps.config.botToken
-    this.http = deps.http ?? defaultHttp
-    Object.freeze(this)
-  }
-
-  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 =
-      body !== null && typeof body === "object" && method !== "GET" && Object.keys(body).length > 0
-
-    const res = await this.http.fetch({
-      method,
-      url: `${DISCORD_API_BASE}${path}`,
-      headers: {
-        Authorization: `Bot ${this.token}`,
-        "Content-Type": "application/json",
-      },
-      body: hasBody ? JSON.stringify(input.body) : undefined,
-    })
-
-    if (!res.ok) {
-      throw new Error(`Discord API failed (${res.status}): ${await res.text()}`)
-    }
-
-    if (res.status === 204) return null
-
-    return await res.json()
-  }
-}

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

@@ -1,12 +0,0 @@
-import { z } from "zod"
-
-export const discordConnectorSchema = z.object({
-  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-event-processor.ts

@@ -1,48 +0,0 @@
-export type DiscordInboundMessage = {
-  authorId: string
-  authorIsBot: boolean
-  channelId: string
-  guildId: string | null
-  mentionedUserIds: string[]
-  raw: unknown
-}
-
-export type DiscordProcessedSkip = { skip: true }
-
-export type DiscordProcessedEmit = {
-  skip: false
-  content: string
-  meta: Record<string, string>
-}
-
-export type DiscordProcessed = DiscordProcessedSkip | DiscordProcessedEmit
-
-type Props = {
-  ownUserId: string
-}
-
-export class FunnelDiscordEventProcessor {
-  private readonly ownUserId: string
-
-  constructor(props: Props) {
-    this.ownUserId = props.ownUserId
-  }
-
-  process(message: DiscordInboundMessage): DiscordProcessed {
-    if (message.authorIsBot) return { skip: true }
-
-    const mentioned = this.ownUserId ? message.mentionedUserIds.includes(this.ownUserId) : false
-
-    return {
-      skip: false,
-      content: JSON.stringify(message.raw),
-      meta: {
-        event_type: "discord",
-        channel_id: message.channelId,
-        user_id: message.authorId,
-        mentioned: String(mentioned),
-        guild_id: message.guildId ?? "",
-      },
-    }
-  }
-}

package/lib/connectors/discord-listener.ts

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