@interactive-inc/claude-funnel 0.10.0 → 0.10.1

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

@@ -1,123 +0,0 @@
-import { homedir } from "node:os"
-import { join } from "node:path"
-import { Server } from "@modelcontextprotocol/sdk/server/index.js"
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js"
-import { FunnelChannelSubscriber } from "@/engine/mcp/channel-subscriber"
-import { FUNNEL_MCP_NAME } from "@/engine/mcp/mcp"
-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
-}
-
-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" },
-    {
-      capabilities: {
-        experimental: { "claude/channel": {} },
-        tools: {},
-      },
-      instructions: [
-        `Events arrive inside <channel source="${FUNNEL_MCP_NAME}"> tags. Use meta.event_type to discriminate.`,
-        "",
-        "To reply or act, call the connector tool exposed by this MCP (one tool per connector configured on this channel). Each tool takes { method, path, body } matching the underlying adapter's CallInput.",
-      ].join("\n"),
-    },
-  )
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const tools = (channel?.connectors ?? []).map((c) => ({
-      name: c.name,
-      description: `Call the "${c.name}" (${c.type}) connector. ${usageHintForType(c.type)}`,
-      inputSchema: {
-        type: "object" as const,
-        properties: {
-          method: { type: "string", description: "HTTP verb or API method (e.g. POST, chat.postMessage)" },
-          path: { type: "string", description: "API path or method name (adapter-specific)" },
-          body: { type: "object", description: "Request body / params (adapter-specific)" },
-        },
-        required: ["method", "path"],
-      },
-    }))
-
-    return { tools }
-  })
-
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    if (!channel) {
-      throw new Error("FUNNEL_CHANNEL_ID is not set or channel not found in settings.json")
-    }
-
-    const connectorName = request.params.name
-    const args = (request.params.arguments ?? {}) as Record<string, unknown>
-    const method = typeof args.method === "string" ? args.method : ""
-    const path = typeof args.path === "string" ? args.path : ""
-    const body = args.body ?? {}
-
-    if (!method || !path) {
-      throw new Error("`method` and `path` are required")
-    }
-
-    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}`
-
-    const res = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ method, path, body }),
-    })
-
-    const text = await res.text()
-
-    if (!res.ok) {
-      throw new Error(`gateway call failed (${res.status}): ${text}`)
-    }
-
-    return {
-      content: [{ type: "text", text }],
-    }
-  })
-
-  const transport = new StdioServerTransport()
-
-  await server.connect(transport)
-
-  if (!channelId) return
-
-  const subscriber = new FunnelChannelSubscriber({
-    server,
-    baseUrl: `${gatewayWsUrl}?channel=${encodeURIComponent(channelId)}`,
-    protocols: token ? [`funnel.token.${token}`] : undefined,
-  })
-
-  subscriber.start()
-}

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

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

@@ -1,126 +0,0 @@
-import { join } from "node:path"
-import { z } from "zod"
-import { FunnelFileSystem } from "@/engine/fs/file-system"
-import { NodeFunnelFileSystem } from "@/engine/fs/node-file-system"
-
-export const FUNNEL_MCP_COMMAND = "funnel"
-export const FUNNEL_MCP_NAME = "funnel"
-
-const mcpEntrySchema = z.object({
-  command: z.string().optional(),
-  args: z.array(z.string()).optional(),
-})
-
-const mcpConfigSchema = z.object({
-  mcpServers: z.record(z.string(), mcpEntrySchema).optional(),
-})
-
-type McpEntry = z.infer<typeof mcpEntrySchema>
-type McpConfig = z.infer<typeof mcpConfigSchema>
-
-type Deps = {
-  fs?: FunnelFileSystem
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-
-/**
- * Installs/uninstalls the funnel MCP entry into a target repository's
- * `.mcp.json`. Detects an existing entry by command match so renaming is
- * preserved across re-installs.
- */
-export class FunnelMcp {
-  private readonly fs: FunnelFileSystem
-
-  constructor(deps: Deps = {}) {
-    this.fs = deps.fs ?? defaultFs
-    Object.freeze(this)
-  }
-
-  install(repoPath: string): void {
-    if (!this.fs.existsSync(repoPath)) {
-      throw new Error(`repository does not exist: ${repoPath}`)
-    }
-
-    const config = this.readConfig(repoPath)
-    const servers = config.mcpServers ?? {}
-
-    const existingName = this.findServerName(servers)
-    const targetName = existingName ?? FUNNEL_MCP_NAME
-
-    servers[targetName] = {
-      command: FUNNEL_MCP_COMMAND,
-      args: ["mcp"],
-    }
-
-    this.writeConfig(repoPath, { ...config, mcpServers: servers })
-  }
-
-  uninstall(repoPath: string): void {
-    if (!this.fs.existsSync(repoPath)) return
-
-    const config = this.readConfig(repoPath)
-    const servers = config.mcpServers ?? {}
-
-    const name = this.findServerName(servers)
-
-    if (!name) return
-
-    const next = { ...servers }
-
-    delete next[name]
-
-    this.writeConfig(repoPath, { ...config, mcpServers: next })
-  }
-
-  findInstalledName(cwd: string): string | null {
-    const config = this.readConfig(cwd)
-
-    return this.findServerName(config.mcpServers ?? {})
-  }
-
-  private findServerName(servers: Record<string, McpEntry>): string | null {
-    for (const entry of Object.entries(servers)) {
-      const name = entry[0]
-      const value = entry[1]
-
-      if (value?.command === FUNNEL_MCP_COMMAND) return name
-    }
-
-    return null
-  }
-
-  private readConfig(repoPath: string): McpConfig {
-    const mcpPath = join(repoPath, ".mcp.json")
-
-    if (!this.fs.existsSync(mcpPath)) return {}
-
-    const content = this.fs.readFileSync(mcpPath).trim()
-
-    if (!content) return {}
-
-    let parsed: unknown
-
-    try {
-      parsed = JSON.parse(content)
-    } catch (error) {
-      throw new Error(
-        `invalid .mcp.json (${mcpPath}): ${error instanceof Error ? error.message : String(error)}`,
-      )
-    }
-
-    const result = mcpConfigSchema.safeParse(parsed)
-
-    if (!result.success) {
-      throw new Error(`invalid .mcp.json (${mcpPath}): ${result.error.message}`)
-    }
-
-    return result.data
-  }
-
-  private writeConfig(repoPath: string, config: McpConfig): void {
-    const mcpPath = join(repoPath, ".mcp.json")
-
-    this.fs.writeFileSync(mcpPath, `${JSON.stringify(config, null, 2)}\n`)
-  }
-}

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

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

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

package/lib/engine/mcp/usage-hint-for-type.ts

@@ -1,15 +0,0 @@
-export 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."
-}

package/lib/engine/process/memory-process-runner.ts

@@ -1,88 +0,0 @@
-import {
-  type AttachOptions,
-  type DetachOptions,
-  FunnelProcessRunner,
-  type RunOptions,
-  type RunResult,
-} from "@/engine/process/process-runner"
-
-export type MemoryProcessResponse = {
-  exitCode?: number
-  stdout?: string
-  stderr?: string
-}
-
-export type MemoryProcessHandler = (
-  command: string[],
-) => MemoryProcessResponse | Promise<MemoryProcessResponse>
-
-export type MemoryProcessSyncHandler = (command: string[]) => MemoryProcessResponse
-
-export type MemoryProcessCall =
-  | { kind: "run"; command: string[]; options: RunOptions }
-  | { kind: "runSync"; command: string[] }
-  | { kind: "attach"; command: string[]; options: AttachOptions }
-  | { kind: "detach"; command: string[]; options: DetachOptions }
-  | { kind: "kill"; command: string[] }
-
-const empty: MemoryProcessResponse = { exitCode: 0, stdout: "", stderr: "" }
-
-export class MemoryFunnelProcessRunner extends FunnelProcessRunner {
-  readonly calls: MemoryProcessCall[] = []
-  readonly killed: { pid: number; signal: string }[] = []
-  private handler: MemoryProcessHandler = () => empty
-  private syncHandler: MemoryProcessSyncHandler = () => empty
-
-  on(handler: MemoryProcessHandler): this {
-    this.handler = handler
-
-    return this
-  }
-
-  onSync(handler: MemoryProcessSyncHandler): this {
-    this.syncHandler = handler
-
-    return this
-  }
-
-  async run(command: string[], options: RunOptions = {}): Promise<RunResult> {
-    this.calls.push({ kind: "run", command, options })
-
-    const result = await this.handler(command)
-
-    return {
-      exitCode: result.exitCode ?? 0,
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? "",
-    }
-  }
-
-  runSync(command: string[]): RunResult {
-    this.calls.push({ kind: "runSync", command })
-
-    const result = this.syncHandler(command)
-
-    return {
-      exitCode: result.exitCode ?? 0,
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? "",
-    }
-  }
-
-  async attach(command: string[], options: AttachOptions = {}): Promise<number> {
-    this.calls.push({ kind: "attach", command, options })
-
-    const result = await this.handler(command)
-
-    return result.exitCode ?? 0
-  }
-
-  detach(command: string[], options: DetachOptions = {}): void {
-    this.calls.push({ kind: "detach", command, options })
-  }
-
-  kill(pid: number, signal: string = "SIGTERM"): void {
-    this.calls.push({ kind: "kill", command: [String(pid), signal] })
-    this.killed.push({ pid, signal })
-  }
-}

package/lib/engine/process/node-process-runner.ts

@@ -1,91 +0,0 @@
-import {
-  type AttachOptions,
-  type DetachOptions,
-  FunnelProcessRunner,
-  type RunOptions,
-  type RunResult,
-} from "@/engine/process/process-runner"
-
-const toEnv = (env?: Record<string, string>): Record<string, string> | undefined => {
-  if (!env) return undefined
-
-  const merged: Record<string, string> = {}
-
-  for (const [key, value] of Object.entries(process.env)) {
-    if (typeof value === "string") merged[key] = value
-  }
-
-  for (const [key, value] of Object.entries(env)) {
-    merged[key] = value
-  }
-
-  return merged
-}
-
-export class NodeFunnelProcessRunner extends FunnelProcessRunner {
-  constructor() {
-    super()
-    Object.freeze(this)
-  }
-
-  runSync(command: string[]): RunResult {
-    const result = Bun.spawnSync(command, {
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    return {
-      exitCode: result.exitCode ?? 0,
-      stdout: result.stdout.toString(),
-      stderr: result.stderr.toString(),
-    }
-  }
-
-  async run(command: string[], options: RunOptions = {}): Promise<RunResult> {
-    const proc = Bun.spawn(command, {
-      cwd: options.cwd,
-      env: toEnv(options.env),
-      stdin: options.input !== undefined ? "pipe" : "ignore",
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    if (options.input !== undefined && proc.stdin) {
-      proc.stdin.write(options.input)
-      proc.stdin.end()
-    }
-
-    const exitCode = await proc.exited
-    const stdout = await new Response(proc.stdout).text()
-    const stderr = await new Response(proc.stderr).text()
-
-    return { exitCode, stdout, stderr }
-  }
-
-  async attach(command: string[], options: AttachOptions = {}): Promise<number> {
-    const proc = Bun.spawn(command, {
-      cwd: options.cwd,
-      env: toEnv(options.env),
-      stdio: ["inherit", "inherit", "inherit"],
-    })
-
-    return await proc.exited
-  }
-
-  detach(command: string[], options: DetachOptions = {}): void {
-    const proc = Bun.spawn(command, {
-      env: toEnv(options.env),
-      stdio: ["ignore", "ignore", "ignore"],
-    })
-
-    proc.unref()
-  }
-
-  kill(pid: number, signal: string = "SIGTERM"): void {
-    try {
-      process.kill(pid, signal)
-    } catch {
-      // ignore
-    }
-  }
-}

package/lib/engine/process/process-runner.ts

@@ -1,33 +0,0 @@
-export type RunOptions = {
-  cwd?: string
-  env?: Record<string, string>
-  input?: string
-}
-
-export type RunResult = {
-  exitCode: number
-  stdout: string
-  stderr: string
-}
-
-export type AttachOptions = {
-  cwd?: string
-  env?: Record<string, string>
-}
-
-export type DetachOptions = {
-  env?: Record<string, string>
-}
-
-/**
- * Process boundary covering one-shot runs, sync runs, foreground attach, and
- * detached background spawns. Default is NodeFunnelProcessRunner (Bun.spawn);
- * MemoryFunnelProcessRunner records calls and lets tests stub responses.
- */
-export abstract class FunnelProcessRunner {
-  abstract run(command: string[], options?: RunOptions): Promise<RunResult>
-  abstract runSync(command: string[]): RunResult
-  abstract attach(command: string[], options?: AttachOptions): Promise<number>
-  abstract detach(command: string[], options?: DetachOptions): void
-  abstract kill(pid: number, signal?: string): void
-}

package/lib/engine/profiles/profile-channel-checker.ts

@@ -1,7 +0,0 @@
-/**
- * Read-side dependency that lets FunnelChannels ask whether a profile
- * references a given channel id, without depending on FunnelProfiles directly.
- */
-export type ProfileChannelChecker = {
-  hasChannelRef(channelId: string): boolean
-}