@interactive-inc/claude-funnel 0.8.1 → 0.10.1

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

@@ -1,204 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-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 { 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 }
-}
-
-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()
-
-  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 = `${GATEWAY_BASE_URL}/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 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
-    })
-  }
-
-  connect()
-}

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/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
-}

package/lib/engine/profiles/profiles.ts

@@ -1,126 +0,0 @@
-import { FunnelSettingsReader } from "@/engine/settings/settings-reader"
-import type { ProfileConfig } from "@/engine/settings/settings-schema"
-
-type Deps = {
-  store: FunnelSettingsReader
-}
-
-/**
- * Named launch presets for `fnl claude`. Each profile bundles a working
- * directory, a sub-agent name, and the channel id its Claude instance will
- * subscribe to. Implements ProfileChannelChecker so FunnelChannels can refuse
- * to remove a channel that is still referenced.
- *
- * The first entry in the persisted array is treated as the default profile;
- * `asDefault` reorders the array to put a named profile first.
- *
- * `channelId` always stores the channel's stable id (uuid). CLI surfaces
- * resolve channel name → id before calling `add`/`update` here.
- */
-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
-  }
-
-  getDefault(): ProfileConfig | null {
-    return this.list()[0] ?? 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.id === config.channelId)) {
-      throw new Error(`channel id "${config.channelId}" 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)
-  }
-
-  asDefault(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`)
-
-    if (index === 0) return
-
-    const [profile] = settings.profiles.splice(index, 1)
-
-    if (!profile) return
-
-    settings.profiles.unshift(profile)
-
-    this.store.write(settings)
-  }
-
-  hasChannelRef(channelId: string): boolean {
-    return this.store.read().profiles.some((p) => p.channelId === channelId)
-  }
-
-  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.channelId !== undefined) {
-      if (!settings.channels.some((c) => c.id === fields.channelId)) {
-        throw new Error(`channel id "${fields.channelId}" not found`)
-      }
-
-      profile.channelId = fields.channelId
-    }
-
-    if (fields.path !== undefined) profile.path = fields.path
-    if (fields.subAgent !== undefined) profile.subAgent = fields.subAgent
-
-    this.store.write(settings)
-  }
-}

package/lib/engine/settings/mock-settings-reader.ts

@@ -1,27 +0,0 @@
-import { FunnelSettingsReader } from "@/engine/settings/settings-reader"
-import { SETTINGS_VERSION } from "@/engine/settings/settings-schema"
-import type { Settings } from "@/engine/settings/settings-schema"
-
-export const createSettings = (partial: Partial<Settings> = {}): Settings => ({
-  version: SETTINGS_VERSION,
-  channels: [],
-  profiles: [],
-  ...partial,
-})
-
-export class MockFunnelSettingsReader extends FunnelSettingsReader {
-  private state: Settings
-
-  constructor(initial?: Partial<Settings>) {
-    super()
-    this.state = createSettings(initial)
-  }
-
-  read(): Settings {
-    return this.state
-  }
-
-  write(settings: Settings): void {
-    this.state = settings
-  }
-}