@interactive-inc/claude-funnel 0.7.1 → 0.8.1

package/lib/{modules/fs/memory-funnel-file-system.ts → engine/fs/memory-file-system.ts}

@@ -1,16 +1,20 @@
-import { type FileStat, FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+import { type FileStat, FunnelFileSystem } from "@/engine/fs/file-system"
 
 type Props = {
   dirs?: string[]
   files?: Record<string, string>
   mtimes?: Record<string, number>
+  modes?: Record<string, number>
   now?: () => number
 }
 
+const SECRET_MODE = 0o600
+
 export class MemoryFunnelFileSystem extends FunnelFileSystem {
   private readonly dirs: Set<string>
   private readonly files: Map<string, string>
   private readonly mtimes: Map<string, number>
+  private readonly modes: Map<string, number>
   private readonly now: () => number
 
   constructor(props: Props = {}) {
@@ -18,6 +22,7 @@ export class MemoryFunnelFileSystem extends FunnelFileSystem {
     this.dirs = new Set(props.dirs ?? [])
     this.files = new Map(Object.entries(props.files ?? {}))
     this.mtimes = new Map(Object.entries(props.mtimes ?? {}))
+    this.modes = new Map(Object.entries(props.modes ?? {}))
     this.now = props.now ?? (() => Date.now())
   }
 
@@ -34,6 +39,12 @@ export class MemoryFunnelFileSystem extends FunnelFileSystem {
     this.touch(path)
   }
 
+  writeSecretFileSync(path: string, data: string): void {
+    this.files.set(path, data)
+    this.modes.set(path, SECRET_MODE)
+    this.touch(path)
+  }
+
   appendFileSync(path: string, data: string): void {
     const prev = this.files.get(path) ?? ""
     this.files.set(path, prev + data)
@@ -43,9 +54,11 @@ export class MemoryFunnelFileSystem extends FunnelFileSystem {
   unlink(path: string): void {
     this.files.delete(path)
     this.mtimes.delete(path)
+    this.modes.delete(path)
   }
 
-  mkdirSync(path: string): void {
+  mkdirSync(path: string, options?: { recursive?: boolean }): void {
+    void options
     this.dirs.add(path)
   }
 
@@ -71,13 +84,17 @@ export class MemoryFunnelFileSystem extends FunnelFileSystem {
       throw new Error(`not found: ${path}`)
     }
 
-    return { mtimeMs }
+    return { mtimeMs, mode: this.modes.get(path) ?? null }
   }
 
   setMtime(path: string, mtimeMs: number): void {
     this.mtimes.set(path, mtimeMs)
   }
 
+  setMode(path: string, mode: number): void {
+    this.modes.set(path, mode)
+  }
+
   private touch(path: string): void {
     if (!this.mtimes.has(path)) this.mtimes.set(path, this.now())
     else this.mtimes.set(path, this.now())

package/lib/{modules/fs/node-funnel-file-system.ts → engine/fs/node-file-system.ts}

@@ -1,5 +1,6 @@
 import {
   appendFileSync,
+  chmodSync,
   existsSync,
   mkdirSync,
   readdirSync,
@@ -8,7 +9,9 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs"
-import { type FileStat, FunnelFileSystem } from "@/modules/fs/funnel-file-system"
+import { type FileStat, FunnelFileSystem } from "@/engine/fs/file-system"
+
+const SECRET_MODE = 0o600
 
 export class NodeFunnelFileSystem extends FunnelFileSystem {
   constructor() {
@@ -28,6 +31,15 @@ export class NodeFunnelFileSystem extends FunnelFileSystem {
     writeFileSync(path, data)
   }
 
+  writeSecretFileSync(path: string, data: string): void {
+    writeFileSync(path, data, { mode: SECRET_MODE })
+    try {
+      chmodSync(path, SECRET_MODE)
+    } catch {
+      // ignore — best-effort tightening for files that already existed with looser perms
+    }
+  }
+
   appendFileSync(path: string, data: string): void {
     appendFileSync(path, data)
   }
@@ -51,6 +63,6 @@ export class NodeFunnelFileSystem extends FunnelFileSystem {
   statSync(path: string): FileStat {
     const stat = statSync(path)
 
-    return { mtimeMs: stat.mtimeMs }
+    return { mtimeMs: stat.mtimeMs, mode: stat.mode & 0o777 }
   }
 }

package/lib/{modules/http/memory-funnel-http-client.ts → engine/http/memory-http-client.ts}

@@ -1,8 +1,4 @@
-import {
-  FunnelHttpClient,
-  type HttpRequest,
-  type HttpResponse,
-} from "@/modules/http/funnel-http-client"
+import { FunnelHttpClient, type HttpRequest, type HttpResponse } from "@/engine/http/http-client"
 
 export type MemoryHttpResponse = {
   status?: number

package/lib/{modules/http/node-funnel-http-client.ts → engine/http/node-http-client.ts}

@@ -1,8 +1,4 @@
-import {
-  FunnelHttpClient,
-  type HttpRequest,
-  type HttpResponse,
-} from "@/modules/http/funnel-http-client"
+import { FunnelHttpClient, type HttpRequest, type HttpResponse } from "@/engine/http/http-client"
 
 export class NodeFunnelHttpClient extends FunnelHttpClient {
   constructor() {

package/lib/{modules/id/memory-funnel-id-generator.ts → engine/id/memory-id-generator.ts}

@@ -1,4 +1,4 @@
-import { FunnelIdGenerator } from "@/modules/id/funnel-id-generator"
+import { FunnelIdGenerator } from "@/engine/id/id-generator"
 
 type Props = {
   prefix?: string

package/lib/{modules/id/node-funnel-id-generator.ts → engine/id/node-id-generator.ts}

@@ -1,4 +1,4 @@
-import { FunnelIdGenerator } from "@/modules/id/funnel-id-generator"
+import { FunnelIdGenerator } from "@/engine/id/id-generator"
 
 export class NodeFunnelIdGenerator extends FunnelIdGenerator {
   generate(): string {

package/lib/{modules/logger/memory-funnel-logger.ts → engine/logger/memory-logger.ts}

@@ -1,4 +1,4 @@
-import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { FunnelLogger } from "@/engine/logger/logger"
 
 export type LogEntry = {
   level: "info" | "warn" | "error"

package/lib/{modules/logger/node-funnel-logger.ts → engine/logger/node-logger.ts}

@@ -1,6 +1,6 @@
 import { appendFileSync, mkdirSync } from "node:fs"
 import { dirname, join } from "node:path"
-import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { FunnelLogger } from "@/engine/logger/logger"
 
 const DEFAULT_LOG_FILE = join("/tmp/funnel", "funnel.log")
 

package/lib/{modules/logger/noop-funnel-logger.ts → engine/logger/noop-logger.ts}

@@ -1,4 +1,4 @@
-import { FunnelLogger } from "@/modules/logger/funnel-logger"
+import { FunnelLogger } from "@/engine/logger/logger"
 
 export class NoopFunnelLogger extends FunnelLogger {
   readonly file = null

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

@@ -0,0 +1,204 @@
+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/{modules/mcp/funnel-mcp.ts → engine/mcp/mcp.ts}

@@ -1,18 +1,22 @@
 import { join } from "node:path"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
+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"
 
-type McpEntry = {
-  command?: string
-  args?: string[]
-}
+const mcpEntrySchema = z.object({
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+})
 
-type McpConfig = {
-  mcpServers?: Record<string, McpEntry>
-}
+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
@@ -95,13 +99,23 @@ export class FunnelMcp {
 
     if (!content) return {}
 
+    let parsed: unknown
+
     try {
-      return JSON.parse(content) as McpConfig
+      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 {

package/lib/{modules/process/memory-funnel-process-runner.ts → engine/process/memory-process-runner.ts}

@@ -4,7 +4,7 @@ import {
   FunnelProcessRunner,
   type RunOptions,
   type RunResult,
-} from "@/modules/process/funnel-process-runner"
+} from "@/engine/process/process-runner"
 
 export type MemoryProcessResponse = {
   exitCode?: number

package/lib/{modules/process/node-funnel-process-runner.ts → engine/process/node-process-runner.ts}

@@ -4,12 +4,22 @@ import {
   FunnelProcessRunner,
   type RunOptions,
   type RunResult,
-} from "@/modules/process/funnel-process-runner"
+} from "@/engine/process/process-runner"
 
 const toEnv = (env?: Record<string, string>): Record<string, string> | undefined => {
   if (!env) return undefined
 
-  return { ...(process.env as Record<string, string>), ...env }
+  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 {
@@ -59,25 +69,6 @@ export class NodeFunnelProcessRunner extends FunnelProcessRunner {
       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
   }
 

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

@@ -0,0 +1,7 @@
+/**
+ * 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/{modules/profiles/funnel-profiles.ts → engine/profiles/profiles.ts}

@@ -1,14 +1,21 @@
-import { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
-import type { ProfileConfig } from "@/modules/settings/settings-schema"
+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` (channel + repo + sub-agent + env files).
- * Implements ProfileChannelChecker / ProfileChannelRefUpdater so FunnelChannels
- * can validate references without depending on the FunnelProfiles concrete type.
+ * 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
@@ -26,6 +33,10 @@ export class FunnelProfiles {
     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()
 
@@ -33,12 +44,8 @@ export class FunnelProfiles {
       throw new Error(`profile "${config.name}" already exists`)
     }
 
-    if (!settings.channels.some((c) => c.name === config.channel)) {
-      throw new Error(`channel "${config.channel}" not found`)
-    }
-
-    if (config.repo && !settings.repositories.some((r) => r.name === config.repo)) {
-      throw new Error(`repo "${config.repo}" not found`)
+    if (!settings.channels.some((c) => c.id === config.channelId)) {
+      throw new Error(`channel id "${config.channelId}" not found`)
     }
 
     settings.profiles.push(config)
@@ -74,22 +81,26 @@ 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 {
+  asDefault(name: 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
-      }
-    }
+    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 (changed) this.store.write(settings)
+    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 {
@@ -99,29 +110,16 @@ export class FunnelProfiles {
 
     if (!profile) throw new Error(`profile "${name}" not found`)
 
-    if (fields.channel !== undefined) {
-      if (!settings.channels.some((c) => c.name === fields.channel)) {
-        throw new Error(`channel "${fields.channel}" not found`)
-      }
-
-      profile.channel = fields.channel
-    }
-
-    if (fields.repo !== undefined) {
-      if (fields.repo && !settings.repositories.some((r) => r.name === fields.repo)) {
-        throw new Error(`repo "${fields.repo}" 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.repo = fields.repo || undefined
+      profile.channelId = fields.channelId
     }
 
-    if (fields.subAgent !== undefined) {
-      profile.subAgent = fields.subAgent || undefined
-    }
-
-    if (fields.envFiles !== undefined) {
-      profile.envFiles = fields.envFiles
-    }
+    if (fields.path !== undefined) profile.path = fields.path
+    if (fields.subAgent !== undefined) profile.subAgent = fields.subAgent
 
     this.store.write(settings)
   }

package/lib/{modules/settings/mock-funnel-settings-reader.ts → engine/settings/mock-settings-reader.ts}

@@ -1,9 +1,10 @@
-import { FunnelSettingsReader } from "@/modules/settings/funnel-settings-reader"
-import type { Settings } from "@/modules/settings/settings-schema"
+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: [],
-  repositories: [],
   profiles: [],
   ...partial,
 })

package/lib/{modules/settings/funnel-settings-reader.ts → engine/settings/settings-reader.ts}

@@ -1,4 +1,4 @@
-import type { Settings } from "@/modules/settings/settings-schema"
+import type { Settings } from "@/engine/settings/settings-schema"
 
 export abstract class FunnelSettingsReader {
   abstract read(): Settings