@interactive-inc/claude-funnel 0.2.0

package/lib/modules/http/node-funnel-http-client.ts

@@ -0,0 +1,27 @@
+import {
+  FunnelHttpClient,
+  type HttpRequest,
+  type HttpResponse,
+} from "@/modules/http/funnel-http-client"
+
+export class NodeFunnelHttpClient extends FunnelHttpClient {
+  constructor() {
+    super()
+    Object.freeze(this)
+  }
+
+  async fetch(request: HttpRequest): Promise<HttpResponse> {
+    const res = await globalThis.fetch(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.body,
+    })
+
+    return {
+      status: res.status,
+      ok: res.ok,
+      text: () => res.text(),
+      json: () => res.json(),
+    }
+  }
+}

package/lib/modules/logger.ts

@@ -0,0 +1,26 @@
+import { appendFileSync, mkdirSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+const LOG_FILE = join("/tmp/funnel", "funnel.log")
+
+type Level = "info" | "warn" | "error"
+
+const write = (level: Level, message: string, meta?: Record<string, unknown>) => {
+  mkdirSync(dirname(LOG_FILE), { recursive: true })
+
+  const entry = {
+    time: new Date().toISOString(),
+    level,
+    message,
+    ...(meta ? { meta } : {}),
+  }
+
+  appendFileSync(LOG_FILE, `${JSON.stringify(entry)}\n`)
+}
+
+export const logger = {
+  info: (message: string, meta?: Record<string, unknown>) => write("info", message, meta),
+  warn: (message: string, meta?: Record<string, unknown>) => write("warn", message, meta),
+  error: (message: string, meta?: Record<string, unknown>) => write("error", message, meta),
+  file: LOG_FILE,
+}

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

@@ -0,0 +1,77 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import { FUNNEL_MCP_NAME } from "@/modules/mcp/funnel-mcp"
+
+const GATEWAY_WS_URL = process.env.FUNNEL_GATEWAY_URL ?? "ws://localhost:9742/ws"
+const RECONNECT_DELAY = 1000
+const MAX_RECONNECT_DELAY = 10000
+
+export const startChannelServer = async (): Promise<void> => {
+  const server = new Server(
+    { name: FUNNEL_MCP_NAME, version: "1.0.0" },
+    {
+      capabilities: {
+        experimental: { "claude/channel": {} },
+      },
+      instructions: [
+        `Events arrive inside <channel source="${FUNNEL_MCP_NAME}"> tags. Use meta.event_type to discriminate.`,
+        "",
+        'event_type="slack": a Slack message. meta includes channel_id, user_id, mentioned, thread_ts, etc. content is the Slack event JSON.',
+        'event_type="system": system event (connect / disconnect / startup, etc.).',
+      ].join("\n"),
+    },
+  )
+
+  const transport = new StdioServerTransport()
+
+  await server.connect(transport)
+
+  const channelId = process.env.FUNNEL_CHANNEL_ID
+
+  if (!channelId) return
+
+  const wsUrl = `${GATEWAY_WS_URL}?channel=${encodeURIComponent(channelId)}`
+  let reconnectDelay = RECONNECT_DELAY
+
+  const connect = () => {
+    const ws = new WebSocket(wsUrl)
+
+    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"
+
+        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/modules/mcp/funnel-mcp.ts

@@ -0,0 +1,107 @@
+import { join } from "node:path"
+import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
+
+export const FUNNEL_MCP_COMMAND = "funnel"
+export const FUNNEL_MCP_NAME = "funnel"
+
+type McpEntry = {
+  command?: string
+  args?: string[]
+}
+
+type McpConfig = {
+  mcpServers?: Record<string, McpEntry>
+}
+
+type Deps = {
+  fs?: FunnelFileSystem
+}
+
+const defaultFs = new NodeFunnelFileSystem()
+
+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 {}
+
+    try {
+      return JSON.parse(content) as McpConfig
+    } catch (error) {
+      throw new Error(
+        `invalid .mcp.json (${mcpPath}): ${error instanceof Error ? error.message : String(error)}`,
+      )
+    }
+  }
+
+  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/modules/process/funnel-process-runner.ts

@@ -0,0 +1,28 @@
+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>
+}
+
+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/modules/process/memory-funnel-process-runner.ts

@@ -0,0 +1,88 @@
+import {
+  type AttachOptions,
+  type DetachOptions,
+  FunnelProcessRunner,
+  type RunOptions,
+  type RunResult,
+} from "@/modules/process/funnel-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/modules/process/node-funnel-process-runner.ts

@@ -0,0 +1,100 @@
+import {
+  type AttachOptions,
+  type DetachOptions,
+  FunnelProcessRunner,
+  type RunOptions,
+  type RunResult,
+} from "@/modules/process/funnel-process-runner"
+
+const toEnv = (env?: Record<string, string>): Record<string, string> | undefined => {
+  if (!env) return undefined
+
+  return { ...(process.env as Record<string, string>), ...env }
+}
+
+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"],
+    })
+
+    const forward = (signal: "SIGINT" | "SIGTERM") => {
+      try {
+        proc.kill(signal)
+      } catch {
+        // ignore
+      }
+
+      setTimeout(() => {
+        try {
+          proc.kill("SIGKILL")
+        } catch {
+          // ignore
+        }
+      }, 3000).unref()
+    }
+
+    process.on("SIGINT", () => forward("SIGINT"))
+    process.on("SIGTERM", () => forward("SIGTERM"))
+
+    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/modules/repos/funnel-repositories.ts

@@ -0,0 +1,107 @@
+import type { FunnelMcp } from "@/modules/mcp/funnel-mcp"
+import { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
+import type { RepositoryConfig } from "@/modules/settings/settings-schema"
+
+type Deps = {
+  store: FunnelSettingsReader
+  mcp: FunnelMcp
+}
+
+export class FunnelRepositories {
+  private readonly store: FunnelSettingsReader
+  private readonly mcp: FunnelMcp
+
+  constructor(deps: Deps) {
+    this.store = deps.store
+    this.mcp = deps.mcp
+    Object.freeze(this)
+  }
+
+  list(): RepositoryConfig[] {
+    return this.store.read().repositories
+  }
+
+  get(name: string): RepositoryConfig | null {
+    return this.list().find((r) => r.name === name) ?? null
+  }
+
+  add(config: RepositoryConfig): void {
+    const settings = this.store.read()
+
+    if (settings.repositories.some((r) => r.name === config.name)) {
+      throw new Error(`repo "${config.name}" already exists`)
+    }
+
+    this.mcp.install(config.path)
+
+    settings.repositories.push(config)
+
+    this.store.write(settings)
+  }
+
+  remove(name: string): void {
+    const settings = this.store.read()
+
+    const index = settings.repositories.findIndex((r) => r.name === name)
+
+    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`)
+    }
+
+    const repo = settings.repositories[index]!
+
+    this.mcp.uninstall(repo.path)
+
+    settings.repositories.splice(index, 1)
+
+    this.store.write(settings)
+  }
+
+  rename(oldName: string, newName: string): void {
+    const settings = this.store.read()
+
+    const repo = settings.repositories.find((r) => r.name === oldName)
+
+    if (!repo) throw new Error(`repo "${oldName}" not found`)
+
+    if (settings.repositories.some((r) => r.name === newName)) {
+      throw new Error(`repo "${newName}" already exists`)
+    }
+
+    repo.name = newName
+
+    for (const agent of settings.agents) {
+      if (agent.repo === oldName) agent.repo = newName
+    }
+
+    this.store.write(settings)
+  }
+
+  update(name: string, fields: Partial<Pick<RepositoryConfig, "path">>): void {
+    const settings = this.store.read()
+
+    const repo = settings.repositories.find((r) => r.name === name)
+
+    if (!repo) throw new Error(`repo "${name}" not found`)
+
+    if (fields.path !== undefined && fields.path !== repo.path) {
+      this.mcp.uninstall(repo.path)
+
+      this.mcp.install(fields.path)
+
+      repo.path = fields.path
+    }
+
+    this.store.write(settings)
+  }
+
+  resolvePath(name: string): string {
+    const repo = this.get(name)
+
+    if (!repo) throw new Error(`repo "${name}" not found`)
+
+    return repo.path
+  }
+}

package/lib/modules/router/query-to-cli-args.ts

@@ -0,0 +1,20 @@
+const BUILTIN_SKIP = new Set(["help"])
+
+export const queryToCliArgs = (url: string, reservedKeys: string[] = []): string[] => {
+  const skipped = new Set([...BUILTIN_SKIP, ...reservedKeys])
+  const args: string[] = []
+  const searchParams = new URL(url).searchParams
+
+  for (const entry of searchParams.entries()) {
+    const key = entry[0]
+    const value = entry[1]
+
+    if (skipped.has(key)) continue
+
+    args.push(`--${key}`)
+
+    if (value !== "true") args.push(value)
+  }
+
+  return args
+}

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

@@ -0,0 +1,122 @@
+const SHORT_FLAGS: Record<string, string> = {
+  h: "help",
+  n: "name",
+}
+
+const STRIPPED_METHOD_KEYWORDS: Record<string, string> = {
+  add: "POST",
+  remove: "DELETE",
+  set: "PUT",
+  update: "PUT",
+}
+
+const KEPT_METHOD_KEYWORDS: Record<string, string> = {
+  rename: "PUT",
+  attach: "PUT",
+  detach: "DELETE",
+  default: "PUT",
+}
+
+const API_CALL_METHODS = new Set(["get", "post", "put", "patch", "delete", "head", "options"])
+
+const isValue = (arg: string | undefined): arg is string => {
+  return typeof arg === "string" && !arg.startsWith("-")
+}
+
+const consumeApiCall = (args: string[], i: number, params: URLSearchParams): number => {
+  params.set("method", args[i]!)
+
+  const nextPath = args[i + 1]
+
+  if (!isValue(nextPath)) return 1
+
+  params.set("path", nextPath)
+
+  const nextBody = args[i + 2]
+
+  if (!isValue(nextBody)) return 2
+
+  params.set("body", nextBody)
+
+  return 3
+}
+
+export const toRequest = (args: string[]) => {
+  const segments: string[] = []
+  const params = new URLSearchParams()
+  let method = "GET"
+
+  let i = 0
+  while (i < args.length) {
+    const arg = args[i]!
+
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2)
+      const next = args[i + 1]
+
+      if (isValue(next)) {
+        params.set(key, next)
+        i += 2
+      } else {
+        params.set(key, "true")
+        i++
+      }
+
+      continue
+    }
+
+    if (arg.startsWith("-") && arg.length === 2) {
+      const long = SHORT_FLAGS[arg[1]!]
+
+      if (!long) {
+        i++
+        continue
+      }
+
+      const next = args[i + 1]
+
+      if (isValue(next)) {
+        params.set(long, next)
+        i += 2
+      } else {
+        params.set(long, "true")
+        i++
+      }
+
+      continue
+    }
+
+    if (STRIPPED_METHOD_KEYWORDS[arg]) {
+      method = STRIPPED_METHOD_KEYWORDS[arg]!
+      i++
+      continue
+    }
+
+    if (KEPT_METHOD_KEYWORDS[arg]) {
+      method = KEPT_METHOD_KEYWORDS[arg]!
+      segments.push(arg)
+      i++
+      continue
+    }
+
+    if (API_CALL_METHODS.has(arg) && !params.has("method")) {
+      segments.push("call")
+      i += consumeApiCall(args, i, params)
+      continue
+    }
+
+    if (arg.includes("/") && !params.has("path")) {
+      params.set("path", arg)
+      i++
+      continue
+    }
+
+    segments.push(arg)
+    i++
+  }
+
+  const path = segments.length > 0 ? `/${segments.join("/")}` : "/"
+  const query = params.size > 0 ? `?${params}` : ""
+
+  return { method, path, url: `http://localhost${path}${query}` }
+}