@interactive-inc/claude-funnel 0.7.1 → 0.8.0

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

@@ -1,30 +1,27 @@
 import { join } from "node:path"
-import type { FunnelChannels } from "@/modules/channels/funnel-channels"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
-import type { FunnelGateway } from "@/modules/gateway/funnel-gateway"
-import { FunnelLogger } from "@/modules/logger/funnel-logger"
-import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
-import type { FunnelMcp } from "@/modules/mcp/funnel-mcp"
-import { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
-import { NodeFunnelProcessRunner } from "@/modules/process/node-funnel-process-runner"
-import type { FunnelRepositories } from "@/modules/repos/funnel-repositories"
-import { FUNNEL_DIR } from "@/modules/settings/funnel-settings-store"
+import type { FunnelChannels } from "@/engine/channels/channels"
+import type { GatewayController } from "@/engine/claude/gateway-controller"
+import { FunnelFileSystem } from "@/engine/fs/file-system"
+import { NodeFunnelFileSystem } from "@/engine/fs/node-file-system"
+import { FunnelLogger } from "@/engine/logger/logger"
+import { NodeFunnelLogger } from "@/engine/logger/node-logger"
+import type { FunnelMcp } from "@/engine/mcp/mcp"
+import { FunnelProcessRunner } from "@/engine/process/process-runner"
+import { NodeFunnelProcessRunner } from "@/engine/process/node-process-runner"
+import { FUNNEL_DIR } from "@/engine/settings/settings-store"
 
 export type LaunchOptions = {
   channel: string
-  repo?: string
+  cwd?: string
   subAgent?: string
-  envFiles?: string[]
   userArgs?: string[]
   profileName?: string
 }
 
 type Deps = {
   channels: FunnelChannels
-  repositories: FunnelRepositories
   mcp: FunnelMcp
-  gateway: FunnelGateway
+  gateway: GatewayController
   process?: FunnelProcessRunner
   fs?: FunnelFileSystem
   logger?: FunnelLogger
@@ -43,9 +40,8 @@ const defaultLogger = new NodeFunnelLogger()
  */
 export class FunnelClaude {
   private readonly channels: FunnelChannels
-  private readonly repositories: FunnelRepositories
   private readonly mcp: FunnelMcp
-  private readonly gateway: FunnelGateway
+  private readonly gateway: GatewayController
   private readonly process: FunnelProcessRunner
   private readonly fs: FunnelFileSystem
   private readonly logger: FunnelLogger
@@ -53,7 +49,6 @@ export class FunnelClaude {
 
   constructor(deps: Deps) {
     this.channels = deps.channels
-    this.repositories = deps.repositories
     this.mcp = deps.mcp
     this.gateway = deps.gateway
     this.process = deps.process ?? defaultProcess
@@ -64,7 +59,7 @@ export class FunnelClaude {
   }
 
   async launch(options: LaunchOptions): Promise<number> {
-    const channel = this.channels.get(options.channel)
+    const channel = this.channels.get(options.channel) ?? this.channels.getById(options.channel)
 
     if (!channel) {
       throw new Error(`channel "${options.channel}" not found`)
@@ -74,9 +69,7 @@ export class FunnelClaude {
       throw new Error(`profile "${options.profileName}" is already running`)
     }
 
-    const cwd = options.repo
-      ? this.repositories.resolvePath(options.repo)
-      : globalThis.process.cwd()
+    const cwd = options.cwd ?? globalThis.process.cwd()
 
     if (!this.mcp.findInstalledName(cwd)) {
       this.mcp.install(cwd)
@@ -95,11 +88,11 @@ export class FunnelClaude {
     }
 
     const claudeArgs = this.buildArgs(options, cwd)
-    const env = this.buildEnv(options, cwd)
+    const env = this.buildEnv(channel.id)
 
     this.logger.info(`claude launch`, {
       channel: options.channel,
-      repo: options.repo,
+      channelId: channel.id,
       subAgent: options.subAgent,
       cwd,
     })
@@ -152,11 +145,12 @@ export class FunnelClaude {
   }
 
   private installCleanup(profileName: string): void {
-    const cleanup = () => this.removePidFile(profileName)
-
-    globalThis.process.once("exit", cleanup)
-    globalThis.process.once("SIGINT", cleanup)
-    globalThis.process.once("SIGTERM", cleanup)
+    // Default Bun behavior on SIGINT/SIGTERM is process.exit(130/143), which
+    // fires the "exit" event. Hooking only "exit" keeps the PID file cleanup
+    // running while letting the signal terminate the process normally —
+    // adding our own SIGINT handler would suppress the default exit and leave
+    // funnel hanging until claude responds.
+    globalThis.process.once("exit", () => this.removePidFile(profileName))
   }
 
   private isProcessAlive(pid: number): boolean {
@@ -191,35 +185,14 @@ export class FunnelClaude {
     return result
   }
 
-  private buildEnv(options: LaunchOptions, cwd: string): Record<string, string> {
-    const env: Record<string, string> = { ...globalThis.process.env } as Record<string, string>
-
-    if (options.envFiles) {
-      for (const file of options.envFiles) {
-        const filePath = `${cwd}/${file}`
-
-        if (!this.fs.existsSync(filePath)) continue
-
-        const content = this.fs.readFileSync(filePath)
-
-        for (const line of content.split("\n")) {
-          const trimmed = line.trim()
-
-          if (!trimmed || trimmed.startsWith("#")) continue
-
-          const eqIndex = trimmed.indexOf("=")
-
-          if (eqIndex < 0) continue
-
-          const key = trimmed.slice(0, eqIndex)
-          const value = trimmed.slice(eqIndex + 1).replace(/^["']|["']$/g, "")
+  private buildEnv(channelId: string): Record<string, string> {
+    const env: Record<string, string> = {}
 
-          env[key] = value
-        }
-      }
+    for (const [key, value] of Object.entries(globalThis.process.env)) {
+      if (typeof value === "string") env[key] = value
     }
 
-    env.FUNNEL_CHANNEL_ID = options.channel
+    env.FUNNEL_CHANNEL_ID = channelId
 
     return env
   }

package/lib/engine/claude/gateway-controller.ts

@@ -0,0 +1,4 @@
+export type GatewayController = {
+  isRunning(): boolean
+  start(options?: { caffeinate?: boolean }): Promise<boolean>
+}

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

@@ -1,5 +1,7 @@
 export type FileStat = {
   mtimeMs: number
+  /** POSIX mode bits (e.g. 0o600). `null` when the underlying FS does not expose mode. */
+  mode: number | null
 }
 
 /**
@@ -11,6 +13,8 @@ export abstract class FunnelFileSystem {
   abstract existsSync(path: string): boolean
   abstract readFileSync(path: string): string
   abstract writeFileSync(path: string, data: string): void
+  /** Write `data` and ensure the resulting file is owner-only (0600). Use for tokens and any file that may contain secrets. */
+  abstract writeSecretFileSync(path: string, data: string): void
   abstract appendFileSync(path: string, data: string): void
   abstract unlink(path: string): void
   abstract mkdirSync(path: string, options?: { recursive?: boolean }): void

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
   }