@interactive-inc/claude-funnel 0.2.0 → 0.4.0

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

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

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

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

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

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

@@ -46,8 +46,8 @@ export class FunnelRepositories {
 
     if (index < 0) throw new Error(`repo "${name}" not found`)
 
-    if (settings.agents.some((a) => a.repo === name)) {
-      throw new Error(`repo "${name}" is referenced by an agent`)
+    if (settings.profiles.some((p) => p.repo === name)) {
+      throw new Error(`repo "${name}" is referenced by a profile`)
     }
 
     const repo = settings.repositories[index]!
@@ -72,8 +72,8 @@ export class FunnelRepositories {
 
     repo.name = newName
 
-    for (const agent of settings.agents) {
-      if (agent.repo === oldName) agent.repo = newName
+    for (const profile of settings.profiles) {
+      if (profile.repo === oldName) profile.repo = newName
     }
 
     this.store.write(settings)

package/lib/modules/router/to-request.ts

@@ -7,7 +7,6 @@ const STRIPPED_METHOD_KEYWORDS: Record<string, string> = {
   add: "POST",
   remove: "DELETE",
   set: "PUT",
-  update: "PUT",
 }
 
 const KEPT_METHOD_KEYWORDS: Record<string, string> = {
@@ -24,8 +23,6 @@ const isValue = (arg: string | undefined): arg is string => {
 }
 
 const consumeApiCall = (args: string[], i: number, params: URLSearchParams): number => {
-  params.set("method", args[i]!)
-
   const nextPath = args[i + 1]
 
   if (!isValue(nextPath)) return 1
@@ -99,8 +96,8 @@ export const toRequest = (args: string[]) => {
       continue
     }
 
-    if (API_CALL_METHODS.has(arg) && !params.has("method")) {
-      segments.push("call")
+    if (API_CALL_METHODS.has(arg) && !params.has("path")) {
+      segments.push(arg)
       i += consumeApiCall(args, i, params)
       continue
     }

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

@@ -0,0 +1,34 @@
+import type { FunnelScheduleStore } from "@/modules/connectors/funnel-schedule-store"
+import type { ScheduleEntry } from "@/modules/connectors/schedule-connector-schema"
+
+type Deps = {
+  store: FunnelScheduleStore
+}
+
+export class FunnelSchedule {
+  private readonly store: FunnelScheduleStore
+
+  constructor(deps: Deps) {
+    this.store = deps.store
+    Object.freeze(this)
+  }
+
+  listEntries(connector: string): ScheduleEntry[] {
+    const config = this.store.get(connector)
+
+    if (!config) throw new Error(`connector "${connector}" not found`)
+
+    return config.entries
+  }
+
+  addEntry(
+    connector: string,
+    entry: Omit<ScheduleEntry, "id"> & { id?: string },
+  ): ScheduleEntry {
+    return this.store.addEntry(connector, entry)
+  }
+
+  removeEntry(connector: string, id: string): void {
+    this.store.removeEntry(connector, id)
+  }
+}

package/lib/modules/settings/funnel-settings-store.ts

@@ -30,10 +30,9 @@ export class FunnelSettingsStore extends FunnelSettingsReader {
   read(): Settings {
     if (!this.fs.existsSync(this.path)) {
       return {
-        connectors: [],
         channels: [],
         repositories: [],
-        agents: [],
+        profiles: [],
       }
     }
 

package/lib/modules/settings/mock-funnel-settings-reader.ts

@@ -2,10 +2,9 @@ import { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
 import type { Settings } from "@/modules/settings/settings-schema"
 
 export const createSettings = (partial: Partial<Settings> = {}): Settings => ({
-  connectors: [],
   channels: [],
   repositories: [],
-  agents: [],
+  profiles: [],
   ...partial,
 })
 

package/lib/modules/settings/settings-schema.ts

@@ -1,38 +1,5 @@
 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>
-
-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>
-
-export const discordConnectorSchema = z.object({
-  type: z.literal("discord"),
-  name: z.string(),
-  botToken: z.string().min(10),
-})
-
-export type DiscordConnectorConfig = z.infer<typeof discordConnectorSchema>
-
-export const connectorConfigSchema = z.discriminatedUnion("type", [
-  slackConnectorSchema,
-  ghConnectorSchema,
-  discordConnectorSchema,
-])
-
-export type ConnectorConfig = z.infer<typeof connectorConfigSchema>
-
 export const channelConfigSchema = z.object({
   name: z.string(),
   connectors: z.array(z.string()).default([]),
@@ -47,7 +14,7 @@ export const repositoryConfigSchema = z.object({
 
 export type RepositoryConfig = z.infer<typeof repositoryConfigSchema>
 
-export const agentConfigSchema = z.object({
+export const profileConfigSchema = z.object({
   name: z.string(),
   channel: z.string(),
   repo: z.string().optional(),
@@ -55,13 +22,12 @@ export const agentConfigSchema = z.object({
   envFiles: z.array(z.string()).optional(),
 })
 
-export type AgentConfig = z.infer<typeof agentConfigSchema>
+export type ProfileConfig = z.infer<typeof profileConfigSchema>
 
 export const settingsSchema = z.object({
-  connectors: z.array(connectorConfigSchema).default([]),
   channels: z.array(channelConfigSchema).default([]),
   repositories: z.array(repositoryConfigSchema).default([]),
-  agents: z.array(agentConfigSchema).default([]),
+  profiles: z.array(profileConfigSchema).default([]),
 })
 
 export type Settings = z.infer<typeof settingsSchema>

package/lib/routes/claude/claude.help.ts

@@ -1,11 +1,16 @@
 export const help = `funnel claude — launch Claude Code
 
-usage: funnel claude --channel <name> [--repo <name>] [--sub-agent <name>] [--env-file <file>] [additional claude args...]
+usage:
+  funnel claude                          launch "default" profile (or the first profile)
+  funnel claude --profile <name>         launch a named profile
+  funnel claude --channel <name> [opts]  raw launch (no profile)
 
-options:
-  --channel        channel name to subscribe to (required)
-  --repo           switch working directory to the named repo (extra)
+options (override profile / raw):
+  --profile        profile name to launch
+  --channel        channel name to subscribe to
+  --repo           switch working directory to the named repo
   --sub-agent      sub-agent name (passed to claude --agent)
   --env-file       additional env file to load (relative path)
 
+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.`

package/lib/routes/claude/claude.ts

@@ -1,16 +1,20 @@
+import { HTTPException } from "hono/http-exception"
 import { z } from "zod"
 import { factory } from "@/factory"
 import { queryToCliArgs } from "@/modules/router/query-to-cli-args"
 import { zValidator } from "@/modules/router/validator"
 import { help } from "@/routes/claude/claude.help"
 
-const RESERVED_KEYS = ["channel", "repo", "sub-agent", "env-file"]
+const RESERVED_KEYS = ["profile", "channel", "repo", "sub-agent", "env-file"]
+
+const DEFAULT_PROFILE_NAME = "default"
 
 export const claudeHandler = factory.createHandlers(
   zValidator(
     "query",
     z
       .object({
+        profile: z.string().optional(),
         channel: z.string().optional(),
         repo: z.string().optional(),
         "sub-agent": z.string().optional(),
@@ -21,17 +25,50 @@ export const claudeHandler = factory.createHandlers(
   ),
   async (c) => {
     const query = c.req.valid("query")
+    const funnel = c.var.funnel
 
-    if (!query.channel) return c.text(help)
+    if (query.profile) {
+      const profile = funnel.profiles.get(query.profile)
 
-    const funnel = c.var.funnel
+      if (!profile) {
+        throw new HTTPException(404, { message: `profile "${query.profile}" not found` })
+      }
+
+      const exitCode = await funnel.claude.launch({
+        channel: query.channel ?? profile.channel,
+        repo: query.repo ?? profile.repo,
+        subAgent: query["sub-agent"] ?? profile.subAgent,
+        envFiles: query["env-file"] ? [query["env-file"]] : profile.envFiles,
+        userArgs: queryToCliArgs(c.req.url, RESERVED_KEYS),
+        profileName: profile.name,
+      })
+
+      process.exit(exitCode)
+    }
+
+    if (query.channel) {
+      const exitCode = await funnel.claude.launch({
+        channel: query.channel,
+        repo: query.repo,
+        subAgent: query["sub-agent"],
+        envFiles: query["env-file"] ? [query["env-file"]] : undefined,
+        userArgs: queryToCliArgs(c.req.url, RESERVED_KEYS),
+      })
+
+      process.exit(exitCode)
+    }
+
+    const defaultProfile = funnel.profiles.get(DEFAULT_PROFILE_NAME) ?? funnel.profiles.list()[0]
+
+    if (!defaultProfile) return c.text(help)
 
     const exitCode = await funnel.claude.launch({
-      channel: query.channel,
-      repo: query.repo,
-      subAgent: query["sub-agent"],
-      envFiles: query["env-file"] ? [query["env-file"]] : undefined,
+      channel: defaultProfile.channel,
+      repo: query.repo ?? defaultProfile.repo,
+      subAgent: query["sub-agent"] ?? defaultProfile.subAgent,
+      envFiles: query["env-file"] ? [query["env-file"]] : defaultProfile.envFiles,
       userArgs: queryToCliArgs(c.req.url, RESERVED_KEYS),
+      profileName: defaultProfile.name,
     })
 
     process.exit(exitCode)

package/lib/routes/connectors/add.help.ts

@@ -1,9 +1,10 @@
 export const help = `funnel connectors add — add a connector
 
 usage:
-  funnel connectors add <name> --type slack   --bot-token xoxb-... --app-token xapp-...
-  funnel connectors add <name> --type gh      [--poll-interval <seconds>]
-  funnel connectors add <name> --type discord --bot-token <discord-bot-token>
+  funnel connectors add <name> --type slack    --bot-token xoxb-... --app-token xapp-...
+  funnel connectors add <name> --type gh       [--poll-interval <seconds>]
+  funnel connectors add <name> --type discord  --bot-token <discord-bot-token>
+  funnel connectors add <name> --type schedule
 
 slack (Socket Mode):
   --bot-token             Slack Bot Token (starts with xoxb-)
@@ -16,7 +17,12 @@ gh (GitHub, gh CLI):
 discord (Discord Gateway):
   --bot-token             Discord Bot Token
 
+schedule (cron-driven prompts):
+  no extra flags at connector level — add entries with:
+    funnel connectors <name> schedules add --cron "* * * * *" --prompt "..."
+
 examples:
   funnel connectors add prod-slack --type slack --bot-token xoxb-... --app-token xapp-...
   funnel connectors add my-gh --type gh --poll-interval 30
-  funnel connectors add my-discord --type discord --bot-token MTI...`
+  funnel connectors add my-discord --type discord --bot-token MTI...
+  funnel connectors add my-cron --type schedule`

package/lib/routes/connectors/add.ts

@@ -21,6 +21,9 @@ export const connectorsAddHandler = factory.createHandlers(
         type: z.literal("discord"),
         "bot-token": z.string().min(10),
       }),
+      z.object({
+        type: z.literal("schedule"),
+      }),
     ]),
     help,
   ),
@@ -42,12 +45,18 @@ export const connectorsAddHandler = factory.createHandlers(
         name: param.name,
         pollInterval: query["poll-interval"] ? Number(query["poll-interval"]) : undefined,
       })
-    } else {
+    } else if (query.type === "discord") {
       funnel.connectors.add({
         type: "discord",
         name: param.name,
         botToken: query["bot-token"],
       })
+    } else {
+      funnel.connectors.add({
+        type: "schedule",
+        name: param.name,
+        entries: [],
+      })
     }
 
     return c.text(`added connector "${param.name}"`)

package/lib/routes/connectors/routes.ts

@@ -1,18 +1,22 @@
 import { factory } from "@/factory"
 import { connectorsAddHandler } from "@/routes/connectors/add"
-import { connectorsCallHandler } from "@/routes/connectors/call"
 import { connectorsGroupHandler } from "@/routes/connectors/group"
 import { connectorsRemoveHandler } from "@/routes/connectors/remove"
 import { connectorsRenameHandler } from "@/routes/connectors/rename"
+import { connectorsSchedulesAddHandler } from "@/routes/connectors/schedules-add"
+import { connectorsSchedulesGroupHandler } from "@/routes/connectors/schedules-group"
+import { connectorsSchedulesRemoveHandler } from "@/routes/connectors/schedules-remove"
 import { connectorsSetHandler } from "@/routes/connectors/set"
 import { connectorsShowHandler } from "@/routes/connectors/show"
 
 export const connectorsRoutes = factory
   .createApp()
   .get("/", ...connectorsGroupHandler)
-  .get("/:name/call", ...connectorsCallHandler)
   .put("/:name/rename/:newName", ...connectorsRenameHandler)
   .put("/rename/:name/:newName", ...connectorsRenameHandler)
+  .post("/:name/schedules", ...connectorsSchedulesAddHandler)
+  .get("/:name/schedules", ...connectorsSchedulesGroupHandler)
+  .delete("/:name/schedules/:id", ...connectorsSchedulesRemoveHandler)
   .post("/:name", ...connectorsAddHandler)
   .put("/:name", ...connectorsSetHandler)
   .delete("/:name", ...connectorsRemoveHandler)

package/lib/routes/connectors/schedules-add.help.ts

@@ -0,0 +1,11 @@
+export const help = `funnel connectors <name> schedules add — add a schedule entry
+
+usage: funnel connectors <name> schedules add --cron "<expr>" --prompt "<text>" [--disabled]
+
+options:
+  --cron        5-field cron expression (min hour dom month dow)
+  --prompt      prompt text delivered to subscribing channels when the cron fires
+  --disabled    create the entry in disabled state
+
+example:
+  funnel connectors my-cron schedules add --cron "*/5 * * * *" --prompt "status check"`

package/lib/routes/connectors/schedules-add.ts

@@ -0,0 +1,33 @@
+import { z } from "zod"
+import { factory } from "@/factory"
+import { matchCron } from "@/modules/connectors/match-cron"
+import { zValidator } from "@/modules/router/validator"
+import { help } from "@/routes/connectors/schedules-add.help"
+
+export const connectorsSchedulesAddHandler = factory.createHandlers(
+  zValidator("param", z.object({ name: z.string() })),
+  zValidator(
+    "query",
+    z.object({
+      cron: z.string(),
+      prompt: z.string(),
+      disabled: z.string().optional(),
+    }),
+    help,
+  ),
+  (c) => {
+    const param = c.req.valid("param")
+    const query = c.req.valid("query")
+    const funnel = c.var.funnel
+
+    matchCron(query.cron, new Date())
+
+    const entry = funnel.schedule.addEntry(param.name, {
+      cron: query.cron,
+      prompt: query.prompt,
+      enabled: query.disabled !== "true",
+    })
+
+    return c.text(`added schedule entry "${entry.id}" to connector "${param.name}"`)
+  },
+)

package/lib/routes/connectors/schedules-group.help.ts

@@ -0,0 +1 @@
+export const help = `funnel connectors <name> schedules — list schedule entries`

package/lib/routes/connectors/schedules-group.ts

@@ -0,0 +1,38 @@
+import { HTTPException } from "hono/http-exception"
+import { z } from "zod"
+import { factory } from "@/factory"
+import { zValidator } from "@/modules/router/validator"
+import { help } from "@/routes/connectors/schedules-group.help"
+
+export const connectorsSchedulesGroupHandler = factory.createHandlers(
+  zValidator("param", z.object({ name: z.string() })),
+  zValidator("query", z.object({}), help),
+  (c) => {
+    const param = c.req.valid("param")
+    const funnel = c.var.funnel
+    const connector = funnel.connectors.get(param.name)
+
+    if (!connector) {
+      throw new HTTPException(404, { message: `connector "${param.name}" not found` })
+    }
+
+    if (connector.type !== "schedule") {
+      throw new HTTPException(400, {
+        message: `connector "${param.name}" is type "${connector.type}", not "schedule"`,
+      })
+    }
+
+    const entries = funnel.schedule.listEntries(param.name)
+
+    if (entries.length === 0) return c.text("no schedule entries")
+
+    const lines: string[] = []
+
+    for (const entry of entries) {
+      const status = entry.enabled ? "" : " (disabled)"
+      lines.push(`${entry.id}${status}  ${entry.cron}  ${entry.prompt}`)
+    }
+
+    return c.text(lines.join("\n"))
+  },
+)

package/lib/routes/connectors/schedules-remove.help.ts

@@ -0,0 +1,3 @@
+export const help = `funnel connectors <name> schedules remove — remove a schedule entry
+
+usage: funnel connectors <name> schedules remove <id>`

package/lib/routes/connectors/schedules-remove.ts

@@ -0,0 +1,17 @@
+import { z } from "zod"
+import { factory } from "@/factory"
+import { zValidator } from "@/modules/router/validator"
+import { help } from "@/routes/connectors/schedules-remove.help"
+
+export const connectorsSchedulesRemoveHandler = factory.createHandlers(
+  zValidator("param", z.object({ name: z.string(), id: z.string() })),
+  zValidator("query", z.object({}), help),
+  (c) => {
+    const param = c.req.valid("param")
+    const funnel = c.var.funnel
+
+    funnel.schedule.removeEntry(param.name, param.id)
+
+    return c.text(`removed schedule entry "${param.id}" from connector "${param.name}"`)
+  },
+)

package/lib/routes/connectors/set.ts

@@ -1,8 +1,28 @@
+import { HTTPException } from "hono/http-exception"
 import { z } from "zod"
 import { factory } from "@/factory"
 import { zValidator } from "@/modules/router/validator"
 import { help } from "@/routes/connectors/set.help"
 
+const SLACK_FIELDS = ["bot-token", "app-token"] as const
+const GH_FIELDS = ["poll-interval"] as const
+const DISCORD_FIELDS = ["bot-token"] as const
+
+const rejectExtraneous = (
+  query: Record<string, string | undefined>,
+  allowed: ReadonlyArray<string>,
+  type: string,
+): void => {
+  for (const key of ["bot-token", "app-token", "poll-interval"]) {
+    if (query[key] === undefined) continue
+    if (allowed.includes(key)) continue
+
+    throw new HTTPException(400, {
+      message: `connector type "${type}" does not accept --${key}`,
+    })
+  }
+}
+
 export const connectorsSetHandler = factory.createHandlers(
   zValidator("param", z.object({ name: z.string() })),
   zValidator(
@@ -19,11 +39,33 @@ export const connectorsSetHandler = factory.createHandlers(
     const query = c.req.valid("query")
     const funnel = c.var.funnel
 
-    funnel.connectors.update(param.name, {
-      botToken: query["bot-token"],
-      appToken: query["app-token"],
-      pollInterval: query["poll-interval"] ? Number(query["poll-interval"]) : undefined,
-    })
+    const current = funnel.connectors.get(param.name)
+
+    if (!current) {
+      throw new HTTPException(404, { message: `connector "${param.name}" not found` })
+    }
+
+    if (current.type === "slack") {
+      rejectExtraneous(query, SLACK_FIELDS, "slack")
+      funnel.connectors.updateSlack(param.name, {
+        botToken: query["bot-token"],
+        appToken: query["app-token"],
+      })
+    } else if (current.type === "gh") {
+      rejectExtraneous(query, GH_FIELDS, "gh")
+      funnel.connectors.updateGh(param.name, {
+        pollInterval: query["poll-interval"] ? Number(query["poll-interval"]) : undefined,
+      })
+    } else if (current.type === "discord") {
+      rejectExtraneous(query, DISCORD_FIELDS, "discord")
+      funnel.connectors.updateDiscord(param.name, {
+        botToken: query["bot-token"],
+      })
+    } else {
+      throw new HTTPException(400, {
+        message: `schedule connectors have no top-level fields — use schedules add/remove`,
+      })
+    }
 
     return c.text(`updated connector "${param.name}"`)
   },