@interactive-inc/claude-funnel 0.10.0 → 0.15.1

package/lib/cli/routes/channels.$channel.connectors.$connector.request.ts

@@ -1,40 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-
-export const requestHelp = `funnel channels <channel> connectors <connector> request — call a connector's outbound API
-
-usage: funnel channels <channel> connectors <connector> request --method=<api.method> [--key=value ...]`
-
-export const channelsConnectorsRequestHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string(), connector: z.string() })),
-  zValidator(
-    "query",
-    z
-      .object({
-        method: z.string(),
-      })
-      .passthrough(),
-    requestHelp,
-  ),
-  async (c) => {
-    const param = c.req.valid("param")
-    const query = c.req.valid("query")
-    const funnel = c.var.funnel
-
-    const passthrough: Record<string, string> = {}
-
-    for (const [k, v] of new URL(c.req.url).searchParams) {
-      if (k === "method") continue
-      passthrough[k] = v
-    }
-
-    const response = await funnel.channels.call(param.channel, param.connector, {
-      method: query.method,
-      path: query.method,
-      body: passthrough,
-    })
-
-    return c.text(typeof response === "string" ? response : JSON.stringify(response, null, 2))
-  },
-)

package/lib/cli/routes/channels.$channel.connectors.$connector.schedules.add.$id.ts

@@ -1,41 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-import { scheduleCatchupPolicySchema } from "@/connectors/schedule-connector-schema"
-
-export const addHelp = `funnel channels <ch> connectors <conn> schedules add <id> — add a schedule entry
-
-usage: funnel channels <ch> connectors <conn> schedules add <id> --cron="*/5 * * * *" --prompt="..." [--enabled=true] [--catchup-policy=latest|all|skip]`
-
-export const channelsConnectorsSchedulesAddHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string(), connector: z.string(), id: z.string() })),
-  zValidator(
-    "query",
-    z.object({
-      cron: z.string(),
-      prompt: z.string(),
-      enabled: z.coerce.boolean().optional(),
-      "catchup-policy": scheduleCatchupPolicySchema.optional(),
-    }),
-    addHelp,
-  ),
-  async (c) => {
-    const param = c.req.valid("param")
-    const query = c.req.valid("query")
-    const funnel = c.var.funnel
-
-    const entry = funnel.channels.addScheduleEntry(param.channel, param.connector, {
-      id: param.id,
-      cron: query.cron,
-      prompt: query.prompt,
-      ...(query.enabled !== undefined ? { enabled: query.enabled } : {}),
-      ...(query["catchup-policy"] !== undefined
-        ? { catchupPolicy: query["catchup-policy"] }
-        : {}),
-    })
-
-    await funnel.listeners.restart(param.channel, param.connector)
-
-    return c.text(`added schedule entry "${entry.id}"`)
-  },
-)

package/lib/cli/routes/channels.$channel.connectors.$connector.schedules.remove.$id.ts

@@ -1,22 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-
-export const removeHelp = `funnel channels <ch> connectors <conn> schedules remove <id>
-
-usage: funnel channels <ch> connectors <conn> schedules remove <id>`
-
-export const channelsConnectorsSchedulesRemoveHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string(), connector: z.string(), id: z.string() })),
-  zValidator("query", z.object({}), removeHelp),
-  async (c) => {
-    const param = c.req.valid("param")
-    const funnel = c.var.funnel
-
-    funnel.channels.removeScheduleEntry(param.channel, param.connector, param.id)
-
-    await funnel.listeners.restart(param.channel, param.connector)
-
-    return c.text(`removed schedule entry "${param.id}"`)
-  },
-)

package/lib/cli/routes/channels.$channel.connectors.$connector.schedules.ts

@@ -1,23 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-
-export const groupHelp = `funnel channels <ch> connectors <conn> schedules — list schedule entries
-
-usage: funnel channels <ch> connectors <conn> schedules`
-
-export const channelsConnectorsSchedulesGroupHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string(), connector: z.string() })),
-  zValidator("query", z.object({}), groupHelp),
-  (c) => {
-    const param = c.req.valid("param")
-    const funnel = c.var.funnel
-    const entries = funnel.channels.listScheduleEntries(param.channel, param.connector)
-
-    if (entries.length === 0) return c.text("no schedule entries")
-
-    return c.text(
-      entries.map((e) => `${e.id}\t${e.cron}\t${e.enabled ? "on" : "off"}\t${e.prompt}`).join("\n"),
-    )
-  },
-)

package/lib/cli/routes/channels.$channel.connectors.$connector.ts

@@ -1,26 +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 showHelp = `funnel channels <channel> connectors show <connector> — show connector config
-
-usage: funnel channels <channel> connectors show <connector>`
-
-export const channelsConnectorsShowHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string(), connector: z.string() })),
-  zValidator("query", z.object({}), showHelp),
-  (c) => {
-    const param = c.req.valid("param")
-    const funnel = c.var.funnel
-    const connector = funnel.channels.getConnector(param.channel, param.connector)
-
-    if (!connector) {
-      throw new HTTPException(404, {
-        message: `connector "${param.connector}" not found in channel "${param.channel}"`,
-      })
-    }
-
-    return c.text(JSON.stringify(connector, null, 2))
-  },
-)

package/lib/cli/routes/channels.$channel.connectors.add.$connector.ts

@@ -1,92 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-
-export const addHelp = `funnel channels <channel> connectors add <connector> — add a connector to a channel
-
-usage:
-  funnel channels <channel> connectors add <connector> --type=slack --bot-token=xoxb-... --app-token=xapp-...
-  funnel channels <channel> connectors add <connector> --type=gh [--poll-interval=60]
-  funnel channels <channel> connectors add <connector> --type=discord --bot-token=...
-  funnel channels <channel> connectors add <connector> --type=schedule
-
-Token uniqueness is enforced across all channels.`
-
-const slackBody = z.object({
-  type: z.literal("slack"),
-  "bot-token": z.string().startsWith("xoxb-"),
-  "app-token": z.string().startsWith("xapp-"),
-})
-
-const ghBody = z.object({
-  type: z.literal("gh"),
-  "poll-interval": z.coerce.number().int().positive().optional(),
-})
-
-const discordBody = z.object({
-  type: z.literal("discord"),
-  "bot-token": z.string().min(10),
-})
-
-const scheduleBody = z.object({
-  type: z.literal("schedule"),
-})
-
-const addBody = z.discriminatedUnion("type", [slackBody, ghBody, discordBody, scheduleBody])
-
-export const channelsConnectorsAddHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string(), connector: z.string() })),
-  zValidator("query", addBody, addHelp),
-  async (c) => {
-    const param = c.req.valid("param")
-    const query = c.req.valid("query")
-    const funnel = c.var.funnel
-
-    if (query.type === "slack") {
-      const created = funnel.channels.addConnector(param.channel, {
-        type: "slack",
-        name: param.connector,
-        botToken: query["bot-token"],
-        appToken: query["app-token"],
-      })
-
-      await funnel.listeners.start(param.channel, created.name)
-
-      return c.text(`added slack connector "${created.name}" to channel "${param.channel}"`)
-    }
-
-    if (query.type === "gh") {
-      const created = funnel.channels.addConnector(param.channel, {
-        type: "gh",
-        name: param.connector,
-        ...(query["poll-interval"] !== undefined ? { pollInterval: query["poll-interval"] } : {}),
-      })
-
-      await funnel.listeners.start(param.channel, created.name)
-
-      return c.text(`added gh connector "${created.name}" to channel "${param.channel}"`)
-    }
-
-    if (query.type === "discord") {
-      const created = funnel.channels.addConnector(param.channel, {
-        type: "discord",
-        name: param.connector,
-        botToken: query["bot-token"],
-      })
-
-      await funnel.listeners.start(param.channel, created.name)
-
-      return c.text(`added discord connector "${created.name}" to channel "${param.channel}"`)
-    }
-
-    const created = funnel.channels.addConnector(param.channel, {
-      type: "schedule",
-      name: param.connector,
-      entries: [],
-    })
-
-    await funnel.listeners.start(param.channel, created.name)
-
-    return c.text(`added schedule connector "${created.name}" to channel "${param.channel}"`)
-  },
-)

package/lib/cli/routes/channels.$channel.connectors.remove.$connector.ts

@@ -1,22 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-
-export const removeHelp = `funnel channels <channel> connectors remove <connector> — remove a connector
-
-usage: funnel channels <channel> connectors remove <connector>`
-
-export const channelsConnectorsRemoveHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string(), connector: z.string() })),
-  zValidator("query", z.object({}), removeHelp),
-  async (c) => {
-    const param = c.req.valid("param")
-    const funnel = c.var.funnel
-
-    await funnel.listeners.stop(param.channel, param.connector)
-
-    funnel.channels.removeConnector(param.channel, param.connector)
-
-    return c.text(`removed connector "${param.connector}" from channel "${param.channel}"`)
-  },
-)

package/lib/cli/routes/channels.$channel.connectors.set.$connector.ts

@@ -1,63 +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 channels <channel> connectors set <connector> — update connector fields
-
-usage:
-  funnel channels <ch> connectors set <conn> [--bot-token=...] [--app-token=...]   # slack
-  funnel channels <ch> connectors set <conn> [--bot-token=...]                    # discord
-  funnel channels <ch> connectors set <conn> [--poll-interval=N]                  # gh`
-
-export const channelsConnectorsSetHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string(), connector: z.string() })),
-  zValidator(
-    "query",
-    z
-      .object({
-        "bot-token": z.string().optional(),
-        "app-token": z.string().optional(),
-        "poll-interval": z.coerce.number().int().positive().optional(),
-      })
-      .passthrough(),
-    setHelp,
-  ),
-  async (c) => {
-    const param = c.req.valid("param")
-    const query = c.req.valid("query")
-    const funnel = c.var.funnel
-    const existing = funnel.channels.getConnector(param.channel, param.connector)
-
-    if (!existing) {
-      throw new HTTPException(404, {
-        message: `connector "${param.connector}" not found in channel "${param.channel}"`,
-      })
-    }
-
-    if (existing.type === "slack") {
-      funnel.channels.updateSlackConnector(param.channel, param.connector, {
-        ...(query["bot-token"] !== undefined ? { botToken: query["bot-token"] } : {}),
-        ...(query["app-token"] !== undefined ? { appToken: query["app-token"] } : {}),
-      })
-    } else if (existing.type === "discord") {
-      funnel.channels.updateDiscordConnector(
-        param.channel,
-        param.connector,
-        query["bot-token"] !== undefined ? { botToken: query["bot-token"] } : {},
-      )
-    } else if (existing.type === "gh") {
-      funnel.channels.updateGhConnector(
-        param.channel,
-        param.connector,
-        query["poll-interval"] !== undefined ? { pollInterval: query["poll-interval"] } : {},
-      )
-    } else {
-      throw new HTTPException(400, { message: "schedule connectors have no settable fields" })
-    }
-
-    await funnel.listeners.restart(param.channel, param.connector)
-
-    return c.text(`updated connector "${param.connector}" in channel "${param.channel}"`)
-  },
-)

package/lib/cli/routes/channels.$channel.connectors.ts

@@ -1,26 +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 groupHelp = `funnel channels <channel> connectors — list connectors in a channel
-
-usage: funnel channels <channel> connectors`
-
-export const channelsConnectorsGroupHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string() })),
-  zValidator("query", z.object({}), groupHelp),
-  (c) => {
-    const param = c.req.valid("param")
-    const funnel = c.var.funnel
-    const channel = funnel.channels.get(param.channel)
-
-    if (!channel) {
-      throw new HTTPException(404, { message: `channel "${param.channel}" not found` })
-    }
-
-    if (channel.connectors.length === 0) return c.text(`no connectors in channel "${channel.name}"`)
-
-    return c.text(channel.connectors.map((c) => `${c.name} (${c.type}, id: ${c.id})`).join("\n"))
-  },
-)

package/lib/cli/routes/channels.$channel.publish.ts

@@ -1,52 +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 publishHelp = `funnel channels <channel> publish — push arbitrary content into a channel
-
-usage: funnel channels <channel> publish --content="<text>" [--connector=<name>] [--meta-<key>=<value> ...]
-
-options:
-  --content       Required. The event body delivered to subscribers.
-  --connector     Optional. Stamp the event with a connector name (resolved to id when found).
-  --meta-<key>    Optional. Repeatable. Added to meta. Example: --meta-source=cron`
-
-const querySchema = z
-  .object({
-    content: z.string().min(1, { message: "--content is required" }),
-    connector: z.string().min(1).optional(),
-  })
-  .passthrough()
-
-export const channelsPublishHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string() })),
-  zValidator("query", querySchema, publishHelp),
-  async (c) => {
-    const param = c.req.valid("param")
-    const query = c.req.valid("query")
-    const funnel = c.var.funnel
-
-    const meta: Record<string, string> = {}
-
-    for (const [k, v] of new URL(c.req.url).searchParams) {
-      if (k.startsWith("meta-")) meta[k.slice("meta-".length)] = v
-    }
-
-    const result = await funnel.publisher.publish(param.channel, {
-      content: query.content,
-      connector: query.connector,
-      meta: Object.keys(meta).length > 0 ? meta : undefined,
-    })
-
-    if (result.state === "offline") {
-      throw new HTTPException(503, { message: "gateway daemon is not running — start it with `fnl gateway start`" })
-    }
-
-    if (result.state === "error") {
-      throw new HTTPException(502, { message: result.reason })
-    }
-
-    return c.text(`published (offset=${result.offset})`)
-  },
-)

package/lib/cli/routes/channels.$channel.rename.$newName.ts

@@ -1,22 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-
-export const renameHelp = `funnel channels rename — rename a channel
-
-usage:
-  funnel channels rename <old> <new>
-  funnel channels <old> rename <new>`
-
-export const channelsRenameHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string(), newName: z.string() })),
-  zValidator("query", z.object({}), renameHelp),
-  (c) => {
-    const param = c.req.valid("param")
-    const funnel = c.var.funnel
-
-    funnel.channels.rename(param.channel, param.newName)
-
-    return c.text(`renamed channel "${param.channel}" to "${param.newName}"`)
-  },
-)

package/lib/cli/routes/channels.$channel.set.delivery.$mode.ts

@@ -1,34 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-import { channelDeliveryModeSchema } from "@/engine/settings/settings-schema"
-
-export const setDeliveryHelp = `funnel channels <name> set delivery <mode> — change a channel's routing mode
-
-usage: funnel channels <name> set delivery fanout | exclusive
-
-modes:
-  fanout      every connected WS client receives every event (default)
-  exclusive   each event is delivered to exactly one connected client (round-robin)
-
-tap=all clients (TUI dashboard, debugging) always receive regardless of mode.
-`
-
-export const channelsSetDeliveryHandler = factory.createHandlers(
-  zValidator(
-    "param",
-    z.object({
-      channel: z.string(),
-      mode: channelDeliveryModeSchema,
-    }),
-    setDeliveryHelp,
-  ),
-  (c) => {
-    const param = c.req.valid("param")
-    const funnel = c.var.funnel
-
-    funnel.channels.setDelivery(param.channel, param.mode)
-
-    return c.text(`channel "${param.channel}" delivery set to ${param.mode}`)
-  },
-)

package/lib/cli/routes/channels.$channel.ts

@@ -1,34 +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 showHelp = `funnel channels <name> — show channel details`
-
-export const channelsShowHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string() })),
-  zValidator("query", z.object({}), showHelp),
-  (c) => {
-    const param = c.req.valid("param")
-    const funnel = c.var.funnel
-    const channel = funnel.channels.get(param.channel)
-
-    if (!channel) {
-      throw new HTTPException(404, { message: `channel "${param.channel}" not found` })
-    }
-
-    const connectorLines = channel.connectors.length
-      ? channel.connectors.map((c) => `  - ${c.name} (${c.type}, id: ${c.id})`)
-      : ["  (none)"]
-
-    const lines = [
-      `id: ${channel.id}`,
-      `name: ${channel.name}`,
-      `delivery: ${channel.delivery}`,
-      `connectors:`,
-      ...connectorLines,
-    ]
-
-    return c.text(lines.join("\n"))
-  },
-)

package/lib/cli/routes/channels.add.$channel.ts

@@ -1,33 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-import { channelDeliveryModeSchema } from "@/engine/settings/settings-schema"
-
-export const addHelp = `funnel channels add — add a channel
-
-usage: funnel channels add <name> [--delivery fanout|exclusive]
-
-options:
-  --delivery    routing mode (default fanout):
-                  fanout      every connected client receives every event
-                  exclusive   each event delivered to exactly one client (round-robin)`
-
-export const channelsAddHandler = factory.createHandlers(
-  zValidator("param", z.object({ channel: z.string() })),
-  zValidator(
-    "query",
-    z.object({
-      delivery: channelDeliveryModeSchema.optional(),
-    }),
-    addHelp,
-  ),
-  (c) => {
-    const param = c.req.valid("param")
-    const query = c.req.valid("query")
-    const funnel = c.var.funnel
-
-    const created = funnel.channels.add({ name: param.channel, delivery: query.delivery })
-
-    return c.text(`added channel "${created.name}" (id: ${created.id})`)
-  },
-)

package/lib/cli/routes/channels.remove.$channel.ts

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

package/lib/cli/routes/channels.ts

@@ -1,39 +0,0 @@
-import { z } from "zod"
-import { factory } from "@/cli/factory"
-import { zValidator } from "@/cli/router/validator"
-
-export const groupHelp = `funnel channels — manage subscription boxes
-
-usage: funnel channels [subcommand]
-
-subcommands:
-  (none)                          list
-  add <name>                      add
-  remove <name>                   remove
-  <name>                          show details
-  <name> connectors                       list connectors
-  <name> connectors add <c> --type=...    add a connector
-
-examples:
-  funnel channels add prod-inbox
-  funnel channels prod-inbox connectors add prod-slack --type=slack --bot-token=xoxb-... --app-token=xapp-...
-  funnel channels prod-inbox`
-
-export const channelsGroupHandler = factory.createHandlers(
-  zValidator("query", z.object({}), groupHelp),
-  (c) => {
-    const funnel = c.var.funnel
-    const channels = funnel.channels.list()
-
-    if (channels.length === 0) return c.text("no channels")
-
-    const lines = channels.map((ch) => {
-      const names = ch.connectors.map((c) => c.name)
-      const connectors = names.length > 0 ? names.join(", ") : "(none)"
-
-      return `${ch.name} [${connectors}]`
-    })
-
-    return c.text(lines.join("\n"))
-  },
-)

package/lib/cli/routes/claude.ts

@@ -1,70 +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 claudeHelp = `funnel claude — launch Claude Code
-
-usage:
-  funnel claude                          launch the default profile (first in the list)
-  funnel claude -p <name>                launch a named profile
-  funnel claude --profile <name>         (long form)
-  funnel claude --channel <name>         raw launch (no profile, cwd = current dir)
-
-options:
-  -p, --profile      profile name to launch
-  --channel          channel name (raw launch, ignored when --profile is given)
-
-Any other arguments are forwarded to the claude CLI.
-On launch the FUNNEL_CHANNEL_ID env var is set and MCP connects to the gateway.`
-
-const RESERVED_KEYS = ["profile", "channel"]
-
-export const claudeHandler = factory.createHandlers(
-  zValidator(
-    "query",
-    z
-      .object({
-        profile: z.string().optional(),
-        channel: z.string().optional(),
-      })
-      .passthrough(),
-    claudeHelp,
-  ),
-  async (c) => {
-    const query = c.req.valid("query")
-    const funnel = c.var.funnel
-
-    if (query.channel && !query.profile) {
-      const exitCode = await funnel.claude.launch({
-        channel: query.channel,
-        userArgs: queryToCliArgs(c.req.url, RESERVED_KEYS),
-      })
-
-      process.exit(exitCode)
-    }
-
-    const profile = query.profile
-      ? funnel.profiles.get(query.profile)
-      : funnel.profiles.getDefault()
-
-    if (!profile) {
-      if (query.profile) {
-        throw new HTTPException(404, { message: `profile "${query.profile}" not found` })
-      }
-      return c.text(claudeHelp)
-    }
-
-    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,
-      brief: profile.brief,
-    })
-
-    process.exit(exitCode)
-  },
-)