@interactive-inc/claude-funnel 0.8.0 → 0.10.0

package/lib/cli/index.ts

@@ -0,0 +1,85 @@
+import pkg from "@/../package.json" with { type: "json" }
+import { startChannelServer } from "@/engine/mcp/channel-server"
+import { toRequest } from "@/cli/router/to-request"
+import { launchTui } from "@/tui/tui"
+import { createCliApp } from "@/cli/routes"
+import { Funnel } from "@/funnel"
+
+process.title = "funnel"
+
+const funnel = new Funnel()
+
+const app = createCliApp(funnel)
+
+const HELP = `funnel — Open Claude Funnel
+
+usage: funnel [command]
+
+commands:
+  (none)                launch TUI
+  claude                launch Claude Code (default profile or --profile)
+  channels              manage subscription boxes (and their nested connectors)
+  profiles              manage launch profiles
+  gateway               manage the gateway daemon (HTTP + WS)
+  status                show overall connection status
+  update                update funnel to the latest version
+  mcp                   run as an MCP server (invoked from .mcp.json)
+
+options:
+  --help, -h            show help
+  --version, -v         show version
+
+more: funnel <command> --help`
+
+const args = process.argv.slice(2)
+
+if (args.length === 0) {
+  await launchTui(funnel)
+  process.exit(0)
+}
+
+if (args[0] === "--version" || args[0] === "-v") {
+  process.stdout.write(`${pkg.version}\n`)
+  process.exit(0)
+}
+
+if (args[0] === "mcp") {
+  await startChannelServer({ dir: funnel.paths.dir })
+}
+
+if (args[0] !== "mcp") {
+  const { method, url } = toRequest(args)
+
+  const parsed = new URL(url)
+  
+  const wantsHelp = parsed.searchParams.has("help")
+
+  if (wantsHelp && parsed.pathname === "/") {
+    process.stdout.write(`${HELP}\n`)
+    process.exit(0)
+  }
+
+  const res = await app.request(url, { method })
+
+  if (res.ok) {
+    const body = await res.text()
+    if (body) process.stdout.write(`${body}\n`)
+    process.exit(0)
+  }
+
+  if (wantsHelp) {
+    const segments = parsed.pathname.split("/").filter(Boolean)
+    const group = segments[0]
+    const fallback = group
+      ? await app.request(`http://localhost/${group}?help=true`, { method: "GET" })
+      : null
+
+    const text = fallback?.ok ? await fallback.text() : HELP
+    process.stdout.write(`${text}\n`)
+    process.exit(0)
+  }
+
+  const text = await res.text()
+  if (text) process.stderr.write(`${text}\n`)
+  process.exit(1)
+}

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

@@ -13,6 +13,7 @@ const METHOD_KEYWORDS = new Set([
   "rename",
   "as-default",
   "request",
+  "publish",
 ])
 
 const API_CALL_METHODS = new Set(["get", "post", "put", "patch", "delete", "head", "options"])

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

@@ -0,0 +1,52 @@
+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/claude.ts

@@ -62,6 +62,7 @@ export const claudeHandler = factory.createHandlers(
       subAgent: profile.subAgent,
       userArgs: queryToCliArgs(c.req.url, RESERVED_KEYS),
       profileName: profile.name,
+      brief: profile.brief,
     })
 
     process.exit(exitCode)

package/lib/cli/routes/index.ts

@@ -32,6 +32,10 @@ import {
   channelsConnectorsSchedulesRemoveHandler,
   removeHelp as channelsConnectorsSchedulesRemoveHelp,
 } from "@/cli/routes/channels.$channel.connectors.$connector.schedules.remove.$id"
+import {
+  channelsPublishHandler,
+  publishHelp as channelsPublishHelp,
+} from "@/cli/routes/channels.$channel.publish"
 import {
   channelsRemoveHandler,
   removeHelp as channelsRemoveHelp,
@@ -75,30 +79,37 @@ import { statusHandler } from "@/cli/routes/status"
 import { updateHandler } from "@/cli/routes/update"
 import { Funnel } from "@/funnel"
 
-const base = factory.createApp()
+const helpRoute = (text: string) => factory.createHandlers((c) => c.text(text))
 
-base.use((c, next) => {
-  c.set("funnel", new Funnel())
+/**
+ * Build the CLI Hono app wired to a specific Funnel instance.
+ * Exposed so library consumers can mount the same routes their `fnl` CLI
+ * uses against a custom Funnel (e.g. one with sandboxed boundaries).
+ *
+ * All CLI verbs (`add` / `remove` / `set` / `rename` / `as-default` / `request`) map to POST in
+ * to-request.ts and stay in the URL as a literal segment. Read paths (list / show / launch) keep GET.
+ * Help shortcuts at parameterless URLs return the help text directly so `funnel <verb>` (no args) is
+ * informative instead of 404.
+ */
+export const createCliApp = (funnel: Funnel) => {
+  const base = factory.createApp()
 
-  return next()
-})
+  base.use((c, next) => {
+    c.set("funnel", funnel)
 
-base.onError((error, c) => {
-  if (error instanceof HTTPException) {
-    return c.text(`error: ${error.message}`, error.status)
-  }
+    return next()
+  })
 
-  return c.text(`error: ${error instanceof Error ? error.message : String(error)}`, 400)
-})
+  base.onError((error, c) => {
+    if (error instanceof HTTPException) {
+      return c.text(`error: ${error.message}`, error.status)
+    }
 
-const helpRoute = (text: string) => factory.createHandlers((c) => c.text(text))
+    return c.text(`error: ${error instanceof Error ? error.message : String(error)}`, 400)
+  })
 
-// All CLI verbs (`add` / `remove` / `set` / `rename` / `as-default` / `request`) map to POST in
-// to-request.ts and stay in the URL as a literal segment. Read paths (list / show / launch) keep GET.
-// Help shortcuts at parameterless URLs return the help text directly so `funnel <verb>` (no args) is
-// informative instead of 404.
-export const app = base
-  .get("/claude", ...claudeHandler)
+  return base
+    .get("/claude", ...claudeHandler)
   .get("/channels", ...channelsGroupHandler)
   .post("/channels/add", ...helpRoute(channelsAddHelp))
   .post("/channels/add/:channel", ...channelsAddHandler)
@@ -109,6 +120,8 @@ export const app = base
   .post("/channels/rename", ...helpRoute(channelsRenameHelp))
   .post("/channels/:channel/rename", ...helpRoute(channelsRenameHelp))
   .post("/channels/:channel/set/delivery/:mode", ...channelsSetDeliveryHandler)
+  .post("/channels/publish", ...helpRoute(channelsPublishHelp))
+  .post("/channels/:channel/publish", ...channelsPublishHandler)
   .get("/channels/:channel", ...channelsShowHandler)
   .get("/channels/:channel/connectors", ...channelsConnectorsGroupHandler)
   .post(
@@ -200,3 +213,7 @@ export const app = base
   .get("/gateway/listeners", ...gatewayListenersHandler)
   .get("/status", ...statusHandler)
   .get("/update", ...updateHandler)
+}
+
+/** CLI Hono app wired to a default `new Funnel()`. For embedding with a custom Funnel use `createCliApp`. */
+export const app = createCliApp(new Funnel())

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

@@ -5,12 +5,13 @@ 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>
+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)`
+  --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() })),
@@ -20,6 +21,7 @@ export const profilesAddHandler = factory.createHandlers(
       path: z.string(),
       "sub-agent": z.string(),
       channel: z.string(),
+      brief: z.coerce.boolean().optional(),
     }),
     addHelp,
   ),
@@ -39,6 +41,7 @@ export const profilesAddHandler = factory.createHandlers(
       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.set.$profile.ts

@@ -5,7 +5,7 @@ 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>]`
+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() })),
@@ -15,6 +15,8 @@ export const profilesSetHandler = factory.createHandlers(
       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,
   ),
@@ -23,22 +25,19 @@ export const profilesSetHandler = factory.createHandlers(
     const query = c.req.valid("query")
     const funnel = c.var.funnel
 
-    let channelId: string | undefined
+    const channel = query.channel !== undefined ? funnel.channels.get(query.channel) : null
 
-    if (query.channel !== undefined) {
-      const channel = funnel.channels.get(query.channel)
-
-      if (!channel) {
-        throw new HTTPException(400, { message: `channel "${query.channel}" not found` })
-      }
-
-      channelId = channel.id
+    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,
+      channelId: channel?.id,
+      ...(brief !== undefined ? { brief } : {}),
     })
 
     return c.text(`updated profile "${param.profile}"`)

package/lib/connectors/discord.ts

@@ -0,0 +1,4 @@
+export * from "@/connectors/discord-adapter"
+export * from "@/connectors/discord-connector-schema"
+export * from "@/connectors/discord-event-processor"
+export * from "@/connectors/discord-listener"

package/lib/connectors/gh.ts

@@ -0,0 +1,3 @@
+export * from "@/connectors/gh-adapter"
+export * from "@/connectors/gh-connector-schema"
+export * from "@/connectors/gh-listener"

package/lib/connectors/schedule.ts

@@ -0,0 +1,4 @@
+export * from "@/connectors/match-cron"
+export * from "@/connectors/schedule-connector-schema"
+export * from "@/connectors/schedule-listener"
+export * from "@/connectors/schedule-state-store"

package/lib/connectors/slack.ts

@@ -0,0 +1,4 @@
+export * from "@/connectors/slack-adapter"
+export * from "@/connectors/slack-connector-schema"
+export * from "@/connectors/slack-event-processor"
+export * from "@/connectors/slack-listener"

package/lib/engine/claude/claude.ts

@@ -16,6 +16,8 @@ export type LaunchOptions = {
   subAgent?: string
   userArgs?: string[]
   profileName?: string
+  /** Forward `--brief` to claude on launch (enables the SendUserMessage tool). */
+  brief?: boolean
 }
 
 type Deps = {
@@ -182,6 +184,10 @@ export class FunnelClaude {
       result.push("--agent", options.subAgent)
     }
 
+    if (options.brief && !result.includes("--brief")) {
+      result.push("--brief")
+    }
+
     return result
   }
 

package/lib/engine/mcp/channel-server.ts

@@ -1,4 +1,3 @@
-import { existsSync, readFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { join } from "node:path"
 import { Server } from "@modelcontextprotocol/sdk/server/index.js"
@@ -7,71 +6,36 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js"
+import { FunnelChannelSubscriber } from "@/engine/mcp/channel-subscriber"
 import { FUNNEL_MCP_NAME } from "@/engine/mcp/mcp"
-import { settingsSchema } from "@/engine/settings/settings-schema"
-
-const GATEWAY_BASE_URL = process.env.FUNNEL_GATEWAY_URL ?? "http://localhost:9742"
-const GATEWAY_WS_URL = `${GATEWAY_BASE_URL.replace(/^http/, "ws")}/ws`
-const RECONNECT_DELAY = 1000
-const MAX_RECONNECT_DELAY = 10000
-const SETTINGS_PATH = join(homedir(), ".funnel", "settings.json")
-const TOOL_CONNECTOR_TYPES = new Set(["slack", "gh", "discord"])
-
-const readGatewayToken = (): string | null => {
-  const fromEnv = process.env.FUNNEL_GATEWAY_TOKEN
-
-  if (fromEnv && fromEnv.length > 0) return fromEnv
-
-  const path = join(homedir(), ".funnel", "gateway.token")
-
-  if (!existsSync(path)) return null
-
-  const value = readFileSync(path, "utf-8").trim()
-
-  return value.length > 0 ? value : null
-}
-
-const readChannelConnectors = (
-  channelId: string,
-): { channelName: string; connectors: { name: string; type: string }[] } | null => {
-  if (!existsSync(SETTINGS_PATH)) return null
-
-  const raw = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"))
-  const parsed = settingsSchema.safeParse(raw)
-
-  if (!parsed.success) return null
-
-  const channel = parsed.data.channels.find((c) => c.id === channelId)
-
-  if (!channel) return null
-
-  const connectors = channel.connectors
-    .filter((c) => TOOL_CONNECTOR_TYPES.has(c.type))
-    .map((c) => ({ name: c.name, type: c.type }))
-
-  return { channelName: channel.name, connectors }
+import { readChannelConnectors } from "@/engine/mcp/read-channel-connectors"
+import { readGatewayToken } from "@/engine/mcp/read-gateway-token"
+import { usageHintForType } from "@/engine/mcp/usage-hint-for-type"
+
+const DEFAULT_FUNNEL_DIR = join(homedir(), ".funnel")
+const DEFAULT_GATEWAY_BASE_URL = "http://localhost:9742"
+
+export type ChannelServerOptions = {
+  /** Funnel home directory (settings.json + gateway.token). Defaults to ~/.funnel. */
+  dir?: string
+  /** Gateway base URL. Defaults to `$FUNNEL_GATEWAY_URL` or `http://localhost:9742`. */
+  gatewayUrl?: string
+  /** Channel id to subscribe to. Defaults to `$FUNNEL_CHANNEL_ID`. */
+  channelId?: string
+  /** Auth token. Defaults to `$FUNNEL_GATEWAY_TOKEN` then `<dir>/gateway.token`. */
+  token?: string
 }
 
-const usageHintForType = (type: string): string => {
-  if (type === "slack") {
-    return "Slack Web API. method=POST path=chat.postMessage body={channel,text,thread_ts?}"
-  }
-
-  if (type === "discord") {
-    return "Discord REST API. method=POST path=/channels/<id>/messages body={content,...}"
-  }
-
-  if (type === "gh") {
-    return "GitHub REST via gh CLI. method=POST path=repos/owner/repo/issues/N/comments body={body}"
-  }
-
-  return "Generic adapter call."
-}
-
-export const startChannelServer = async (): Promise<void> => {
-  const channelId = process.env.FUNNEL_CHANNEL_ID
-  const channel = channelId ? readChannelConnectors(channelId) : null
-  const token = readGatewayToken()
+export const startChannelServer = async (
+  options: ChannelServerOptions = {},
+): Promise<void> => {
+  const dir = options.dir ?? DEFAULT_FUNNEL_DIR
+  const gatewayBaseUrl =
+    options.gatewayUrl ?? process.env.FUNNEL_GATEWAY_URL ?? DEFAULT_GATEWAY_BASE_URL
+  const gatewayWsUrl = `${gatewayBaseUrl.replace(/^http/, "ws")}/ws`
+  const channelId = options.channelId ?? process.env.FUNNEL_CHANNEL_ID
+  const channel = channelId ? readChannelConnectors(dir, channelId) : null
+  const token = options.token ?? readGatewayToken(dir)
 
   const server = new Server(
     { name: FUNNEL_MCP_NAME, version: "1.0.0" },
@@ -121,7 +85,7 @@ export const startChannelServer = async (): Promise<void> => {
       throw new Error("`method` and `path` are required")
     }
 
-    const url = `${GATEWAY_BASE_URL}/channels/${encodeURIComponent(channel.channelName)}/connectors/${encodeURIComponent(connectorName)}/call`
+    const url = `${gatewayBaseUrl}/channels/${encodeURIComponent(channel.channelName)}/connectors/${encodeURIComponent(connectorName)}/call`
     const headers: Record<string, string> = { "content-type": "application/json" }
 
     if (token) headers.authorization = `Bearer ${token}`
@@ -149,56 +113,11 @@ export const startChannelServer = async (): Promise<void> => {
 
   if (!channelId) return
 
-  const baseUrl = `${GATEWAY_WS_URL}?channel=${encodeURIComponent(channelId)}`
-  const protocols = token ? [`funnel.token.${token}`] : undefined
-  let reconnectDelay = RECONNECT_DELAY
-  let lastOffset = 0
-
-  const connect = () => {
-    const sinceQuery = lastOffset > 0 ? `&since=${lastOffset}` : ""
-    const wsUrl = `${baseUrl}${sinceQuery}`
-    const ws = new WebSocket(wsUrl, protocols)
-
-    ws.addEventListener("open", () => {
-      reconnectDelay = RECONNECT_DELAY
-      process.stderr.write(`funnel: connected (${wsUrl})\n`)
-    })
-
-    ws.addEventListener("message", async (event) => {
-      try {
-        const payload = JSON.parse(String(event.data))
-        const eventType = payload.meta?.event_type ?? "unknown"
-
-        if (typeof payload.offset === "number" && payload.offset > lastOffset) {
-          lastOffset = payload.offset
-        }
-
-        process.stderr.write(`funnel: received event (${eventType})\n`)
-
-        await server.notification({
-          method: "notifications/claude/channel",
-          params: {
-            content: payload.content,
-            meta: payload.meta,
-          },
-        })
-      } catch (error) {
-        process.stderr.write(
-          `funnel: error: ${error instanceof Error ? error.message : String(error)}\n`,
-        )
-      }
-    })
-
-    ws.addEventListener("close", () => {
-      process.stderr.write(`funnel: disconnected, reconnecting in ${reconnectDelay}ms\n`)
-      setTimeout(connect, reconnectDelay)
-      reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY)
-    })
-
-    ws.addEventListener("error", () => {
-      // close handler will reconnect
-    })
-  }
+  const subscriber = new FunnelChannelSubscriber({
+    server,
+    baseUrl: `${gatewayWsUrl}?channel=${encodeURIComponent(channelId)}`,
+    protocols: token ? [`funnel.token.${token}`] : undefined,
+  })
 
-  connect()
+  subscriber.start()
 }

package/lib/engine/mcp/channel-subscriber.ts

@@ -0,0 +1,82 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js"
+
+const RECONNECT_DELAY = 1000
+const MAX_RECONNECT_DELAY = 10000
+
+type Props = {
+  server: Server
+  baseUrl: string
+  protocols: string[] | undefined
+}
+
+type State = {
+  reconnectDelay: number
+  lastOffset: number
+}
+
+/**
+ * Subscribes to the gateway WebSocket for a single channel and forwards
+ * incoming events to the MCP server as `notifications/claude/channel`.
+ * Reconnects with exponential backoff and replays missed events via `?since=<offset>`.
+ */
+export class FunnelChannelSubscriber {
+  private readonly state: State = { reconnectDelay: RECONNECT_DELAY, lastOffset: 0 }
+
+  constructor(private readonly props: Props) {
+    Object.freeze(this)
+  }
+
+  start(): void {
+    this.connect()
+  }
+
+  private connect(): void {
+    const sinceQuery = this.state.lastOffset > 0 ? `&since=${this.state.lastOffset}` : ""
+    const wsUrl = `${this.props.baseUrl}${sinceQuery}`
+    const ws = new WebSocket(wsUrl, this.props.protocols)
+
+    ws.addEventListener("open", () => {
+      this.state.reconnectDelay = RECONNECT_DELAY
+      process.stderr.write(`funnel: connected (${wsUrl})\n`)
+    })
+
+    ws.addEventListener("message", (event) => this.handleMessage(event))
+
+    ws.addEventListener("close", () => {
+      process.stderr.write(
+        `funnel: disconnected, reconnecting in ${this.state.reconnectDelay}ms\n`,
+      )
+      setTimeout(() => this.connect(), this.state.reconnectDelay)
+      this.state.reconnectDelay = Math.min(this.state.reconnectDelay * 2, MAX_RECONNECT_DELAY)
+    })
+
+    ws.addEventListener("error", () => {
+      // close handler will reconnect
+    })
+  }
+
+  private async handleMessage(event: MessageEvent): Promise<void> {
+    try {
+      const payload = JSON.parse(String(event.data))
+      const eventType = payload.meta?.event_type ?? "unknown"
+
+      if (typeof payload.offset === "number" && payload.offset > this.state.lastOffset) {
+        this.state.lastOffset = payload.offset
+      }
+
+      process.stderr.write(`funnel: received event (${eventType})\n`)
+
+      await this.props.server.notification({
+        method: "notifications/claude/channel",
+        params: {
+          content: payload.content,
+          meta: payload.meta,
+        },
+      })
+    } catch (error) {
+      process.stderr.write(
+        `funnel: error: ${error instanceof Error ? error.message : String(error)}\n`,
+      )
+    }
+  }
+}

package/lib/engine/mcp/read-channel-connectors.ts

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { settingsSchema } from "@/engine/settings/settings-schema"
+
+const TOOL_CONNECTOR_TYPES = new Set(["slack", "gh", "discord"])
+
+export type ChannelConnectorsView = {
+  channelName: string
+  connectors: { name: string; type: string }[]
+}
+
+export const readChannelConnectors = (
+  dir: string,
+  channelId: string,
+): ChannelConnectorsView | null => {
+  const settingsPath = join(dir, "settings.json")
+
+  if (!existsSync(settingsPath)) return null
+
+  const raw = JSON.parse(readFileSync(settingsPath, "utf-8"))
+  const parsed = settingsSchema.safeParse(raw)
+
+  if (!parsed.success) return null
+
+  const channel = parsed.data.channels.find((c) => c.id === channelId)
+
+  if (!channel) return null
+
+  const connectors = channel.connectors
+    .filter((c) => TOOL_CONNECTOR_TYPES.has(c.type))
+    .map((c) => ({ name: c.name, type: c.type }))
+
+  return { channelName: channel.name, connectors }
+}

package/lib/engine/mcp/read-gateway-token.ts

@@ -0,0 +1,16 @@
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+
+export const readGatewayToken = (dir: string): string | null => {
+  const fromEnv = process.env.FUNNEL_GATEWAY_TOKEN
+
+  if (fromEnv && fromEnv.length > 0) return fromEnv
+
+  const path = join(dir, "gateway.token")
+
+  if (!existsSync(path)) return null
+
+  const value = readFileSync(path, "utf-8").trim()
+
+  return value.length > 0 ? value : null
+}