@interactive-inc/claude-funnel 0.3.0 → 0.4.1

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/profiles/funnel-profiles.ts

@@ -69,6 +69,24 @@ export class FunnelProfiles {
     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()
 

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/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,7 +30,6 @@ export class FunnelSettingsStore extends FunnelSettingsReader {
   read(): Settings {
     if (!this.fs.existsSync(this.path)) {
       return {
-        connectors: [],
         channels: [],
         repositories: [],
         profiles: [],

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

@@ -2,7 +2,6 @@ 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: [],
   profiles: [],

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([]),
@@ -58,7 +25,6 @@ export const profileConfigSchema = z.object({
 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([]),
   profiles: z.array(profileConfigSchema).default([]),

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

@@ -3,6 +3,9 @@ import { connectorsAddHandler } from "@/routes/connectors/add"
 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"
 
@@ -11,6 +14,9 @@ export const connectorsRoutes = factory
   .get("/", ...connectorsGroupHandler)
   .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`