@interactive-inc/claude-funnel 0.4.1 → 0.8.0

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

@@ -1,58 +1,65 @@
 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 { logger } from "@/modules/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"
-
-const CLAUDE_PID_DIR = join(FUNNEL_DIR, "claude")
+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
+  dir?: string
 }
 
 const defaultProcess = new NodeFunnelProcessRunner()
 const defaultFs = new NodeFunnelFileSystem()
-
+const defaultLogger = new NodeFunnelLogger()
+
+/**
+ * Launches Claude Code with funnel pre-wired: ensures the gateway is running,
+ * installs the funnel MCP into the target repo's `.mcp.json` if missing,
+ * injects `FUNNEL_CHANNEL_ID` into the child env, and writes a per-profile
+ * PID file to enforce singleton launches.
+ */
 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
+  private readonly pidDir: string
 
   constructor(deps: Deps) {
     this.channels = deps.channels
-    this.repositories = deps.repositories
     this.mcp = deps.mcp
     this.gateway = deps.gateway
     this.process = deps.process ?? defaultProcess
     this.fs = deps.fs ?? defaultFs
+    this.logger = deps.logger ?? defaultLogger
+    this.pidDir = join(deps.dir ?? FUNNEL_DIR, "claude")
     Object.freeze(this)
   }
 
   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`)
@@ -62,18 +69,16 @@ 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)
 
-      logger.info(`added funnel MCP to .mcp.json`, { cwd })
+      this.logger.info(`added funnel MCP to .mcp.json`, { cwd })
     }
 
     if (!this.gateway.isRunning()) {
-      logger.info(`starting gateway automatically`)
+      this.logger.info(`starting gateway automatically`)
       await this.gateway.start()
     }
 
@@ -83,11 +88,11 @@ export class FunnelClaude {
     }
 
     const claudeArgs = this.buildArgs(options, cwd)
-    const env = this.buildEnv(options, cwd)
+    const env = this.buildEnv(channel.id)
 
-    logger.info(`claude launch`, {
+    this.logger.info(`claude launch`, {
       channel: options.channel,
-      repo: options.repo,
+      channelId: channel.id,
       subAgent: options.subAgent,
       cwd,
     })
@@ -108,7 +113,7 @@ export class FunnelClaude {
   }
 
   private pidPath(profileName: string): string {
-    return join(CLAUDE_PID_DIR, `${profileName}.pid`)
+    return join(this.pidDir, `${profileName}.pid`)
   }
 
   private readPid(profileName: string): number | null {
@@ -129,7 +134,7 @@ export class FunnelClaude {
   }
 
   private writePidFile(profileName: string): void {
-    this.fs.mkdirSync(CLAUDE_PID_DIR, { recursive: true })
+    this.fs.mkdirSync(this.pidDir, { recursive: true })
     this.fs.writeFileSync(this.pidPath(profileName), String(globalThis.process.pid))
   }
 
@@ -140,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 {
@@ -179,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,11 +1,20 @@
 export type FileStat = {
   mtimeMs: number
+  /** POSIX mode bits (e.g. 0o600). `null` when the underlying FS does not expose mode. */
+  mode: number | null
 }
 
+/**
+ * Filesystem boundary used everywhere funnel reads or writes.
+ * Default is NodeFunnelFileSystem (real `node:fs`); MemoryFunnelFileSystem
+ * provides a sandbox for tests and embedded use.
+ */
 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/engine/id/id-generator.ts

@@ -0,0 +1,7 @@
+/**
+ * ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
+ * MemoryFunnelIdGenerator emits `<prefix>-1, <prefix>-2, ...` for deterministic tests.
+ */
+export abstract class FunnelIdGenerator {
+  abstract generate(): string
+}

package/lib/engine/id/memory-id-generator.ts

@@ -0,0 +1,20 @@
+import { FunnelIdGenerator } from "@/engine/id/id-generator"
+
+type Props = {
+  prefix?: string
+}
+
+export class MemoryFunnelIdGenerator extends FunnelIdGenerator {
+  private counter = 0
+  private readonly prefix: string
+
+  constructor(props: Props = {}) {
+    super()
+    this.prefix = props.prefix ?? "id"
+  }
+
+  generate(): string {
+    this.counter++
+    return `${this.prefix}-${this.counter}`
+  }
+}

package/lib/engine/id/node-id-generator.ts

@@ -0,0 +1,7 @@
+import { FunnelIdGenerator } from "@/engine/id/id-generator"
+
+export class NodeFunnelIdGenerator extends FunnelIdGenerator {
+  generate(): string {
+    return crypto.randomUUID()
+  }
+}

package/lib/engine/logger/logger.ts

@@ -0,0 +1,11 @@
+/**
+ * Structured logger with three levels and an optional log-file path.
+ * Defaults to NodeFunnelLogger (appends to /tmp/funnel/funnel.log);
+ * MemoryFunnelLogger captures entries in memory and NoopFunnelLogger silences output.
+ */
+export abstract class FunnelLogger {
+  abstract info(message: string, meta?: Record<string, unknown>): void
+  abstract warn(message: string, meta?: Record<string, unknown>): void
+  abstract error(message: string, meta?: Record<string, unknown>): void
+  abstract readonly file: string | null
+}

package/lib/engine/logger/memory-logger.ts

@@ -0,0 +1,28 @@
+import { FunnelLogger } from "@/engine/logger/logger"
+
+export type LogEntry = {
+  level: "info" | "warn" | "error"
+  message: string
+  meta?: Record<string, unknown>
+}
+
+export class MemoryFunnelLogger extends FunnelLogger {
+  readonly file = null
+  readonly entries: LogEntry[] = []
+
+  info(message: string, meta?: Record<string, unknown>): void {
+    this.entries.push({ level: "info", message, meta })
+  }
+
+  warn(message: string, meta?: Record<string, unknown>): void {
+    this.entries.push({ level: "warn", message, meta })
+  }
+
+  error(message: string, meta?: Record<string, unknown>): void {
+    this.entries.push({ level: "error", message, meta })
+  }
+
+  clear(): void {
+    this.entries.length = 0
+  }
+}

package/lib/engine/logger/node-logger.ts

@@ -0,0 +1,49 @@
+import { appendFileSync, mkdirSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { FunnelLogger } from "@/engine/logger/logger"
+
+const DEFAULT_LOG_FILE = join("/tmp/funnel", "funnel.log")
+
+type Level = "info" | "warn" | "error"
+
+type Props = {
+  file?: string
+  now?: () => Date
+}
+
+export class NodeFunnelLogger extends FunnelLogger {
+  readonly file: string
+  private readonly now: () => Date
+
+  constructor(props: Props = {}) {
+    super()
+    this.file = props.file ?? DEFAULT_LOG_FILE
+    this.now = props.now ?? (() => new Date())
+    Object.freeze(this)
+  }
+
+  info(message: string, meta?: Record<string, unknown>): void {
+    this.write("info", message, meta)
+  }
+
+  warn(message: string, meta?: Record<string, unknown>): void {
+    this.write("warn", message, meta)
+  }
+
+  error(message: string, meta?: Record<string, unknown>): void {
+    this.write("error", message, meta)
+  }
+
+  private write(level: Level, message: string, meta?: Record<string, unknown>): void {
+    mkdirSync(dirname(this.file), { recursive: true })
+
+    const entry = {
+      time: this.now().toISOString(),
+      level,
+      message,
+      ...(meta ? { meta } : {}),
+    }
+
+    appendFileSync(this.file, `${JSON.stringify(entry)}\n`)
+  }
+}

package/lib/engine/logger/noop-logger.ts

@@ -0,0 +1,9 @@
+import { FunnelLogger } from "@/engine/logger/logger"
+
+export class NoopFunnelLogger extends FunnelLogger {
+  readonly file = null
+
+  info(): void {}
+  warn(): void {}
+  error(): void {}
+}